Codeforces题解集 1.0

记录 Codeforces 2019年12月19日到 2020年2月12日 的部分比赛题

Educational Codeforces Round 82 (Rated for Div. 2)

D Fill The Bag

给出m(≤1e5)个盒子，盒子的大小是2的幂次。可以选择把一个盒子分成大小相同的两部分，问最少执行几次分盒子的操作，可以装满大小为n(≤1e18)的背包。

把n转化为二进制，代表可以由若干种2的幂次的盒子各一个装满。从小往大贪心地使用已有的盒子，不足时把第一个比它大的盒子分开。

 #include <bits/stdc++.h>
 using namespace std;
 #define ll long long
 #define inc(i, l, r) for (int i = l; i <= r; i++)

 const int maxn = 1e6 + ;

 ll t, n, m, a[maxn];
 ll num[];

 int main() {
     ios::sync_with_stdio(false);
     cin.tie(nullptr);
     cin >> t;
     while (t--) {
         cin >> n >> m;
         ll tot = ;
         memset(num, , sizeof(num));
         inc(i, , m - ) {
             cin >> a[i];
             tot += a[i];
             num[(int)log2((double)a[i])]++;
         }
         if (tot < n) {
             cout << "-1\n";
             continue;
         }
         ll ans = ;
         for (int i = ; n; i++) {
             if (n & ) {
                 if (num[i])
                     num[i]--;
                 else
                     inc(j, i + , ) if (num[j]) {
                         num[j]--;
                         num[i] += ( << (j - i)) - ;
                         ans += j - i;
                         break;
                     }
             }
             num[i + ] += num[i] / ;
             n >>= ;
         }
         cout << ans << "\n";
     }
 }

E Erase Subsequences

给出两个串s, t，长度≤400，问s的两个不相交的子序列能否拼接成 t.

枚举 t 的分界处，设左子串为t1，右子串为t2，遍历s，其实就是考虑是放到t1还是t2。dp[i]表示已匹配到t1[i]时，t2最远匹配到t2[dp[i]]，当dp[cnt]=size(t)时表示匹配成功。时间复杂度O(n^3)

 #include <bits/stdc++.h>
 using namespace std;
 #define ll long long
 #define inc(i, l, r) for (int i = l; i <= r; i++)

 const int maxn = 1e3 + ;

 int c;
 char s[maxn], t[maxn];

 int main() {
   //  ios::sync_with_stdio(false);
   //  cin.tie(nullptr);
     cin >> c;
     while (c--) {
         scanf("%s%s", s, t + );
         int l1 = strlen(s), l2 = strlen(t + ), f = ;
         inc(cnt, , l2) {
             vector<int> dp(cnt + , -), nxt(cnt + );
             dp[] = cnt;
             inc(i, , l1 - ) {
                 inc(j, , cnt) nxt[j] = dp[j];
                 inc(j, , cnt - ) if (s[i] == t[j + ] && dp[j] != -)
                     nxt[j + ] = max(nxt[j + ], dp[j]);
                 inc(j, ,
                     cnt) if (dp[j] != - && dp[j] < l2 && s[i] == t[dp[j] + ])
                     nxt[j] = max(nxt[j], dp[j] + );
                 inc(j, , cnt) dp[j] = nxt[j];
             }
             if (dp[cnt] == l2) {
                 f = ;
                 break;
             }
         }
         if (f)
             printf("YES\n");
         else
             printf("NO\n");
     }
 }

Codeforces Round #618 (Div. 1)

A Anu Has a Function

定义f(x, y) = x | y - y，给出一个数列，要改变顺序顺序后，使得f(f(x1, x2), x3), …)最大

这种题目直接考虑01的四种组合结果会是什么。发现只有f(1, 0)结果会是1，所以对于某一数位，只有1 0 0 …是有意义的。找到最高的数位满足这种状况，在确定了第一个数后，后面的数无论是什么顺序都不影响了。

 #include <bits/stdc++.h>
 using namespace std;
 #define ll long long
 #define inc(i, l, r) for (int i = l; i <= r; i++)
 #define dec(i, l, r) for (int i = l; i >= r; i--)

 const int maxn = 1e6 + ;

 int a[maxn], n, vis[maxn];

 int main() {
     ios::sync_with_stdio(false);
     cin.tie(nullptr);
     cin >> n;
     inc(i, , n - ) cin >> a[i];
     int res = -;
     dec(i, , ) {
         int pos = -;
         inc(j, , n - ) if (a[j] >> i & ) {
             if (pos == -)
                 pos = j;
             else
                 pos = -;
         }
         if (pos >= ) {
             res = pos;
             break;
         }
     }
     if (res >= ) {
         cout << a[res] << " ";
         vis[res] = ;
     }
     inc(i, , n - ) if (!vis[i]) cout << a[i] << " ";
 }

B Aerodynamic

给出一个凸多边形P，我们可以看作一个空心的框，想像(0, 0) 处有一个钉子，框在保证钉子在里面的前提下平移，经过的区域形成一个新的多边形T。问P与T是否相似。

另一种定义，P中存在向量(x, y)，则点(x, y)在T内(上)。

考虑到存在向量(x,y)就必存在(-x,-y)，T必然是中心对称。那么当P是中心对称时，使P中心点在原点，可以发现若(x, y)在P上，则(2x, 2y)在T上；而对于P外的某点，考虑中心对称的且在边上的两点，构成向量(x, y)，必不存在该方向上更长的向量（P是凸包）。所以P与T相似，且相似比为1:2。

 #include <bits/stdc++.h>
 using namespace std;
 #define ll long long
 #define inc(i, l, r) for (int i = l; i <= r; i++)

 const int maxn = 1e6 + ;

 ll x[maxn], y[maxn];
 int n;

 int main() {
     ios::sync_with_stdio(false);
     cin.tie(nullptr);
     cin >> n;
     inc(i, , n - ) cin >> x[i] >> y[i];
     if (n & ) {
         printf("no\n");
         exit();
     }
     ll cx = x[] + x[n / ], cy = y[] + y[n / ];
     inc(i, ,
         n /  - ) if (x[i] + x[i + n / ] != cx || y[i] + y[i + n / ] != cy) {
         printf("no\n");
         exit();
     }
     printf("yes\n");
 }

C Water Balance

给出一个数列，可以使一个连续区间的数，都变成该区间的平均数。问经过任意次操作，字典序最小的结果

考虑我们总是优先使第一个最小化，第一个最小化后，继续检查后面能否更小。维护一个递增的单调栈，出现逆序就合并。

 #include <bits/stdc++.h>
 using namespace std;
 #define ll long long
 #define inc(i, l, r) for (int i = l; i <= r; i++)
 #define dec(i, l, r) for (int i = l; i >= r; i--)

 const int maxn = 1e6 + ;

 ll a[maxn];
 int n;

 struct p {
     double ave;
     int num;
 };
 stack<p> s;
 vector<double> res;

 int main() {
     ios::sync_with_stdio(false);
     cin.tie(nullptr);
     cin >> n;
     inc(i, , n) cin >> a[i];
     inc(i, , n) {
         double sum = a[i];
         int num = ;
         while (!s.empty() && sum / num < s.top().ave) {
             sum += s.top().ave * s.top().num;
             num += s.top().num;
             s.pop();
         }
         s.push({sum / num, num});
     }
     while (!s.empty()) {
         inc(i, , s.top().num) res.push_back(s.top().ave);
         s.pop();
     }
     dec(i, n - , ) printf("%.12f ", res[i]);
 }

Educational Codeforces Round 81 (Rated for Div. 2)

D Same GCDs

给出a和m，1≤a<m≤1e10，问有多少个x，0≤x<m，gcd(a, m)==gcd(a+x, m)

 #include <bits/stdc++.h>
 using namespace std;
 #define ll long long
 #define inc(i, l, r) for (int i = l; i <= r; i++)

 int t;
 ll a, m;

 const int maxnum = 1e5;
 int prim[maxnum], pvis[maxnum + ], pcnt;
 void getprim() {
     for (int i = ; i <= maxnum; i++) {
         if (!pvis[i]) prim[++pcnt] = i;
         for (int j = ; j <= pcnt && prim[j] * i <= maxnum; j++) {
             pvis[prim[j] * i] = ;
             if (i % prim[j] == ) break;
         }
     }
 }

 ll cal(ll x) {
     ll org = x;
     for (int i = ; i <= pcnt && x > ; i++) {
         if (x % prim[i] == ) org = org / prim[i] * (prim[i] - );
         while (x % prim[i] == ) x /= prim[i];
     }
     if (x > ) org = org / x * (x - );
     return org;
 }

 int main() {
     getprim();
     cin >> t;
     while (t--) {
         cin >> a >> m;
         cout << cal(m / __gcd(a, m)) << "\n";
     }
 }

E Permutation Separation

给出一个n的排列，2≤n≤2e5，每个数有权值ai，现要分成两个非空子串，并对应两个数字集合，通过付出每个数字的权值的代价，可以把一个数字从原来的集合移动到另一个集合里。要使左子串对应的数字集合里的所有数都小于右字串对应的集合，或使若某一集合为空集，问最小代价

易知最终左子串对应的集合必然是1,2,,,n的一个前缀，扫描一遍，维护一个“变成前缀为i的集合需要的代价”的线段树

 #include <bits/stdc++.h>
 using namespace std;
 #define ll long long
 #define inc(i, l, r) for (int i = l; i <= r; i++)

 const int maxn = 2e5 + ;

 int n, p[maxn], a[maxn];
 int val[maxn];
 ll fv;

 ll res, tmp;

 ll w[ * maxn], f[ * maxn];

 void build(int k, int l, int r) {
     if (l == r) {
         fv += val[l];
         w[k] = fv;
         return;
     }
     int m = (l + r) / ;
     build( * k, l, m);
     build( * k + , m + , r);
     w[k] = min(w[ * k], w[ * k + ]);
 }

 void down(int k, int l, int r) {
     f[ * k] += f[k];
     f[ * k + ] += f[k];
     w[ * k] += f[k];
     w[ * k + ] += f[k];
     f[k] = ;
 }

 void change(int k, int l, int r, int a, int b, int val) {
     if (a <= l && r <= b) {
         w[k] += val;
         f[k] += val;
         return;
     }
     if (f[k]) down(k, l, r);
     int m = (l + r) / ;
     if (a <= m) change( * k, l, m, a, b, val);
     if (b > m) change( * k + , m + , r, a, b, val);
     w[k] = min(w[ * k], w[ * k + ]);
 }

 int main() {
     cin >> n;
     inc(i, , n) cin >> p[i];
     inc(i, , n) {
         cin >> a[i];
         val[p[i]] = a[i];
     }
     build(, , n);
     res = a[];
     for (int i = ; i < n; i++) {
         change(, , n, , p[i] - , a[i]);
         change(, , n, p[i], n, -a[i]);
         res = min(res, w[]);
     }
     cout << res;
 }

Educational Codeforces Round 80 (Rated for Div. 2)

D Minimax Problem

给出N×M的矩阵，N≤3e5，M≤8。现取出其中两行，“合并”成新的一行。所谓合并，是在相同位置的数取最大值。现在要最大化该数列的最小值，输出选取的两行行号

比较容易想到是二分答案。judge时要让每一个位置至少有一个数大于ans，可以把大于ans的数位hash成1，然后在至多2**M的hash数组里寻找是否有满足条件的两列。这里降低时间复杂度是利用了2**M<N的特点。注意二分的时候，避免没有judge为true（即ans实际为0，却不会运行到一步）的情况

 #include <bits/stdc++.h>
 using namespace std;
 #define ll long long
 #define inc(i, l, r) for (int i = l; i <= r; i++)
 #define pii pair<int, int>
 #define fi first
 #define se second
 #define pb push_back

 const int maxn = 3e5 + ;

 int a[maxn][], n, m, r1, r2;
 int h[];

 inline bool judge(int ans) {
     memset(h, , sizeof(h));
     inc(i, , n - ) {
         int val = ;
         inc(j, , m - ) {
             if (a[i][j] >= ans) val +=  << j;
         }
         h[val] = i + ;
     }
     int sz = ( << m) - ;
     inc(i, , sz) {
         inc(j, , sz) if ((i | j) == sz && h[i] && h[j]) {
             r1 = h[i], r2 = h[j];
             return true;
         }
     }
     return false;
 }

 int main() {
     scanf("%d %d", &n, &m);
     inc(i, , n - ) inc(j, , m - ) scanf("%d", &a[i][j]);
     int l = , r = (int)1e9 + , ans = -;
     while (l +  < r) {
         int m = (r - l) /  + l;
         if (judge(m))
             l = m, ans = m;
         else
             r = m;
     }
     if (ans == -)
         printf("1 1\n");
     else
         cout << r1 << " " << r2;
 }

E Messenger Simulator

初始为1,2,,,n的一个排列，代表n位好友的消息列表。给出m条消息，其中每一条都会使对应的好友消息在列表中置顶，即排列中的该数字被提前到第一个位置。问每个人在消息列表中最靠前和最靠后的位置。

考虑到一个人的位置只有在发消息时会减少，否则只会递增。所以，只关心在发消息时以及结束时刻他前面有多少人。建立一个n+m的BIT，初始时后n个位置置为1，代表了这n个人；每次处理一位好友消息时，查询前缀和，更新最大值，把他置于所有人前一位，并删去原来所在位置.

 #include <bits/stdc++.h>
 using namespace std;
 #define ll long long
 #define inc(i, l, r) for (int i = l; i <= r; i++)
 #define lowbit(x) x&(-x)

 const int maxn = 6e5 + ;

 int n, m, q;

 int f[maxn];
 void add(int x, int val) {
     for (; x <= n + m; x += lowbit(x)) f[x] += val;
 }
 int get(int x) {
     int res = ;
     for (; x; x -= lowbit(x)) res += f[x];
     return res;
 }

 int a[maxn], b[maxn], pos[maxn];

 int main() {
     cin >> n >> m;
     inc(i, , n) {
         a[i] = b[i] = i;
         pos[i] = m + i;
         add(i + m, );
     }
     inc(i, , m) {
         cin >> q;
         a[q] = ;
         b[q] = max(b[q], get(pos[q] - ) + );
         add(pos[q], -);
         pos[q] = m - i + ;
         add(m - i + , );
     }
     inc(i, , n) b[i] = max(b[i], get(pos[i] - ) + );
     inc(i, , n) printf("%d %d\n", a[i], b[i]);
 }

Codeforces Round #610 (Div. 2)

C Petya and Exam

有一次测验，有N道题，考试时间T，已知每一题是容易题还是困难题，解决前者需要时间a，后者需要b，每道题有个ti，考生在离开考场(可以选择提前离场)时若不小于该时间而未解决该题，他总分就是0分。问考生最多能获得多少分(解决一题得一分)。

思维点在于考虑到每个ti的前一秒是离场的最佳时间，检查能否把必须做的题了，外加做额外的题，更新答案。另外考试结束时也要检查是否可以更新答案。

 #include <bits/stdc++.h>
 using namespace std;
 #define ll long long
 #define inc(i, l, r) for (int i = l; i <= r; i++)

 const int maxn = 2e5 + ;

 int m, n, t, a, b;

 struct problem {
     int hard, gg;
     bool operator<(const problem& o) const { return gg < o.gg; }
 } p[maxn];

 int main() {
     ios::sync_with_stdio(false);
     cin.tie(nullptr);
     cin >> m;
     while (m--) {
         cin >> n >> t >> a >> b;
         ll ea = , eb = ;
         inc(i, , n - ) {
             cin >> p[i].hard;
             ea += p[i].hard == ;
             eb += p[i].hard == ;
         }
         inc(i, , n - ) cin >> p[i].gg;
         sort(p, p + n);
         p[n] = {-, t + };
         ll task = ;
         ll na = , nb = , res = ;
         for (int i = , j; i <= n; i = j) {
             if (p[i].gg -  >= task) {
                 ll tot = na + nb, tmp = p[i].gg -  - task;
                 if (tmp <= (ea - na) * a)
                     tot += tmp / a;
                 else {
                     tot += ea - na;
                     tmp -= (ea - na) * a;
                     if (tmp <= (eb - nb) * b)
                         tot += tmp / b;
                     else
                         tot += eb - nb;
                 }
                 res = max(res, tot);
             }
             j = i;
             while (j <= n && p[j].gg == p[i].gg) {
                 if (p[j].hard == )
                     task += a, na++;
                 else
                     task += b, nb++;
                 j++;
             }
         }
         cout << res << "\n";
     }
 }

D Enchanted Artifact

交互题。定义Edit distance是串s经过增，删，改(每次一个字符)变成串t的次数。现有一个串s(size≤300)，用户询问串t(size≤300)，返回Edit distance，最多询问s.size+2次（包括最终返回0的“询问”）

先询问300个a的串和300个b的串得到s有几个a和几个b，依据：由s变成全a只能把b改成a以及添加a。此时，我们也知道了如果询问一个与s长度相同全为b的串(记作tt)会得到的答案。然后询问这样的串t，长度与s相同，除了某一位置为a，其他都是b，可以推理出，a的位置与s匹配与 询问tt的返回值-1 是等价的。又注意到最后一个位置可以通过计算a的个数得出，所以无须询问，总询问次数刚好size+2次。

 #include <bits/stdc++.h>
 using namespace std;
 #define inc(i, l, r) for (int i = l; i <= r; i++)

 int a, b, x, n;

 void read() {
     cout << '\n';
     fflush(stdout);
     cin >> x;
     if (x == ) exit();
 }

 int main() {
     inc(i, , ) cout << 'a';
     read();
     a =  - x;

     inc(i, , ) cout << 'b';
     read();
     b =  - x;

     n = a + b;
     string res(n, 'b');

     int ta = ;
     inc(i, , n - ) {
         inc(j, , n - ) if (i == j) cout << "a";
         else cout << "b";
         read();
         if (x == a - ) {
             res[i] = 'a';
             ta++;
         }
     }
     if (ta != a) res[n - ] = 'a';
     cout << res;
     read();
 }

Codeforces Round #607 (Div. 1)

B Beingawesomeism

给出r×c的格子，上面有字符A和P。选择一个1×X的区域，指定某一方向与步长，该方向需与指定区域垂直；该方向的格子会被与起始指定区域同一行(列)的字符同化。问最少经过几次操作全部变成A

模拟题。最多4步(或者不能)，可以先判断能否3步的，其次2步，最后1步，节省代码量。

 #include <bits/stdc++.h>
 using namespace std;
 #define ll long long
 #define inc(i, l, r) for (int i = l; i <= r; i++)

 char a[][];
 int t, w, h;

 bool judge(int x, int d) {
     if (d == ) {
         inc(i, , w - ) if (a[x][i] != 'A') return ;
     } else {
         inc(i, , h - ) if (a[i][x] != 'A') return ;
     }
     return ;
 }

 int main() {
     ios::sync_with_stdio(false);
     cin.tie(nullptr);
     cin >> t;
     while (t--) {
         cin >> h >> w;
         int all = ;
         inc(i, , h - ) {
             cin >> a[i];
             inc(j, , w - ) all += a[i][j] == 'A';
         }
         if (all == )
             printf("MORTAL\n");
         else if (all == h * w)
             printf("0\n");
         else {
             int res = ;
             inc(i, , h - ) if (a[i][] == 'A' || a[i][w - ] == 'A') res = ;
             inc(i, , w - ) if (a[][i] == 'A' || a[h - ][i] == 'A') res = ;
             inc(i, , h - ) if (judge(i, )) res = ;
             inc(i, , w - ) if (judge(i, )) res = ;
             if (a[][] == 'A' || a[][w - ] == 'A' || a[h - ][] == 'A' ||
                 a[h - ][w - ] == 'A')
                 res = ;
             if (judge(, ) || judge(h - , ) || judge(, ) ||
                 judge(w - , ))
                 res = ;
             printf("%d\n", res);
         }
     }
 }

C Jeremy Bearimy

给出一个2n个点的树，两两匹配树上的所有节点，匹配后这些节点对的距离总和，问该距离总和的最小值与最大值。

考虑以某一条边为界，把树分为两部分。要最大化距离总和时，要尽可能匹配不同部分的点，那么这条边就被计算min(sz, 2n-sz)次；,sz为一部分的节点数；要最小化距离总和时，要尽可能匹配同一部分的点，那么这条边就被计算 sz & 1 次。

 #include <bits/stdc++.h>
 using namespace std;
 #define ll long long
 #define inc(i, l, r) for (int i = l; i <= r; i++)
 #define pii pair<int, int>
 #define fi first
 #define se second
 #define pb push_back

 const int maxn = 2e5 + ;

 vector<pii> g[maxn];

 int t, n, u, v, dis;
 ll res1, res2;

 int dfs(int x, int par) {
     int sz = ;
     for (int i = ; i < g[x].size(); i++) {
         if (g[x][i].fi != par) {
             int t = dfs(g[x][i].fi, x);
             res1 += t %  * g[x][i].se;
             res2 += (ll)min(t,  * n - t) * g[x][i].se;
             sz += t;
         }
     }
     return sz;
 }

 int main() {
     ios::sync_with_stdio(false);
     cin.tie(nullptr);
     cin >> t;
     while (t--) {
         cin >> n;
         inc(i, ,  * n) g[i].clear();
         inc(i, ,  * n - ) {
             cin >> u >> v >> dis;
             g[u].pb(pii(v, dis));
             g[v].pb(pii(u, dis));
         }
         res1 = res2 = ;
         dfs(, -);
         printf("%lld %lld\n", res1, res2);
     }
 }

Educational Codeforces Round 78 (Rated for Div. 2)

D Segment Tree

给出n个区间，这些区间的端点取遍1-2n。当两个区间相交时（不能包含），它们代表的节点之间就有一条边。判断依此生成的图是否是树。

对所有节点排序，遇到左端点加入set，遇到右端点时统计与其左端点间有多少个点，并删除左端点。用并查集维护集合关系。最后根据边数和连通性判断是否是树。因为每次都是遍历寻找左右端点间的点，此时算法的复杂度是O(n^2)。当统计点的个数大于n-1时，一定不是树，就可以break出来，此时是O(nlogn)。

E Tests for problem D

给出n个节点的树，要为每一个节点构造一个区间，使得区间的左右端点取遍1-2n，两个节点之间是否有边等价于它们的区间是否相交（不能包含）。

根的左端点为1，先序遍历，维护当前已使用的数字，当前区间的右端点贪心地取最小值——即右端点与已使用的数字之间的空余刚好能容下它的儿子的左端点（它的儿子的左端点就其次取这些空余的数字）。并且儿子的左端点越大越先遍历，这样可以保证儿子之间不会相交。

 #include <bits/stdc++.h>
 using namespace std;
 #define ll long long
 #define inc(i, l, r) for (int i = l; i <= r; i++)
 #define pii pair<int, int>
 #define fi first
 #define se second
 #define pb push_back

 const int maxn = 1e6 + ;

 vector<int> g[maxn];
 int n, u, v;
 pii res[maxn];

 int top = , root = ;
 void dfs(int x, int par) {
     top += g[x].size();
     if (x == root) top++;
     res[x].se = top;
     for (int i = , j = ; i < g[x].size(); i++) {
         if (g[x][i] != par) {
             res[g[x][i]].fi = top - ++j;
         }
     }
     for (int i = ; i < g[x].size(); i++) {
         if (g[x][i] != par) {
             dfs(g[x][i], x);
         }
     }
 }

 int main() {
     ios::sync_with_stdio(false);
     cin.tie(nullptr);
     cin >> n;
     inc(i, , n - ) {
         cin >> u >> v;
         g[u].pb(v);
         g[v].pb(u);
     }
     dfs(, -);
     res[].fi = ;
     inc(i, , n) cout << res[i].fi << " " << res[i].se << "\n";
 }