[ABC311] D~G 题解

D - Grid Ice Floor 搜索

题目的意思实际上是要求出所有可能到达的点，也就是说所有路径可达点的并。

基本上看清题目就会了，直接搜索每个点，每次枚举四个方向的时候直接冲到底，需要用数组去重贡献。

void dfs(int x, int y, int fax, int fay) {
    if(st[x][y]) return ;
    st[x][y] = 1;
    for(int i = 0; i < 4; i ++) {
        int cnt = 0;
        int xx = x + dx[i], yy = y + dy[i];
        while(check(xx, yy)) {
            ans += !vis[xx][yy], vis[xx][yy] = 1;
            xx += dx[i], yy += dy[i];
        }
        xx -= dx[i], yy -= dy[i];
        dfs(xx, yy, x, y);
    }
}

signed main() {
    memset(dist, 0, sizeof dist);
    vis[2][2] = 1;
    dist[2][2] = 1;
    dfs(2, 2, 0, 0);
    cout << ans << '\n';
    return 0;
}

E - Defect-free Squares

使用 $d p [i] [j]$ 表示以 $(i, j)$ 为右下角的正方形的最大边长是多少。

d p [i] [j] = min (d p [i - 1] [j], d p [i] [j - 1], d p [i - 1] [j - 1]) + 1, (i, j) 合 法 d p [i] [j] = 0, (i, j) 非 法

F - Yet Another Grid Task

使用 $d p [i] [s]$ 表示第 $i$ 列的状态为 $s$ 的方案数。

这样会爆，考虑优化状态表示。

观察发现，如果一个位置是黑色的，那么它所在列下面的所有的格子都是黑的，所以只需要保留一个最上的黑格子位置即可，有了这个观察，得到表示：

$d p [i] [j]$ 表示第 $i$ 列的最上黑色格子在第 $j$ 行。

由于第 $i$ 列的最高位是 $j$ ，所以第 $i - 1$ 列的最高位不能超过 $j + 1$ ，否则第 $i$ 列第 $j + 1$ 行一定是黑色的，与最高黑色位是 $j$ 的假设矛盾了。

如果令 $t o p [i]$ 表示第 $i$ 列初始最高黑色位，得到转移方程：

d p [i] [j] = \sum_{k = t o p [i - 1]}^{min (n, j + 1)} d p [i - 1] [k]

发现可以前缀和优化掉，滚掉一维，剩下没了。

时间复杂度： $O (n m)$ 。

#include <algorithm>
#include <cstring>
#include <iostream>
#include <queue>

using namespace std;

const int N = 2e3 + 10, mod = 998244353;

int n, m, top[N];
long long dp[N], s[N][N];
char g[N][N];

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            cin >> g[i][j], (g[i][j] == '#' ? top[j] = max(top[j], n - i + 1) : 0);
    for (int i = 0; i <= n; i++)
        s[0][i] = 1;
    for (int i = 1; i <= m; i++)
        for (int j = top[i]; j <= n; j++)
            dp[j] = s[i - 1][min(j + 1, n)] - s[i - 1][max(top[i - 1] - 1, 0)],
            s[i][j] = ((j ? s[i][j - 1] : 0) + dp[j]) % mod;
    cout << s[m][n] << '\n';
    return 0;
}

G - One More Grid Task

观察到 $A_{i, j} \leq 300$ ，考虑枚举矩形的最小值，之后将所有小于最小值的元素都设为非法，剩下就是一个最大子矩形的板子了，顶多套个二维前缀和。

时间复杂度： $O (M A N)$ 。

#include <algorithm>
#include <cstring>
#include <iostream>
#include <queue>

using namespace std;

const int N = 3e2 + 10, M = 3e2;

int n, m, l[N][N], r[N][N], u[N][N];
int g[N][N];
long long s[N][N];
bool st[N];

long long sum(int a, int b, int c, int d)
{
    if (c < a || d < b)
        return 0;
    return s[c][d] - s[a - 1][d] - s[c][b - 1] + s[a - 1][b - 1];
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            cin >> g[i][j], s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + g[i][j], st[g[i][j]] = 1;
    long long ans = 0;
    for (int k = 1; k <= M; k++)
    {
        if (!st[k])
            continue; // 小优化
        memset(u, 0, sizeof u);
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= m; j++)
            {
                if (g[i][j] < k)
                    g[i][j] = 0;
                l[i][j] = r[i][j] = j;
            }
        for (int i = 1; i <= n; i++)
        {
            for (int j = 2; j <= m; j++)
                if (g[i][j] && g[i][j - 1])
                    l[i][j] = l[i][j - 1];
            for (int j = m - 1; j; j--)
                if (g[i][j] && g[i][j + 1])
                    r[i][j] = r[i][j + 1];
        }
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= m; j++)
            {
                if (!g[i][j])
                    continue;
                if (g[i - 1][j])
                    l[i][j] = max(l[i][j], l[i - 1][j]), r[i][j] = min(r[i][j], r[i - 1][j]);
                u[i][j] = u[i - 1][j] + 1;
                ans = max(ans, 1ll * k * sum(i - u[i][j] + 1, l[i][j], i, r[i][j]));
            }
        }
    }
    cout << ans << '\n';

    return 0;
}