1.字典序最小的字符串连接方案

题意：给定一个由字符串组成的数组strs，必须把所有的字符串拼接起来，返回所有可能的拼接结果中字典序最小的结果。

public static class MyCom implements Comparator<String>{

    @Override
    public int compare(String a, String b) {
        return (a+b).compareTo(b+a);
    }
}
public static String lowestString(String[] strs){
    if(strs==null|| strs.length==0){
        return "";
    }
    Arrays.sort(strs,new MyCom());
    String res="";
    for (int i = 0; i < strs.length; i++) {
        res+=strs[i];
    }
    return res;
}

2.点灯问题

给定一个字符串str，只由’X’和’.'两种字符构成
‘X’表示墙，不能放灯，也不需要点亮；’.'表示居民点，可以放灯，需要点亮
如果灯放在i位置，可以让i-1，i和i+1三个位置被点亮
返回如果点亮str中所有需要点亮的位置，至少需要几盏灯

public static int minLight(String road){
    char[] str=road.toCharArray();
    int i=0;
    int light=0;
    while(i<str.length){
        if(str[i]=='X'){
            i++;
        }else{
            light++;
            if(i+1==str.length){
                break;
            }else{
                if(str[i+1]=='X'){
                    i=i+2;
                }else{
                    i=i+3;
                }
            }
        }
    }
    return light;
}

3.分金条问题

题意：一块金条切成两半，是需要花费和长度数值一样的铜板
比如长度为20的金条，不管怎么切都要花费20个铜板，一群人想整分整块金条，怎么分最省铜板?
例如，给定数组{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 int lessMoney(int[] arr) {
    PriorityQueue<Integer> pq=new PriorityQueue<>();
    for (int i = 0; i < arr.length; i++) {
        pq.add(arr[i]);
    }
    int sum=0;
    int cur=0;
    while(pq.size()>1){
        cur=pq.poll()+pq.poll();
        sum+=cur;
        pq.add(cur);
    }
    return sum;
}

4.会议的最多安排

题意：一些项目要占用一个会议室宣讲，会议室不能同时容纳两个项目的宣讲，给你每一个项目开始的时间和结束的时间。你来安排宣讲的日程，要求会议室进行的宣讲的场次最多，返回最多的宣讲场次.

public static int bestArrange(Program[] programs){
    Arrays.sort(programs,new ProgramComparator());
    int timeLine=0;
    int result=0;
    for (int i = 0; i < programs.length; i++) {
        if(timeLine<=programs[i].start){
            result++;
            timeLine=programs[i].end;
        }
    }
    return result;
}

5.IPO问题

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

public static class Program {
    public int p;
    public int c;

    public Program(int p, int c) {
        this.p = p;
        this.c = c;
    }
}

//利润降序
public static class MaxProfitComparator implements Comparator<Program> {
    @Override
    public int compare(Program o1, Program o2) {
        return o2.p - o1.p;
    }
}

//花费升序
public static class MinCostComparator implements Comparator<Program> {

    @Override
    public int compare(Program o1, Program o2) {
        return o1.c - o2.c;
    }
}

public static int findMaximizedCapital(int k, int w, int[] profits, int[] capitals) {
    PriorityQueue<Program> minCost = new PriorityQueue<>(new MinCostComparator());
    PriorityQueue<Program> maxPro = new PriorityQueue<>(new MaxProfitComparator());
    for (int i = 0; i < profits.length; i++) {
        minCost.add(new Program(profits[i], capitals[i]));
    }
    for (int i = 0; i < k; i++) {
        while (!minCost.isEmpty() && minCost.peek().c <= w) {
            maxPro.add(minCost.poll());
        }
        if (maxPro.isEmpty()) {
            return w;
        }
        w += maxPro.poll().p;
    }
    return w;

}