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个价格复杂度就是n5

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
>=price[m]){
rev+=price[m];
}else if(price
>=price[k]){
rev+=price[k];
}else if(price
>=price[j]){
rev+=price[j];
}else if(price
>=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
[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;
}
}