【解题报告】Codeforces Round #376 (Div. 2)

题目链接

---

A. Night at the Museum（Codeforces 731A）

题目

在每个状态都只有两种策略到达下一个状态。一个是向左走，另一个是向右走。这两种策略在数学上的表达方式是，一个是两个状态的距离的绝对值 $x$ ，另一个是在模 $26$ 运算下 $x$ 的补码 $26 - x$ 。于是每次都只会走这两个值较小者对应的策略。

思路

#include <bits/stdc++.h>
using namespace std;

int L, R, ans, cur, nxt;
string s;

int main() {
    cin >> s;
    for(int i = 0; i < s.size(); i++) {
        nxt = s[i] - 'a';
        L = abs(nxt - cur);
        R = 26 - L;
        ans += min(L, R);
        cur = nxt;
    }
    cout << ans << endl;
    return 0;
}

---

B. Coupons and Discounts（Codeforces 731B）

思路1

由题知每天都有两种买披萨策略。策略行不行得通跟当天队伍数量的奇偶性有关。当第 $i$ 天出现奇数支队伍时，必须来一个“连续两天单份套餐”，不然当天就会有人因刷题过度而饿死，与此同时解决了第 $i + 1$ 天的一份伙食，也就是 $a[i+1]--$ （如果第 $i + 1$ 天没有队伍这个策略就不能使用）。于是扫描题给数组，贪心地根据奇偶性使用策略即可解决问题。

思路2

考虑用动态规划来记录在每一个阶段于每一种可能状态下完美构造购买披萨方案的可行性。令 $d[i][0]$ 为前 $i$ 天（包括第 $i$ 天）能通过买偶数份披萨满足所有队伍的可行性（ $bool$ 值），而 $d[i][1]$ 为前 $i$ 天能通过“连续两天买一份披萨（第 $i$ 天和第 $i + 1$ 天）”和买偶数份披萨满足所有队伍。

那么当 $a[i]$ 为奇数时有

$d[i][0] = d[i-1][1]$
$d[i][1] = d[i-1][0]$

当为偶数时有

$d[i][0] = d[i-1][0]$
$d[i][1] = d[i-1][1]$

意思就是今天是否有可行方案取决于昨天是否有可行方案。最后 $d[n][0]$ 就是答案。

代码2

#include <bits/stdc++.h>
using namespace std;

const int maxn = 2e5 + 5;
int n, a, d[maxn][2];

int main() {
    scanf("%d", &n);
    d[0][0] = 1;
    for(int i = 1; i <= n; i++) {
        scanf("%d", &a);
        if(a % 2) {
            d[i][0] = d[i-1][1];
            if(a > 0) {
                d[i][1] = d[i-1][0];
            }
        }
        else {
            d[i][0] = d[i-1][0];
            if(a > 0) {
                d[i][1] = d[i-1][1];
            }
        }
    }
    puts(d[n][0] ? "YES" : "NO");
    return 0;
}

---

C. Socks（Codeforces 731C）

思路

首先由于数据规模的原因暴力、搜索之类的肯定是行不通的。然后搜索的过程中也不会出现重叠子问题，因此也不考虑动态规划。二分查找的话，给定一个涂色次数也无法判断是否行得通。所以这个想法也被掐死了。
然后尝试在草稿纸上画出袜子之间的关系，发现如果将需要在同一天穿的袜子用无向边连接的话，最终的染色结果是一个无向图，其中任意一个联通分量内所有袜子的颜色都是相同的。那么显然对于无向图的一个连通袜子分量，我们应该将分量内的袜子都染成分量内有着最多袜子的那个颜色，这样是最优的。
所以我们以 $DFS$ 序遍历每个联通分量，在记录分量内节点个数 $num$ 的同时用 $map$ 记录每种颜色的出现次数，假设最大值为 $Max$ 。那么该联通分量对答案的贡献就是 $num - Max$ 。最后将所有贡献加起来即可得到答案。

代码

#include <bits/stdc++.h>
using namespace std;

const int maxn = 2e5 + 5;
bool vis[maxn];
int n, m, k, u, v, num, Max, ans, c[maxn];
vector <int> G[maxn];
map <int, int> :: iterator it;
map <int, int> mp;

int dfs(int u) {
    vis[u] = true;
    mp[c[u]]++;
    int res = 0;
    for(int i = 0; i < G[u].size(); i++) {
        int v = G[u][i];
        if(vis[v] == true) {
            continue;
        }
        res += dfs(v);
    }
    return res + 1;
}

int main() {
    scanf("%d%d%d", &n, &m, &k);
    for(int i = 1; i <= n; i++) {
        scanf("%d", &c[i]);
    }
    while(m--) {
        scanf("%d%d", &u, &v);
        G[u].push_back(v);
        G[v].push_back(u);
    }
    for(int i = 1; i <= n; i++) {
        if(vis[i] == false) {
            mp.clear();
            num = dfs(i);
            Max = 0;
            for(it = mp.begin(); it != mp.end(); it++) {
                Max = max(Max, it->second);
            }
            ans += num - Max;
        }
    }
    printf("%d\n", ans);
    return 0;
}

---

F. Video Cards（Codeforces 731F）

思路

如果将第 $i$ 张卡作为主卡的话，那么所有威力比主卡大（或一样大）的卡减少到 $a[i]$ 的倍数，就能同 $i$ 组合起来发挥最大威力。于是我们枚举这些卡，将枚举到的卡 $i$ 视作主卡。那么威力在 $a[i]$ 和 $2a[i]$ 之间的卡的威力都要变成 $a[i]$ ，威力在 $2a[i]$ 到 $3a[i]$ 之间的卡得威力都要变成 $2a[i]$ ……以此类推。
因此我们可以用一种类似筛法的算法，在枚举 $i$ 的同时枚举 $j$ ，将能力介于 $j \times a[i]$ 和 $(j + 1) \times a[i]$ 之间的卡的总和 $sum(j)$ 算出来再乘 $j \times a[i]$ ，就能算此 $j$ 对以 $i$ 为主卡的答案的贡献。由 $j$ 的贡献可以得到卡 $i$ 的威力，同时更新最大值即可在最后得到题目要求的结果。另外 $sum(j)$ 可以利用计算前缀和的方法在常数时间内获得。

代码

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
const int maxn = 2e5 + 5;
int n, x, m, a[maxn];
ll res, ans, sum[maxn];

int main() {
    scanf("%d", &n);
    for(int i = 0; i < n; i++) {
        scanf("%d", &x);
        m = max(m, x);
        a[x]++;
    }
    for(int i = 1; i <= m; i++) {
        sum[i] = sum[i-1] + a[i];
    }
    for(int i = 1; i <= m; i++) {
        if(a[i] == 0) {
            continue;
        }
        res = 0;
        for(int j = i; j <= m; j += i) {
            int k = min(j + i - 1, m);
            res += (sum[k] - sum[j-1]) * j;
        }
        ans = max(ans, res);
    }
    printf("%I64d\n", ans);
    return 0;
}

---

（其它题目略）