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

题目链接

---

A.Set of Strings（Codeforces 544A）

思路

显然，若字符串中有不少于 $k$ 个不同的字符，则一定能找到满足条件的分割方式。（因为允许只含有一个字符的子串）

代码

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

int k, vis[30];
string s, sub;
vector <int> v;

int main() {
    cin >> k >> s;
    for(int i = 0; i < s.size(); i++) {
        if(vis[s[i]-'a'] == 0) {
            vis[s[i]-'a'] = 1;
            v.push_back(i);
        }
    }
    if(v.size() < k) puts("NO");
    else {
        puts("YES");
        for(int i = 0; i < k; i++) {
            if(i != k - 1) sub = s.substr(v[i], v[i+1] - v[i]);
            else sub = s.substr(v[i], s.size() - v[i]);
            cout << sub << endl;
        }
    }
    return 0;
}

---

B.Sea and Islands（Codeforces 544B）

思路

这是一道构造的题目。由于是构造，所以只需要找到构造的特例就行。首先，由国际象棋的棋盘可以联想到， $ceil( \frac{1}{2} n^2)$ 为岛的数量的上界。既然想到了国际象棋的棋盘，那么岛的摆放也可以按照国际象棋中的黑格子的分布来摆。这样既适用于所有情况，又能以非常简洁的代码来实现。

代码

#include <cstdio>

int n, k;

int main() {
    scanf("%d%d", &n, &k);
    if(2 * k - 1 > n * n) {
        puts("NO");
    }
    else {
        puts("YES");
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                if(k > 0 && ((i ^ j) & 1) == 0) {
                    putchar('L');
                    k--;
                }
                else {
                    putchar('S');
                }
            }
            puts("");
        }
    }
    return 0;
}

---

C.Writing Code（Codeforces 544C）

思路

这种有一定资源限制求最优解或解的数量，或者说在每种状态下有超过一种的决策方案，但是不同的决策向量的子结构能转移到同一个状态的问题，通常能用动态规划解决。更具体地，通常能用背包思想解决。因为显然程序员i写的单行代码就是背包问题中的物品 $i$ 。由于一个程序员写的代码行数没有数量限制，因此这是个完全背包问题。回忆一下，只有一种限制条件（二维）的完全背包的状态转移方程为 $d[i][j] = d[i-1][j] + d[i][j-v[i]]$ ;本题显然多了一个限制条件: $bug$ 的总数不能超过 $b$ 。于是我们在状态中增加一维，用 $d[i][j][k]$ 表示在前 $i$ 个程序员共完成 $j$ 行代码并出现 $k$ 个 $bug$ 时的方案总数。若想要由某个状态转移到状态 $(i, j, k)$ 则可以通过两种方式，一种是在上一个程序员写了j行的情况下轮到第 $i$ 个程序员写，另一种是在第 $i$ 个程序员写了 $j - 1$ 行代码的情况下多写一行代码。相应的转移方程为 $d[i][j][k] = d[i-1][j][k] + d[i][j-1][k-a[i]]$ 。同样的，像二维的背包问题一样，我们可以用滚动数组的方法降低算法的空间复杂度。

代码

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

const int maxn = 505;
int n, m, b, mod, ans, a[maxn], d[maxn][maxn];

int main() {
    scanf("%d%d%d%d", &n, &m, &b, &mod);
    for(int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
    }
    d[0][0] = 1;
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            for(int k = a[i]; k <= b; k++) {
                d[j][k] = (d[j][k] + d[j-1][k-a[i]]) % mod; 
            }
        }
    }
    for(int k = 0; k <= b; k++) {
        ans = (ans + d[m][k]) % mod;
    }
    printf("%d\n", ans);
    return 0;
}

---

D.Destroying Roads（Codeforces 544D）

思路

若不考虑路径重合的话， $d[s1][t1] + d[s2][t2]$ 就应该是最后剩余道路的数量 $num$ （对任意的 $x$ 和 $y$ , $d[x][y]$ 为 $x$ 到 $y$ 的最短路径长度）。但是如果出现重合的话就可能有更短的 $num$ 。在不知道重合部分是哪部分且复杂度允许的情况下，可以通过枚举重合部分的方法，在枚举的过程中更新最短的 $num$ 。怎么枚举重合部分呢？答案是枚举重合部分的端点 $i$ 和 $j$ 。枚举了重合部分以后怎样更新 $num$ 呢？对两条路径，先判断从起点到重合路径的再到终点的最短距离是否满足题给条件，若满足条件则将这些最短距离相加并减去重合路径，最后用结果来更新 $num$ 。注意到，这个算法是建立在 $d$ 数组已经被计算出来的基础上的，由于所有的边权都是 $1$ ，所以可以用 $n$ 次 $BFS$ 处理出 d <script id="MathJax-Element-34" type="math/tex">d</script> 数组。

代码

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

const int maxn = 3010;
bool vis[maxn];
int n, m, u, v, s1, t1, l1, s2, t2, l2, tmp, ans;
int d[maxn][maxn];
vector <int> G[maxn];

void bfs(int s) {
    queue <int> q;
    q.push(s);
    vis[s] = true;
    d[s][s] = 0;
    while(!q.empty()) {
        int u = q.front();
        q.pop();
        for(int i = 0; i < G[u].size(); i++) {
            int v = G[u][i];
            if(vis[v] == true) {
                continue;
            }
            d[s][v] = d[s][u] + 1;
            q.push(v);
            vis[v] = true;
        }
    }
}

int main() {
    scanf("%d%d", &n , &m);
    for(int i = 1; i <= m; i++) {
        scanf("%d%d", &u, &v);
        G[u].push_back(v);
        G[v].push_back(u);
    }
    scanf("%d%d%d", &s1, &t1, &l1);
    scanf("%d%d%d", &s2, &t2, &l2);
    for(int i = 1; i <= n; i++) {
        memset(vis, 0, sizeof(vis));
        bfs(i);
    }
    if(d[s1][t1] > l1 || d[s2][t2] > l2) {
        puts("-1");
        return 0;
    }
    ans = d[s1][t1] + d[s2][t2];
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= n; j++) {
            if(d[s1][i] + d[i][j] + d[j][t1] > l1) {
                continue;
            }
            tmp = d[i][j] + d[s1][i] + d[j][t1];
            if(d[s2][i] + d[i][j] + d[j][t2] <= l2) {
                ans = min(ans, tmp + d[s2][i] + d[j][t2]);
            }
            if(d[s2][j] + d[i][j] + d[i][t2] <= l2) {
                ans = min(ans, tmp + d[s2][j] + d[i][t2]);
            }
        }
    }
    printf("%d\n", m - ans);
    return 0;
}

---

E.Remembering Strings（Codeforces 544E）

思路

这是一个从初始状态经过一系列操作得到目标状态，求最优解的问题。这样的问题适合用搜索或者动态规划解决。由于数据规模的原因，因此不能用搜索解决。分析问题后容易知道，因为行数的上限是20，而小写字母有26个，所以当某行不满足条件时总能通过将该行某列的字符改成别的字符或者将其它行某列的与该行该列相同的字符全部改成其它字符来使该行满足条件而不影响其他行。由于既不能搜索又不能贪心，而且数据量不是很大，所以直接将每行是否满足条件用1和0表示，于是能用一个二进制数表示所有行的状态，进行状态压缩的动态规划。

代码

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

const int maxn = 20 + 1, INF = 1e9;
char s[maxn][maxn];
int n, m, Max, nn, x, y;
int d[1<<maxn], a[maxn][maxn], b[maxn][maxn], same[maxn][maxn];

int main() {
    scanf("%d%d", &n, &m);
    for(int i = 0; i < n; i++) {
        scanf("%s", s[i]);
    }
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < m; j++) {
            scanf("%d", &a[i][j]);
        }
    }
    // 预处理出b和same
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < m; j++) {
            Max = 0;
            // 该列有多少与该字符相同的字符
            for(int k = 0; k < n; k++) {
                if(s[i][j] != s[k][j]) {
                    continue;
                }
                // 将相同字符的位置信息记录下来
                same[i][j] |= (1 << k);
                Max = max(Max, a[k][j]);
                b[i][j] += a[k][j];
            }
            b[i][j] -= Max;
        }
    }
    nn = 1 << n;
    fill(d, d + nn, INF);
    d[0] = 0;
    for(int i = 0; i < nn; i++) {
        // 查找一个不满足条件的行
        for(int j = 0; j < n; j++) {
            x = 1 << j;
            if(x & i) {
                continue;
            }
            // 查找一个要修改的列
            for(int k = 0; k < m; k++) {
                int y = same[j][k];
                d[i|x] = min(d[i|x], d[i] + a[j][k]);
                d[i|y] = min(d[i|y], d[i] + b[j][k]);
            }
            break;
        }
    }
    printf("%d\n", d[nn-1]);
    return 0;
}

---