AtCoder Beginner Contest 183

AtCoder Beginner Contest 183

E - Queen on Grid

题意：

再一个矩阵中从1，号点到$(n,m)$号点你的总共步数。

题解：

前缀和优化dp 记得dp从$(1,1)$赋值， 先把三维的dp先出来然后看看怎么用前缀和优化

代码：

#include<bits/stdc++.h>
using namespace std;
const int N = 2007;
typedef long long ll;

ll dp[N][N], n, m, fn[N][N], f[N][N];
const ll mod = 1e9 + 7;

ll x[N][N], y[N][N], z[N][N];

char mp[N][N];

int main() {
    scanf("%lld %lld", &n, &m);
    
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            scanf(" %c", &mp[i][j]);
        }
    }
    dp[1][1] = 1;
    x[1][1] = 1, y[1][1] = 1, z[1][1] = 1;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (i == 1 && j == 1) continue;
            if (mp[i][j] == '.') {
                dp[i][j] = (x[i - 1][j] + y[i][j - 1] + z[i - 1][j - 1]) % mod;

                x[i][j] = (x[i - 1][j] + dp[i][j]) % mod;
                y[i][j] = (y[i][j - 1] + dp[i][j]) % mod;
                z[i][j] = (z[i - 1][j - 1] + dp[i][j]);
            } else {
                x[i][j] = y[i][j] = z[i][j] = dp[i][j] = 0;
            }
            // 三维 dp
            // for (int k = i - 1; k; k--) {
            //     dp[i][j] += dp[k][j];
            // }
            // for (int k = j - 1; k; k--) {
            //     dp[i][j] += dp[i][k];
            // }
            // for (int k = 1; k < min(i, j); k++) {
            //     dp[i][j] += dp[i - k][j - k];
            // }
        }
    }
    cout << dp[n][m] << endl;
}

---

F - Confluence

题意：

给你 m个班级 n个学生， 第i学生属于 a[i]班级。刚开始每个学生为一组

然后用 q次询问

• $1,a,b$ 将 $a$ 组 $b$组的成员合并成一个组
• $2,x,y$ 询问$x$组中$y$班的学生有多少个？

题解：

这题很容易想到并查集， 用map记录每个几何， 每个班数， 当合并并查集的时候用启发式合并， 所谓的启发式合并就是将小集合加入大集合中，这样时间复杂度就是 $o(n\ast log(n)\ast log(n))$

关于启发式合并复杂度简单证明

每次合并都是小集合向大集合合并

假设 这个集合有x个且每个集合大小相等， 那么就是平均每个集合大小为 $\frac{n}{x}$ ，那么最好的情况就是

每次都是最小的向大的合并，总共合并 $x-1$次， 时间复杂度为 $o(n)$, 最坏的情况也就是， 两两合并然后再两两合并， 类似归并排序 时间复杂度为 $o(log(n))$;

代码:

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

const int N = 2e5 + 7;

int fa[N], n, q, a[N], sz[N];

map<int, int> v[N];

int find(int x) {
    if (x != fa[x]) {
        return fa[x] = find(fa[x]);
    }
    return x;
}

int main() {
    scanf("%d %d", &n, &q);
    for (int i = 1; i <= n; i++) {
        fa[i] = i;
        sz[i] = 1;
    }
    for (int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
    }
    for (int i = 1; i <= n; i++) {
        v[i][a[i]]++;
    }

    while (q--) {
        int op, l, r;
        scanf("%d %d %d", &op, &l, &r);
        if (op == 1) {
            int fx = find(l);
            int fy = find(r);
            if (fx == fy) continue;
            if (sz[fx] > sz[fy]) swap(fx, fy);
       
            for (auto i: v[fx]) {
                v[fy][i.first] += v[fx][i.first];
              
            }
            sz[fy] += sz[fx];
            fa[fx] = fa[fy];
        } else {
            int fx = find(l);
            printf("%d\n", v[fx][r]);
        }
    }

    
}