A. Shell Game（Codeforces 777A）
思路
为了更好地找到解题关键，先将小球随杯子运动的轨迹画在纸上。具体地，假设初始状态球在杯子
1
中。在纸上画一个数组
于是我们用二维数组
d[i][j]
表示初始状态下小球在杯子
i
中，当杯子被移动了
代码
#include <bits/stdc++.h>
using namespace std;
int n, x;
int d[3][6] = { {0, 1, 2, 2, 1, 0},
{1, 0, 0, 1, 2, 2},
{2, 2, 1, 0, 0, 1} };
int main() {
// freopen("data.txt", "r", stdin);
cin >> n >> x;
n = n % 6;
for(int i = 0; i < 3; i++) {
if(d[i][n] == x) {
cout << i << endl;
break;
}
}
return 0;
}B. Game of Credit Cards（Codeforces 777B）
思路
首先这个数据规模暴力肯定是不行了。那么潜在的，可能有贪心策略也可能是动态规划。那么先考察有没有贪心策略。因为两个字符串的序对本题是没有影响的（因为M已经知道S的出牌顺序）。因此考虑对两个字符串进行排序。我们分两种策略来考虑：
- 被
S 攻击的最少次数。假设我们是 M ，那么我们的目标是让对方的牌尽可能不发挥作用。我们从当前S 的点数最大的 S[i] 这儿考虑。为了让 S[i] 哑火，我们可以拿出最大的 M[j] 来压制它。这样为什么是最好的呢？因为如果 M[j] 都压不住它，那么也没有牌能够压住它了。况且如果此时不用 M[j] ，有什么理由以后再用它呢？有人可能会反驳：能不能放弃压制 S[i] ，把 M[j] 留到后面用呢？假如这样做，那么最好的情况是结果不变，最差的情况是结果变大了（也就是次优解）。因此我们按照点数从大到小枚举 S[i] ，用当前最大的牌来压制对方即可。- 攻击
S
的最多次数。假设我们是
M ，那我们的目标是让我们的牌尽可能发挥作用。那么我们从 M 的点数最大的M[j] 这儿考虑。为了让 M[j] 发挥最大效果，我们选择比 M[j] 小的（或相等的）最大的 S[i] 下手。因为对于任意满足 S[k]≤S[i] 的 k ，都存在S[k]≤M[j] ，那么将 M[j] 用在 S[i] 上最利于我方的后来的牌的发挥。我们同样可以从大到小枚举 S[j] ，用当前最大的牌来压制对方。 代码
#include <bits/stdc++.h> using namespace std; const int maxn = 1010; char S[maxn], M[maxn]; int n, Max, Min; int main() { // freopen("data.txt", "r", stdin); scanf("%d%s%s", &n, S, M); sort(S, S + n); sort(M, M + n); int j = n - 1; for(int i = n - 1; i >= 0; i--) { if(S[i] > M[j]) { Min++; } else { j--; } } j = n - 1; for(int i = n - 1; i >= 0; i--) { if(S[i] < M[j]) { Max++; j--; } } printf("%d\n%d\n", Min, Max); return 0; }
C. Alyona and Spreadsheet（Codeforces 777C）
思路
对于这题，不少人都能够立即想到暴力的解法：对于每列 j ，检查行区间
[l,r] 中的每行，看看这些行是不是在 j 列上单调不减。这是不错的想法，但是时间复杂度太大了，达到了O(nm+n+m) 。
事实上，这种要对矩阵进行某种统计，暴力解复杂度太大的题，多半是要维护某种神奇的量，使得我们只用枚举行或枚举列就能完成这种统计。话说 CF 出这种题已经不是一次两次了。
那么这题怎么样呢？我们可以事先统计 d[j][i] ，表示以 i 行j 列的元素 aij 为终点的最长上升子串（注意是子串而不是子序列）的长度为多少。此时原问题就转化成对于第 r 行，是否存在一个
j ，使得 r−d[j][r]+1≤l 。不等式左边的式子表示以 r 为区间右端点
d[j][r] 为区间长度的区间左端点的编号（也就是本题的行号）是多少。将式子变形后问题转化成是否存在一个 j ，使得
d[j][r]≥r−l+1 。显然这个问题就是在问
max{d[j][r]}≥r−l+1 是否成立。
那么对于每个 r ，维护
d[j][r] 的最大值即可。这既是我前面所说的神奇的量。最后，实现上需要注意一个细节。因为题目只说 n×m≤105 ，所以理论上说 n,m 都有可能达到 105 。在存矩阵的时候如果用二维数组的话会超内存限制。所以得采用类似图论中邻接表的数据结构才能存下。
代码
#include <bits/stdc++.h> using namespace std; const int maxn = 1e5 + 10; vector <int> a[maxn], d[maxn]; int n, m, k, l, r, num, Max[maxn]; int main() { // freopen("data.txt", "r", stdin); scanf("%d%d", &n, &m); // 输入并存储矩阵 for(int i = 1; i <= n; i++) { a[i].push_back(0); for(int j = 1; j <= m; j++) { scanf("%d", &num); a[i].push_back(num); } } for(int j = 1; j <= m; j++) { d[j].push_back(0); d[j].push_back(1); } // 对每列计算以某个元素结尾的最长不下降子串 for(int j = 1; j <= m; j++) { for(int i = 2; i <= n; i++) { if(a[i][j] >= a[i-1][j]) { d[j].push_back(d[j][i-1] + 1); } else { d[j].push_back(1); } } } // 统计每行的列最长不下降子串的最大值 for(int i = 1; i <= n; i++) { for(int j = 1; j <= m; j++) { Max[i] = max(Max[i], d[j][i]); } } // 回答查询 scanf("%d", &k); while(k--) { scanf("%d%d", &l, &r); puts(r - Max[r] + 1 <= l ? "Yes" : "No"); } return 0; }
D. Cloud of Hashtags（Codeforces 777D）
思路
这题从数据规模和“字典序”这个这么强的条件来看，可能存在贪心策略。首先从先往后考虑，结果是没什么结果。那么从后往前考虑呢？首先，对于一个字符串，我们删除它的后缀只会让它的字典序变小而不是变大。那么，对于倒数第一个串 s[n] 和倒数第二个串 s[n−1] ，如果字典序 s[n]<s[n−1] ，那么我们对 s[n] 做任何事情都于事无补，但可以删除 s[n−1] 的后缀。
从这个灵感不难得出贪心算法：我们从第一位开始逐位比较两个字符串 s[i] 和 s[i−1] 。- 如果出现某位j使得 s[i][j]>s[i−1][j] ，那么一切顺利。
- 如果出现某位j使得
s[i][j]<s[i−1][j]
，那么从
j
开始的
s[i−1] 的后缀要全部删除掉。 - 如果一直是 s[i][j]==s[i−1][j] 直到某个串被遍历完，那么只需要 s[i] 的长度大于或等于 s[i−1] 的长度即可。
代码
#include <bits/stdc++.h> using namespace std; const int maxn = 5e5 + 10; string s[maxn]; bool equ; int n, p1, p2; int main() { // freopen("data.txt", "r", stdin); ios::sync_with_stdio(false); cin.tie(0); cin >> n; for(int i = 1; i <= n; i++) { cin >> s[i]; } for(int i = n - 1; i >= 1; i--) { equ = true; p1 = p2 = 0; while(true) { if(s[i+1][p1] < s[i][p2]) { if(true == equ) { s[i] = s[i].substr(0, p2); } break; } if(s[i+1][p1] > s[i][p2]) { equ = false; } if(++p2 >= s[i].size()) { break; } if(++p1 >= s[i+1].size()) { if(true == equ) { s[i] = s[i].substr(0, p2); } break; } } } for(int i = 1; i <= n; i++) { cout << s[i] << endl; } return 0; }
E. Hanoi Factory（Codeforces 777E）
思路
这题显然不是贪心能够解决的（很难找到某个顺序进行某种贪心策略）。考虑动态规划。我们需要有一个“序”来让动规满足“无后效性”。根据题目的特点先按照外径从大到小对 ring 排序，当外径相等时按照内径从大到小排序（相当于排在前面的一定放在下面）。这时候就可以设计动态规划算法了。
令状态 i 表示当前考虑到ringi 这个物品，且 ringi 是放在塔顶的物品， d[i] 表示状态 i 下的最优解。若某个状态j 可以转移到状态 i ，那么物品ringi 的外径一定要严格小于 ringj 的外径，且物品 ringi 的外径一定要严格大于 ringj 的内径，用方程来描述状态转移过程中最优解的变化有（ a,b,h 数组分别存放内径，外径和高度）d[i]=max{d[j],j<i,b[i]>a[j]}
这看上去会是一个 O(n2) 的算法。让我们来尝试优化它（所以一定要熟悉动态规划及其优化技巧，这样才能自信认为这样的优化会奏效）。根据 j<i 这个信息。我们可以开一个数组 data[] ，假设我们处理到状态 i 了，
data[k] 表示在状态 i 之前出现过的内径为k 的物品在塔的最顶端时的最优解。那么我们就可以通过区间最大值查询 RMQ(1,b[i]−1) ，来得知 max{d[j],j<i,b[i]>a[j]} （相当于不需要知道 j ，而直接知道了d[j] ），从而更新 d[i] ，然后通过 d[i] 来更新 data[a[i]] 。那么这有什么用呢？将问题逐步变形至此有什么好处呢？答案是，动态的 RMQ 以及修改元素是可以用线段树在 O(logn) 的时间内完成的（需要对内径离散化）。只要将 data 数组用线段树维护起来就好了。这样，本题的复杂度达到了 O(nlogn) ，这是可以接受的。代码
#include <bits/stdc++.h> using namespace std; #define lch (k << 1) #define rch (k << 1 | 1) #define mid ((l + r) >> 1) typedef long long ll; const int maxn = 2e5 + 10; map <int, int> mp; int n, a, b, h, m, foo[maxn], bar[maxn]; ll d, tmp, ans; // 排序用的ring结构体 struct ring { int a, b, h; ring() {} ring(int a, int b, int h):a(a), b(b), h(h) {} bool operator < (const ring& o) const { if(b == o.b) { return a > o.a; } return b > o.b; } }rings[maxn]; // 线段树 template <class T> struct Tree { T data[maxn<<2]; T operate(T x, T y) { return max(x, y); } void pushUp(int k) { data[k] = operate(data[lch], data[rch]); } // 建树 void build(int k, int l, int r) { if(l == r) { data[k] = 0; return; } build(lch, l, mid); build(rch, mid + 1, r); pushUp(k); } // 修改 void update(int a, T v, int k, int l, int r) { if(l == r) { data[k] = v; return; } if(a <= mid) { update(a, v, lch, l, mid); } else { update(a, v, rch, mid + 1, r); } pushUp(k); } // 查询 T query(int a, int b, int k, int l, int r) { if(a <= l && r <= b) { return data[k]; } ll res = 0; if(a <= mid) { res = operate(res, query(a, b, lch, l, mid)); } if(b > mid) { res = operate(res, query(a, b, rch, mid + 1, r)); } return res; } }; Tree <ll> o; // 离散化 int dec(int a[], int b[], int n, map <int, int>& mp) { copy(a + 1, a + n + 1, b + 1); sort(b + 1, b + n + 1); int m = unique(b + 1, b + n + 1) - b - 1; for(int i = 1; i <= n; i++) { mp[a[i]] = lower_bound(b + 1, b + m + 1, a[i]) - b; } return m; } int main() { // freopen("data.txt", "r", stdin); scanf("%d", &n); for(int i = 1; i <= n; i++) { scanf("%d%d%d", &a, &b, &h); rings[i] = ring(a, b, h); foo[i] = a; foo[n + i] = b; } // 离散化 m = dec(foo, bar, 2 * n, mp); o.build(1, 1, m); sort(rings + 1, rings + n + 1); for(int i = 1; i <= n; i++) { a = rings[i].a; b = rings[i].b; h = rings[i].h; // 查询d[j] if(mp[b] >= 2) { d = o.query(1, mp[b] - 1, 1, 1, m) + h; } else { d = h; } // tmp相当于d[i] tmp = o.query(mp[a], mp[a], 1, 1, m); // 将d[i]插入线段树 if(d > tmp) { o.update(mp[a], d, 1, 1, m); } // 用d[i]更新答案 ans = max(ans, d); } printf("%I64d\n", ans); return 0; }
- 攻击
S
的最多次数。假设我们是
757
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
