Codeforces Round #266 (Div. 2) DE题解

D. Increase Sequence

题意：给一个数组，你可以选择若干个区间 [Li, Ri]进行区间加1，要求同一个左端点Li 和同一个右端点Ri不能用两次，问有多少种方案，使得数组每个数都等于h。

思路：设dp[i][j]为前 i 个数都等于h且还有 j 个左端点未匹配的方案数。那么我们要求的答案就是dp[n][0]。转移方程如下：

当 ai + j = h：

                    第 i 个数不新增任何端点：dp[i][j] += dp[i-1][j]

                    第 i 个数新增左端点：dp[i][j] += dp[i-1][j-1]

当 ai + j + 1 = h

                    第 i 个数新增右端点，那么这个右端点前面有 j + 1个左端点可以匹                配：dp[i][j] += dp[i-1][j+1] * (j+1)

                    第 i 个数新增左端点和右端点：dp[i][j] += dp[i-1][j] * (j+1)

代码实现我用了滚动数组

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn = 2005, mod = 1e9 + 7;
ll dp[2][maxn];
void add(ll &x, ll y) {
    x += y;
    if (x >= mod)
        x -= mod;
}
int main() {
    int n, h, x, cur = 0;
    cin>>n>>h>>x;
    if (x == h || x == h - 1)
        dp[cur][0] = 1;
    if (x == h - 1)
        dp[cur][1] = 1;
    while (--n) {
        cin>>x;
        cur = !cur;
        memset(dp[cur], 0, sizeof(dp[cur]));
        int i = h - x - 1;
        for (int j = max(0, i); j <= i + 1; j++) {
            if (j + x == h) {
                add(dp[cur][j], dp[!cur][j]);
                add(dp[cur][j], dp[!cur][j - 1]);
            }
            if ( j + x == h - 1) {
                add(dp[cur][j], dp[!cur][j + 1] * (j + 1) % mod);
                add(dp[cur][j], dp[!cur][j] * (j + 1) % mod);
            }
        }
    }
    cout<<dp[cur][0];
}

E. Information Graph

题意：有三种操作：1 x y ：将x的父亲设为y（保证之前x没有父亲），2 x ：新增了一份文件，x 到 x当前的根路径上所有节点都会接受这份文件，3 x i：询问x是否收到了第 i 份文件

思路：对于每一份文件，我都存好接受这份文件的的 x 节点和 x 的根节点 rt，那么问题转化成：查询 y 节点是否在 x 到 rt 的路径中，我们先对每颗树进行dfs序，设L[u]为u的dfs序，R[u]为u的子树中节点中最大的dfs序，如果 y 是 x 的祖先，那么显然满足一个条件：L[y] <= L[x] && R[y] >= R[x]，那么根据这个性质，就可以解决掉这个题了

#include<bits/stdc++.h>
#define mk make_pair
#define pb push_back
#define pi pair<int, int>
using namespace std;
const int maxn = 1e5 + 10;
vector<int> G[maxn];
pi val[maxn];
int L[maxn], R[maxn], p[maxn], cnt;
struct node {
    int opt, x, y;
}a[maxn];
int find(int x) {
    if (p[x] != x)
        p[x] = find(p[x]);
    return p[x];
}
void dfs(int u) {
    L[u] = ++cnt;
    for (auto v : G[u])
        dfs(v);
    R[u] = cnt;
}
int main() {
    int n, q, num = 0;
    cin>>n>>q;
    for (int i = 1; i <= n; i++)
        p[i] = i;
    for (int i = 1; i <= q; i++) {
        cin>>a[i].opt>>a[i].x;
        if (a[i].opt == 1) {
            cin>>a[i].y;
            G[a[i].y].pb(a[i].x);
            int x = find(a[i].x);
            int y = find(a[i].y);
            p[x] = y;
        }
        else if(a[i].opt == 2) {
            num++;
            int y = find(a[i].x);
            val[num] = mk(a[i].x, y);
        }
        else
            cin>>a[i].y;
    }
    for (int i = 1; i <= n; i++)
        if (!L[i]) {
            int root = find(i);
            dfs(root);
        }
    for (int i = 1; i <= q; i++) {
        if (a[i].opt != 3)
            continue;
        int cur = a[i].y;
        int x = val[cur].first;
        int rt = val[cur].second;
        int o = a[i].x;
        if (L[o] <= L[x] && R[o] >= R[x] && L[rt] <= L[o] && R[rt] >= R[o])
            puts("YES");
        else
            puts("NO");
    }
}