Codeforces Round #577 (Div. 2)
题目链接：https://codeforces.com/contest/1201
A - Important Exam
送分题。
B - Zero Array
题意：给一个数组，每次选两个不同位置的数字，然后同时-1。问是否能全部变成0。
题解：好像做过。首先和必须是偶数，其次最大的数字不能超过和的一半，这两个显然是必要条件，但是为什么这样就充分了呢？貌似可以归纳，每次取最大和次大同时-1，问题会变成和-2的，且最大的数字依然不超过和的一半的子问题，因为新的最大值要么是原本的最大值-1，要么原本有至少3个值都是原本的最大值，两种情况下新的最大值都不会超过和的一半。即：已知sum>=3x，求证x<=(sum-2)/2。显然当sum>=6时上式成立，当sum<6时，枚举掉这种情况即可。
void test_case() {
int n;
scanf("%d", &n);
ll sum = 0, maxa = 0;
while(n--) {
ll x;
scanf("%lld", &x);
sum += x;
maxa = max(maxa, x);
}
if(sum % 2 == 1 || maxa > sum / 2)
puts("NO");
else
puts("YES");
}
C - Maximum Median
题意：给一个奇数个数的数组，每次操作可以把一个数字+1，求最多k次操作能变到的最大的中位数。
题解：很明显有二分的做法：枚举中位数x，需要把中间及其之后的所有小于x的数变成x，求出这个花费是否超过k，求花费的时候还要再进行一次二分，带两个log。
int n, k, mid;
int a[200005];
ll sum[200005];
bool check(int x) {
int pos = lower_bound(a + 1, a + 1 + n, x) - a;
--pos;
if(pos < mid)
return 1;
int cnt = pos - mid + 1;
ll cost = 1ll * (pos - mid + 1) * x - (sum[pos] - sum[mid - 1]);
return cost <= k;
}
void test_case() {
scanf("%d%d", &n, &k);
for(int i = 1; i <= n; ++i)
scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
for(int i = 1; i <= n; ++i)
sum[i] = sum[i - 1] + a[i];
mid = (n + 1) / 2;
int L = a[mid], R = a[mid] + k;
while(1) {
int M = (L + R) >> 1;
if(L == M) {
if(L == R || check(R)) {
printf("%d\n", R);
return;
}
printf("%d\n", L);
return;
}
if(check(M))
L = M;
else
R = M - 1;
}
}
但是居然T了。卡一下常数试试。最后发现是二分的时候加法溢出了。
int n, k, mid;
int a[200005];
ll sum[200005];
bool check(ll x) {
int pos = lower_bound(a + 1, a + 1 + n, x) - a;
--pos;
if(pos < mid)
return 1;
ll cost = 1ll * (pos - mid + 1) * x - (sum[pos] - sum[mid - 1]);
return cost <= k;
}
void test_case() {
scanf("%d%d", &n, &k);
for(int i = 1; i <= n; ++i)
scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
for(int i = 1; i <= n; ++i)
sum[i] = sum[i - 1] + a[i];
mid = (n + 1) / 2;
ll L = a[mid], R = a[mid] + k;
while(1) {
ll M = (L + R) >> 1;
if(L == M) {
if(L == R || check(R)) {
printf("%d\n", R);
return;
}
printf("%d\n", L);
return;
}
if(check(M))
L = M;
else
R = M - 1;
}
}
启示：上了1e9的都用ll比较好，说不定哪天就溢出了。在二分lower_bound的时候起点其实不一定要是1，直接从mid开始也可以，不过也就快了一次？
挑战一下主体部分线性的做法，因为这题自带一个排序，所以本身的一个log是逃不掉的，思路是一次把相等的一段数字全部吃进来，然后求中位数到当前这段数字的和，加上k之后除以这段数字的个数，就得到了中位数的大小tmp。需要注意的是tmp不能超过a[r+1]，因为假如超过了就应该把下一段也吃进来，这个tmp也不能小于a[r]，否则就说明中位数不能到达a[r]（意思是要把a[r]的一部分分给前面的数才使得大家都是tmp，这是不对的）。
int n, k;
ll a[200005];
void test_case() {
scanf("%d%d", &n, &k);
for(int i = 1; i <= n; ++i)
scanf("%lld", &a[i]);
sort(a + 1, a + 1 + n);
int mid = (n + 1) / 2;
ll sum = 0, ans = a[mid];
for(int l = mid, r; l <= n; l = r + 1) {
for(r = l; r + 1 <= n && a[r + 1] == a[l]; ++r);
for(int j = l; j <= r; ++j)
sum += a[j];
ll tmp = (k + sum) / (r - mid + 1);
if(tmp < a[r])
break;
if(r != n)
tmp = min(a[r + 1], tmp);
ans = max(ans, tmp);
}
printf("%lld\n", ans);
}
*D - Treasure Hunting
题意：有个n*m的迷宫，从左下角开始走，迷宫中有一些宝物，要用最少的步数收集所有的宝物。每次移动只能向左向右或者向上移动，其中只有在某些安全列才能向上移动。
题解：看起来就很dp，先去掉最高的有宝物的层，那么收集完一层之后，必定从某个安全列去往下一层，那么到达上层的每个安全列的最小步数是可以直接转移出来的。易知搜集完某层的宝物之后，分别从两侧的安全列其中之一去往上层是最优的解法。且每层的最左边或者最右边的宝物是最后被收集的，所以真正有用的安全列只有最多4个。最后特殊处理一下顶层。
特别注意并不是从上一层的安全列上来之后就直接到某个端点，而应该先走到另一个端点。
int n, m, k, q;
int L[200005], R[200005];
int LS[200005], RS[200005];
struct DP {
int pos;
ll val;
DP(int pos = 0, ll val = 0): pos(pos), val(val) {}
} dp1[15], dp2[15];
int dp1top, dp2top;
void test_case() {
scanf("%d%d%d%d", &n, &m, &k, &q);
int top = 0;
while(k--) {
int r, c;
scanf("%d%d", &r, &c);
top = max(top, r);
if(L[r] == 0) {
L[r] = c;
R[r] = c;
} else {
L[r] = min(L[r], c);
R[r] = max(R[r], c);
}
}
for(int i = 1, b; i <= q; ++i) {
scanf("%d", &b);
LS[b] = b;
RS[b] = b;
}
for(int j = 1; j <= m; ++j) {
if(LS[j] == 0)
LS[j] = LS[j - 1];
}
for(int j = m; j >= 1; --j) {
if(RS[j] == 0)
RS[j] = RS[j + 1];
}
if(top == 1) {
printf("%d\n", R[1] - 1);
return;
}
dp1top = 0;
if(R[1] == 0)
dp1[++dp1top] = DP(RS[1], RS[1] - 1 + 1);
else {
if(LS[R[1]])
dp1[++dp1top] = DP(LS[R[1]], R[1] - 1 + R[1] - LS[R[1]] + 1);
if(RS[R[1]])
dp1[++dp1top] = DP(RS[R[1]], RS[R[1]] - 1 + 1);
}
for(int t = 2; t < top; ++t) {
if(L[t] == 0) {
for(int i = 1; i <= dp1top; ++i)
dp1[i].val += 1;
continue;
}
dp2top = 0;
ll Lminval = LINF;
for(int i = 1; i <= dp1top; ++i) {
ll dis = dp1[i].pos >= R[t] ? dp1[i].pos - L[t] : R[t] - dp1[i].pos + R[t] - L[t];
Lminval = min(Lminval, dp1[i].val + dis);
}
if(LS[L[t]])
dp2[++dp2top] = DP(LS[L[t]], Lminval + L[t] - LS[L[t]] + 1);
if(RS[L[t]])
dp2[++dp2top] = DP(RS[L[t]], Lminval + RS[L[t]] - L[t] + 1);
ll Rminval = LINF;
for(int i = 1; i <= dp1top; ++i) {
ll dis = dp1[i].pos <= L[t] ? R[t] - dp1[i].pos : dp1[i].pos - L[t] + R[t] - L[t];
Rminval = min(Rminval, dp1[i].val + dis);
}
if(LS[R[t]])
dp2[++dp2top] = DP(LS[R[t]], Rminval + R[t] - LS[R[t]] + 1);
if(RS[R[t]])
dp2[++dp2top] = DP(RS[R[t]], Rminval + RS[R[t]] - R[t] + 1);
dp1top = dp2top;
for(int i = 1; i <= dp2top; ++i)
dp1[i] = dp2[i];
}
ll Lminval = LINF;
for(int i = 1; i <= dp1top; ++i) {
ll dis = dp1[i].pos >= R[top] ? dp1[i].pos - L[top] : R[top] - dp1[i].pos + R[top] - L[top];
Lminval = min(Lminval, dp1[i].val + dis);
}
ll Rminval = LINF;
for(int i = 1; i <= dp1top; ++i) {
ll dis = dp1[i].pos <= L[top] ? R[top] - dp1[i].pos : dp1[i].pos - L[top] + R[top] - L[top];
Rminval = min(Rminval, dp1[i].val + dis);
}
printf("%lld\n", min(Lminval, Rminval));
}
