SRM149_DIV2

继续继续~

250

简单的一道题就是String.format的各种参数用法

public class FormatAmt {
    public String amount(int dollars, int cents) {
        return String.format("$%,d.%02d", dollars, cents);
    }
}

---

500

很简单的一个题，就是先存个上个顾客离开时间，之后就判断下

public class BigBurger {
    public int maxWait(int[] arrival, int[] service) {
        int result = 0;
        int pre_leave = 0;
        for (int i = 0; i < arrival.length; i++) {
            if (arrival[i] >= pre_leave) {
                pre_leave = arrival[i] + service[i];
            } else {
                result = Math.max(result, pre_leave - arrival[i]);
                pre_leave += service[i];
            }
        }
        return result;
    }
}

---

1000

两种解法，首先第一种就遍历所有4个价格复杂度就是$n^5$

public class Pricing {
    public int maxSales(int[] price) {
        Arrays.sort(price);
        int ret = 0;
        for(int i = 0; i<price.length; i++){
            for(int j = i; j<price.length; j++){
                for(int k = j; k<price.length; k++){
                    for(int m = k; m<price.length; m++){
                        int rev = 0;
                        for(int n = 0; n<price.length; n++){
                            if(price[n]>=price[m]){
                                rev+=price[m];
                            }else if(price[n]>=price[k]){
                                rev+=price[k];
                            }else if(price[n]>=price[j]){
                                rev+=price[j];
                            }else if(price[n]>=price[i]){
                                rev+=price[i];
                            }
                        }
                        ret=Math.max(ret,rev);
                    }
                }
            }
        }
        return ret;
    }
}

第二种解法就是动态规划，动态规划就是建立一个大大的情况矩阵，矩阵中有的边缘是确定的数，有一个递推公式可以确定整个矩阵。像是这个问题来说，有个序列。不妨从序列的尾巴开始不停的延长序列。
而对应的情况矩阵呢，列就是序列的起点位置，最后一行都是0咯。行left表示用了多少个价格区间0~4个咯，价格区间如果是0那也全是0咯。矩阵就是用来记录以前的结果，这样子计算就可以根据以前的递推。这个里边就是go函数了
pos就是其实位置，left就是用了几个价格区间，之后也是遍历来着pos往后滑动，这个滑动窗口都是一个区间，滑动窗口后面的就是历史结果了。递归调用咯。

import java.util.Arrays;

public class Pricing {
    int[][] memo;
    int[] v;
    int n;
    public int maxSales(int[] price) {
        v = price;
        n = v.length;
        for (int i = 0; i < n; i++) {
            v[i] = -v[i];
        }
        Arrays.sort(v);
        for (int i = 0; i < n; i++) {
            v[i] = -v[i];
        }
        memo = new int[n][5];
        for (int[] x : memo) {
            Arrays.fill(x, -1);
        }
        return go(0, 4);
    }

    private int go(int pos, int left) {
        if (left == 0) {
            return 0;
        }
        if (pos == n) {
            return 0;
        }
        if (memo[pos][left] != -1) {
            return memo[pos][left];
        }
        int ans = 0;
        for (int i = pos; i < n; i++) {
            ans = Math.max(ans, (i - pos + 1) * v[i] + go(i + 1, left - 1));
        }
        return memo[pos][left] = ans;
    }
}