左神算法第七节课：前缀树，贪心策略（字符串数组拼接，切割金条，代价利润），数据流中位数，举办宣讲会场数最多

1.何为前缀树？TrieTree

在计算机科学中，trie，又称前缀树或字典树，是一种有序树，用于保存关联数组，其中的键通常是字符串。与二叉查找树不同，键不是直接保存在节点中，而是由节点在树中的位置决定。一个节点的所有子孙都有相同的前缀，也就是这个节点对应的字符串，而根节点对应空字符串。一般情况下，不是所有的节点都有对应的值，只有叶子节点和部分内部节点所对应的键才有相关的值。

trie中的键通常是字符串，但也可以是其它的结构。

举例：

当有四个字符串时：“abc”，”bce”，”abd”，”bef”.下图中：边上的是字符，树内的数字是以当前字符结尾的字符串有多少个。比如，加入”bef”后，f后面的数字就由0-->1，再加入”be”后，‘e’处的数值就由0变成了1；求：有多少个字符串以“be”做为前缀？直接找到“be”处的'e'的数字即可。

/*
 * 前缀树，查看两个字符串数组内元素；
 */
public class Code_01_TrieTree {

    public static class TrieNode {
        public int path;//经过该节点的次数
        public int end;//以该节点为结尾的字符串的个数;
        public TrieNode[] nexts;
        public TrieNode() {
            path = 0;
            end = 0;
            nexts = new TrieNode[26];//26个字母对应0--25下标
        }
    }
    
    public static class Trie {
        private TrieNode root;//根节点
        public Trie() {
            root = new TrieNode();
        }
        
        public void insert(String word) {
            if (word == null) {
                return;
            }
            char[] chs = word.toCharArray();
            TrieNode node = root;
            int index = 0;
            for (int i = 0; i < chs.length; i++) {
                index = chs[i]-'a';//将字母对应成下标
                if (node.nexts[index] == null) {
                    node.nexts[index] = new TrieNode();
                }
                node = node.nexts[index];
                node.path++;
            }
            node.end++;    
        }
        
        public void delete(String word) {
            if (search(word) != 0) {
                char[] chs = word.toCharArray();
                int index = 0;
                TrieNode node = root;
                for (int i = 0; i < chs.length; i++) {
                    index = chs[i] - 'a';
                    if (--node.nexts[index].path == 0) {
                        node.nexts[index] = null;
                        return;
                    }
                    node = node.nexts[index];
                }
                node.end--;
            }
        }
        
        public int search(String word) {
            if (word == null) {
                return 0;
            }
            char[] chs = word.toCharArray();
            int index = 0;
            TrieNode node = root;
            for (int i = 0; i < chs.length; i++) {
                index = chs[i] - 'a';
                if (node.nexts[index] == null) {
                    return 0;
                }
                node = node.nexts[index];
            }
            return node.end;            
        }
    }
    
    
    
    public static void main(String[] args) {
        test();

    }



    private static void test() {
        Trie trie = new Trie();
        System.out.println(trie.search("zuo"));
        trie.insert("zuo");
        System.out.println(trie.search("zuo"));
        trie.delete("zuo");
        System.out.println(trie.search("zuo"));
        trie.insert("zuo");
        trie.insert("zuo");
        trie.delete("zuo");
        System.out.println(trie.search("zuo"));
        trie.delete("zuo");
        System.out.println(trie.search("zuo"));
        trie.insert("zuoa");
        trie.insert("zuoac");
        trie.insert("zuoab");
        trie.insert("zuoad");
        trie.delete("zuoa");
        System.out.println(trie.search("zuoa"));
        System.out.println(trie.search("zuoac"));
        System.out.println(trie.search("zuoab"));
        System.out.println(trie.search("zuoad"));
    }

}

2.字符串数组拼接—贪心策略

（对数器小样本测，不纠结证明过程）

字符串数组，将各字符串拼接，使得最低词典顺序。如：“ab”,“cd”,“ef”,拼接成“abcdef”最小，其他方式都比它大。到这里可能想到排序，再拼接，有一种情况是，“b”和“ba”拼接，排序后是“b”，“ba”,拼接后是“b ba”，但是按照“b ab”拼接的话，更小，故刚才对字符串按照字典的排序进行拼接是不对的。所以排序策略需要改变一下。

对str1,str2排序：

原先的拼接策略是：str1<=str2,str1放前，否则str2放前；

改进后拼接策略是：str1+str2<=str2+str1，str1放前，否则str2放前；

证明过程：

证明排序的传递性：a.b表示a后拼接b，拼接后可以看成a在高位，b在低位，a.b表示a是向左移动了b的长度个位数再加上b。a.b可以看成是k进制的拼接，即a*K^b长度+b，令

K^b长度=m(b)，故a.b=a*m(b)+b；

 

                                

/*
 * 给定一个字符串类型的数组strs，找到一种拼接方式，使得把所
 * 有字 符串拼起来之后形成的字符串具有最低的字典序。
 */
public class Code_05_LowestLexicography {

    public static class MyComparator implements Comparator<String>{
        @Override
        public int compare(String o1, String o2) {
            return (o1+o2).compareTo(o2+o1);
        }        
    }
    public static String lowestString(String[] strs) {
        if (strs == null || strs.length < 1) {
            return null;
        }
        Arrays.sort(strs, new MyComparator());
        String res = "";
        for (int i = 0; i < strs.length; i++) {
            res = res + strs[i] + "-";
        }
        return res;
    }
    
    private static void test() {
        String[] strs1 = { "jibw", "ji", "jp", "bw", "jibw" };
        System.out.println(lowestString(strs1));

        String[] strs2 = { "ba", "b" };
        System.out.println(lowestString(strs2));
        
    }
    public static void main(String[] args) {
        test();
    }

}

在这里：

3. 切割金条问题—贪心策略

一块金条切成两半，是需要花费和长度数值一样的铜板的。比如长度为20的 金条，不管切成长度多大的两半，都要花费20个铜板。一群人想整分整块金 条，怎么分最省铜板？例如,给定数组{10,20,30}，代表一共三个人，整块金条长度为10+20+30=60. 金条要分成10,20,30三个部分。 如果先把长度60的金条分成10和50，花费60 再把长度50的金条分成20和30，花费50 一共花费110铜板。但是如果， 先把长度60的金条分成30和30，花费60 再把长度30金条分成10和20，花费30 一共花费90铜板。输入一个数组，返回分割的最小代价。

思路：通过定义不同的比较器，来实现不同的堆。该题利用最小堆，每次从堆里找出最小的两个数，合并之后再插入堆中，依次循环，直至堆中只剩下一个数停止。其实本质是哈夫曼问题。

 

public static class MinHeapComparator implements Comparator<Integer>{
        @Override
        public int compare(Integer o1, Integer o2) {
            // TODO Auto-generated method stub
            return o1.compareTo(o2);//负数第一个前
        }        
    }
    
    public static int lessMoney(int[] arr) {
        int sum = 0;
        if (arr == null || arr .length <1) {
            return 0;
        }
        PriorityQueue<Integer> pq = new PriorityQueue<>(new MinHeapComparator());
        for (int i = 0; i < arr.length; i++) {
            pq.add(arr[i]);
        }
        int temp = 0;
        while (pq.size() > 1) {
            temp = pq.poll() + pq.poll();
            sum += temp;
            pq.add(temp);
        }
        
        return sum;
    }

4. 代价利润问题—贪心策略

给定两个数组，Costs[…….]和Profits[…....]，数组大小相等，一次只能做一个项目，一共最多做k个项目，初始资金W，求最大收益（钱剩下多少）。

输入：参数1，正数数组costs；参数2，正数数组profits；参数3，正数k；参数4，正数m。costs[i]表示第i个项目的花费，profits[i]表示第i个项目在扣除花费之后还能挣到的钱(利润)，k表示你不能并行、只能串行的最多做k个项目，m表示你初始的资金。说明：你每做完一个项目，马上获得的收益，可以支持你去做下一个项目。

输出：你最后获得的最大钱数。

思路：运用小根堆+大根堆，把所有项目按照cost放入小根堆中，然后从小根堆中取出所有比此时的总钱小的项目放入按照profit排序的大根堆，意思是利用现在的钱将能做的项目都放入大根堆，然后从大根堆中每次取出一个栈顶项目（利润最大项目），然后再将总钱数增加，再去小根堆里找出所有比当前总钱数要少的项目，依次循环，直至大根堆里没有项目。

/*
 给定两个数组，Costs[…….]和Profits[…....]，数组大小相等，一次只能做一个项目，
  一共最多做k个项目，初始资金W，求最大收益（钱剩下多少）。
输入：参数1，正数数组costs 参数2，正数数组profits 参数3，正数k 参数4，正数m。
    costs[i]表示第i个项目的花费，profits[i]表示第i个项目在扣除花费之后还能挣到的钱(利润)，
    k表示你不能并行、只能串行的最多做k个项目，m表示你初始的资金。
    说明：你每做完一个项目，马上获得的收益，可以支持你去做下一个项目。
输出： 你最后获得的最大钱数。

 */
public class Code_03_IPO {

    public static class Node{
        public int cost;
        public int profit;
        public Node(int c, int p){
            cost = c;
            profit = p;
        }
    }
    
    public static class MinHeapComparator implements Comparator<Node>{
        @Override
        public int compare(Node o1, Node o2) {
            return o1.cost-o2.cost;//负数第一个前
        }        
    }
    public static class MaxHeapComparator implements Comparator<Node>{
        @Override
        public int compare(Node o1, Node o2) {
            return o2.profit-o1.profit;//负数第一个前
        }        
    }
    public static int findMaximizedCapital(int k, int W, int[] Profits, int[] Capital) {        
        if (Profits == null || Capital == null || Profits.length < 1 || Capital.length < 1) {
            return W ;
        }
        Node[] nodes = new Node[Profits.length];
        for (int i = 0; i < Profits.length; i++) {
            nodes[i] = new Node(Profits[i], Capital[i]);
        }
        PriorityQueue<Node> minPQ = new PriorityQueue<>(new MinHeapComparator());
        PriorityQueue<Node> maxPQ = new PriorityQueue<>(new MaxHeapComparator());
        for (int i = 0; i < nodes.length; i++) {
            minPQ.add(nodes[i]);
        }
        int time = 0;
        while (time < k) {
            while(!minPQ.isEmpty() && minPQ.peek().cost < W) {
                maxPQ.add(minPQ.poll());
            }
            if (maxPQ.isEmpty()) {
                return W;
            }
            W+=maxPQ.poll().profit;
            time++;
        }
        return W;
    }    
    public static void main(String[] args) {
    }
}

自己做：带输入输出

public class Code_03_IPO1 {

    public static class MyMinComparator implements Comparator<projest>{

        @Override
        public int compare(projest o1, projest o2) {
            return o1.cost-o2.cost;
        }
        
    }
    public static class MyMaxComparator implements Comparator<projest>{

        @Override
        public int compare(projest o1, projest o2) {
            return o2.profit-o1.profit;
        }
        
    }
    
    public static class projest {
        int cost;
        int profit;
        public projest(int c,int p) {
            this.cost = c;
            this.profit = p;
        }
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String costStr = sc.nextLine();
//        System.out.println("999");
        String profitStr = sc.nextLine();
//        System.out.println("888");
        int k = sc.nextInt();
        int m = sc.nextInt();
        String[] costs = costStr.split(" ");
        String[] profits = profitStr.split(" ");
        int[] cost = new int[costs.length];
        int[] profit = new int[profits.length];
        projest[] ps = new projest[cost.length];
        for (int i = 0; i < profit.length; i++) {
            cost[i] = Integer.valueOf(costs[i]);
            profit[i] = Integer.valueOf(profits[i]);
            ps[i] = new projest(cost[i], profit[i]);
        }
        
        Queue<projest> minQueue = new PriorityQueue<projest>(new MyMinComparator());
        Queue<projest> maxQueue = new PriorityQueue<projest>(new MyMaxComparator());
        for (int i = 0; i < ps.length; i++) {
            minQueue.add(ps[i]);
        }
        int k1 = 0;
        while (!minQueue.isEmpty() || !maxQueue.isEmpty()) {
            while (!minQueue.isEmpty() && minQueue.peek().cost<=m) {
                maxQueue.add(minQueue.poll());
            }
            if (k1<k) {
                m += maxQueue.poll().profit;
                k1++;
            }else {
                break;
            }
        }
        System.out.println(m);

    }

}

5. 求数据流中的中位数

如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。

思路：一个大根堆，一个小根堆。小根堆里放的是较大的数，大根堆里放的是较小的数，然后每次进来的数与小根堆的堆顶相比较，再记一个变量记录当前进来的数是第几个，如果是序号是奇数。

public class Code_04_MadianQuick {

    public static class MyMinComparator implements Comparator<Integer> {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o1.compareTo(o2);
        }        
    }
    public static class MyMaxComparator implements Comparator<Integer> {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2.compareTo(o1);
        }    
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] dataStr = sc.nextLine().split(" ");
        int[] datas = new int[dataStr.length];
        for (int i = 0; i < datas.length; i++) {
            datas[i] = Integer.valueOf(dataStr[i]);
        }
        
        Queue<Integer> minQueue = new PriorityQueue<Integer>(new MyMinComparator());
        Queue<Integer> maxQueue = new PriorityQueue<Integer>(new MyMaxComparator());
        
        for (int i = 0; i < datas.length; i++) {
            if (maxQueue.isEmpty()) {
                maxQueue.add(datas[i]);
                continue;
            }
            if (maxQueue.peek()>=datas[i]) {
                maxQueue.add(datas[i]);
            }else {
                if (minQueue.isEmpty()) {
                    minQueue.add(datas[i]);
                    continue;
                }
                if (minQueue.peek()<datas[i]) {
                    minQueue.add(datas[i]);
                }else {
                    maxQueue.add(datas[i]);
                }
            }
            //调整堆的大小
            if (maxQueue.size() == minQueue.size()+2) {
                minQueue.add(maxQueue.poll());
            }
            if (maxQueue.size() == minQueue.size()-2) {
                maxQueue.add(minQueue.poll());
            }        
        }//endfor
        //取中位数
        if ((datas.length&1)==0) {//偶数
            System.out.printf("%.6f",(maxQueue.peek()+minQueue.peek())/2.0);
        }else {
            System.out.println(maxQueue.size()>minQueue.size()?maxQueue.peek():minQueue.peek());
        }
    }
}

另：保留小数点后几位的三种写法：

6. 求举办宣讲会场最多—贪心策略

一些项目要占用一个会议室宣讲，会议室不能同时容纳两个项目的宣讲。 给你每一个项目开始的时间和结束的时间(给你一个数组，里面 是一个个具体的项目)，你来安排宣讲的日程，要求会议室进行 的宣讲的场次最多。返回这个最多的宣讲场次。

其中一种： 按照开始时间最早，错！按照每个持续的时间长短，也不行。

正确思路：按照结束时间的早晚。找出最早结束的项目，然后过滤掉因该项目而不能举办的项目，依次循环。

public class Code_06_BestArrange1 {
    
    public static class Program {
        int start;
        int end;
        public Program(int start, int end) {
            this.start = start;
            this.end = end;
        }
    }
    
    public static class MyComparator implements Comparator<Program> {
        @Override
        public int compare(Program o1, Program o2) {
            return o1.end-o2.end;//小根堆
        }        
    }
    //左神写
    public static int bestArrange(Program[] programs,int cur) {
        Arrays.sort(programs, new MyComparator());
        int count = 0;
        for (int i = 0; i < programs.length; i++) {
            if (cur <= programs[i].start) {
                cur = programs[i].end;
                System.out.println(programs[i].start+"---"+programs[i].end);
            }            
        }
        return 0;
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] startStr = sc.nextLine().split(" ");
        String[] endStr = sc.nextLine().split(" ");
        int[] start = new int[startStr.length];
        int[] end = new int[endStr.length];
        Program[] programs = new Program[end.length];
        for (int i = 0; i < end.length; i++) {
            start[i] = Integer.valueOf(startStr[i]);
            end[i] = Integer.valueOf(endStr[i]);
            programs[i] = new Program(start[i], end[i]);
        }
        Queue<Program> queue = new PriorityQueue<Program>(new MyComparator());
        for (int i = 0; i < programs.length; i++) {
            queue.add(programs[i]);
        }
        while (!queue.isEmpty()) {
            Program pTemp = queue.poll();
//            System.out.println(pTemp.start+"--"+pTemp.end);
            while (!queue.isEmpty() && queue.peek().start<pTemp.end) {
                queue.poll();
            }
        }
        //法2
        bestArrange(programs,0);
    }
}

结果：