agc033

A题意：给你个黑白矩阵，每次黑的周围一圈会变黑，求多少次之后全黑。n <= 1000

解：BFS即可。

#include <bits/stdc++.h>
 
const int N = 1010;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
 
struct Node {
    int x, y;
    Node(int X = 0, int Y = 0) {
        x = X;
        y = Y;
    }
};
 
int vis[N][N], d[N][N];
char str[N];
std::queue<Node> Q;
 
int main() {
 
    int n, m, ans = 0;
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i++) {
        scanf("%s", str + 1);
        for(int j = 1; j <= m; j++) {
            if(str[j] == '#') {
                Q.push(Node(i, j));
                vis[i][j] = 1;
                d[i][j] = 0;
            }
        }
    }
 
    while(Q.size()) {
        int x = Q.front().x, y = Q.front().y;
        Q.pop();
        for(int i = 0; i < 4; i++) {
            int tx = x + dx[i], ty = y + dy[i];
            if(tx < 1 || ty < 1 || tx > n || ty > m || vis[tx][ty]) {
                continue;
            }
            vis[tx][ty] = 1;
            d[tx][ty] = d[x][y] + 1;
            Q.push(Node(tx, ty));
            ans = std::max(ans, d[tx][ty]);
        }
    }
    printf("%d
", ans);
    return 0;
}

B题意：给你个矩阵，初始时有个棋子在(sx,sy)。先后手都有个字符串，每一回合可以选择不走或者按照字符串上的方向走一步。先手想要玩完n回合，后手想要在n回合之内把棋子走出棋盘。谁能如愿以偿呢？n <= 20w

解：发现行列独立。于是考虑行。我们从后往前，维护第i步时棋子在哪些地方会导致在n步内出棋盘。判断一下是否必出棋盘即可。列同理。

#include <bits/stdc++.h>

const int N = 200010;

char str1[N], str2[N];
int n;

int main() {

    int n1, n2, x1, x2;
    scanf("%d%d%d", &n1, &n2, &n);
    scanf("%d%d", &x1, &x2);
    scanf("%s%s", str1 + 1, str2 + 1);

    bool f = 1;
    int L = 0, R = n1 + 1;
    for(int i = n; i >= 1; i--) {

        if(str2[i] == 'L' || str2[i] == 'R') {

        }
        else if(str2[i] == 'D') {
            L = std::max(L - 1, 0);
        }
        else {
            R = std::min(R + 1, n1 + 1);
        }

        if(str1[i] == 'L' || str1[i] == 'R') {

        }
        else if(str1[i] == 'D') {
            R = R - 1;
        }
        else {
            L = L + 1;
        }
        if(L + 1 >= R) {
            f = 0;
            break;
        }

    }
    if(x1 <= L || R <= x1) {
        f = 0;
    }
    L = 0, R = n2 + 1;
    for(int i = n; i >= 1 && f; i--) {

        if(str2[i] == 'U' || str2[i] == 'D') {

        }
        else if(str2[i] == 'L') {
            R = std::min(R + 1, n2 + 1);
        }
        else {
            L = std::max(L - 1, 0);
        }

        if(str1[i] == 'U' || str1[i] == 'D') {

        }
        else if(str1[i] == 'L') {
            L = L + 1;
        }
        else {
            R = R - 1;
        }
        if(L + 1 >= R) {
            f = 0;
            break;
        }

    }
    if(x2 <= L || R <= x2) {
        f = 0;
    }
    if(f) {
        printf("YES
");
    }
    else {
        printf("NO
");
    }
    return 0;
}

C题意：给你一棵树，每个点上有一个硬币。两个人轮流选择一个有硬币的点，把该点的硬币取走并把其它点的硬币都向这个点挪一步。不能操作者输。问谁输？n <= 20w

解：发现与每个点的具体硬币数量没关系，只跟是否有硬币有关系。然后发现每一次就是删掉所有叶子，但是你可以选择保护一个叶子不被删。我们感性想象一下，发现跟每某个点的伸出去的最长链有关系...

然后考虑直径，别问我怎么想到的...灵光一闪就想到了。发现每次操作之后，直径要么减2要么减1，就算直径改变了，但是长度仍然遵守这个规律。且最后剩下来的是一条单个的直径。于是求出直径长度，sg函数即可。(其实有个规律......) 

#include <bits/stdc++.h>

const int N = 200010;

struct Edge {
    int nex, v;
}edge[N << 1]; int tp;

int n, e[N], sg[N], f[N], Ans;

inline void add(int x, int y) {
    edge[++tp].v = y;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}

void DFS(int x, int fa) {
    int a = 1, b = 0;
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == fa) continue;
        DFS(y, x);
        if(a < f[y] + 1) {
            b = a;
            a = f[y] + 1;
        }
        else {
            b = std::max(b, f[y] + 1);
        }
    }
    Ans = std::max(Ans, std::max(a + b - 1, a));
    f[x] = a;
    return;
}

int main() {

    int n;
    scanf("%d", &n);
    for(int i = 1, x, y; i < n; i++) {
        scanf("%d%d", &x, &y);
        add(x, y);
        add(y, x);
    }

    DFS(1, 0);

    /// cal Ans
    sg[1] = 1;
    sg[2] = 0;
    for(int i = 3; i <= Ans; i++) {
        if(std::min(sg[i - 1], sg[i - 2]) == 0) {
            sg[i] = 1;
        }
        else {
            sg[i] = 0;
        }
    }

    if(sg[Ans]) {
        printf("First
");
    }
    else {
        printf("Second
");
    }

    return 0;
}

D题意：给你一个黑白矩阵，求它的复杂度。定义一个矩阵的复杂度为：纯色矩阵为0，否则横/竖切一刀，这种划分方式的权值为两个子矩阵的复杂度的max。这个矩阵的复杂度为所有划分方式的权值中的最小值 + 1。n <= 185, 5s。

解：考虑到复杂度不会超过2log，于是设f_ijkl为左边界为i，上下边界为jk，复杂度为l的矩形右边界最远能到的列。转移的时候有一个非常优秀的单调指针，不知道为什么......

#include <bits/stdc++.h>
 
const int N = 190;
 
short G[N][N], a[N][N][N][18], b[N][N][N][18], sum1[N][N], sum2[N][N]; /// a->  b|
char str[N];
 
inline short get1(short l, short r, short i) { /// |
    return sum1[r][i] - sum1[l - 1][i];
}
inline short get2(short i, short l, short r) { /// -
    return sum2[i][r] - sum2[i][l - 1];
}
 
inline void exmax(short &a, const short &b) {
    a < b ? a = b : 0;
    return;
}
inline short Min(const short &a, const short &b) {
    return a > b ? b : a;
}
 
int main() {
 
 
    //printf("%d 
", (sizeof(a) * 2 + sizeof(G) + sizeof(str)) / 1048576);
    short n, m;
    scanf("%hd%hd", &n, &m);
    for(register short i(1); i <= n; ++i) {
        scanf("%s", str + 1);
        for(register short j(1); j <= m; ++j) {
            G[i][j] = (str[j] == '#');
            sum1[i][j] = sum1[i - 1][j] + G[i][j];
            sum2[i][j] = sum2[i][j - 1] + G[i][j];
            //printf("%hd %hd G = %hd 
", i, j, G[i][j]);
        }
    }
 
    for(register short l(1); l <= n; ++l) {
        for(register short r(l); r <= n; ++r) {
            short last = -1;
            for(register short i(m); i >= 1; --i) {
                short tot(get1(l, r, i));
                //printf("tot = %hd 
", tot);
                if(tot != 0 && tot != r - l + 1) {
                    a[l][r][i][0] = i - 1;
                    last = -1;
                }
                else if(last != tot) {
                    a[l][r][i][0] = i;
                    last = tot;
                }
                else {
                    a[l][r][i][0] = a[l][r][i + 1][0];
                }
                //printf("a %hd %hd %hd 0 = %hd 
", l, r, i, a[l][r][i][0]);
            }
        }
    }
 
    /*for(short l = 1; l <= m; l++) {
        for(short r = l; r <= m; r++) {
            short last = -1;
            for(short i = n; i >= 1; i--) {
                short tot = get2(i, l, r);
                //printf("tot = %hd 
", tot);
                if(tot != r - l + 1 && tot != 0) {
                    b[i][l][r][0] = i - 1;
                    last = -1;
                }
                else if(tot != last) {
                    b[i][l][r][0] = i;
                    last = tot;
                }
                else {
                    b[i][l][r][0] = b[i + 1][l][r][0];
                }
                //printf("b %hd %hd %hd 0 = %hd 
", i, l, r, b[i][l][r][0]);
            }
        }
    }*/
 
    if(a[1][n][1][0] == m) {
        printf("%hd
", 0);
        return 0;
    }
 
    for(register short j(1); j <= 17; ++j) {
 
        //printf("------------------- %hd -------------------- 
", j);
        for(register short i(m); i >= 1; --i) {
            for(register short l(1); l <= n; ++l) {
                short p = l;
                for(register short r(l); r <= n; ++r) {
                    exmax(a[l][r][i][j], a[l][r][i][j - 1]);
                    short t(a[l][r][i][j - 1]);
                    t = a[l][r][t + 1][j - 1];
                    exmax(a[l][r][i][j], t);
                    if(a[l][r][i][j] == m || l == r) continue;
 
                    for(; p < r; ++p) {
                        /// p [l, p] [p + 1, r]
                        t = Min(a[l][p][i][j - 1], a[p + 1][r][i][j - 1]);
                        // if(a[l][p][i][j - 1] <= a[l][r][i][j]) break;
                        if(a[l][p][i][j - 1] == i - 1) break;
                        if(p == r - 1 || Min(a[l][p + 1][i][j - 1], a[p + 2][r][i][j - 1]) < t) {
                            exmax(a[l][r][i][j], t);
                            break;
                        }
                    }
 
                }
            }
            if(a[1][n][1][j] == m) {
                printf("%hd
", j);
                return 0;
            }
        }
 
        /*for(short l = 1; l <= n; l++) {
            for(short r = l; r <= n; r++) {
                for(short i = 1; i <= m; i++) {
                    printf("a %hd %hd %hd = %hd 
", l, r, i, a[l][r][i][j]);
                }
            }
        }
        printf("--------------- 
");
        for(short l = 1; l <= m; l++) {
            for(short r = l; r <= m; r++) {
                for(int i = 1; i <= n; i++) {
                    printf("b %hd %hd %hd = %hd 
", i, l, r, b[i][l][r][j]);
                }
            }
        }
        puts("");*/
    }
 
    /*for(register short i = 0; i <= 17; i++) {
        if(a[1][n][1][i] == m) {
            printf("%hd
", i);
            break;
        }
        if(b[1][1][m][i] == n) {
            printf("%hd
", i);
            break;
        }
    }*/
 
    return 0;
}