所谓的日常 #10

div.2

CodeForces 546B Soldier and Badges

给定n(<= 3000)个整数Ai，有一种操作：给某个数加1。问最少操作几次，使得n个数都不一样。

考虑这样一个问题：已知一个数组B，用上面的操作，把A变成B的最小代价怎么算。

一个最优的方法是，把A中最小的数变成B中最小的数，把A中次小的数变成B中次小的数...把A中最大的数变成B中最大的数。

所以做法就出来了。先把A数组排序，然后把A[i]变成max(A[i],B[i - 1] + 1)即可。(因为同样要保证变化完后B数组递增)

#include <stdio.h>
#include <algorithm>

int A[3000];
int n;

int main() {
    scanf("%d",&n);
    for (int i = 0; i < n; ++ i) {
        scanf("%d",A + i);
    }
    std::sort(A,A + n);
    int answer = 0;
    for (int i = 1; i < n; ++ i) {
        if (A[i] <= A[i - 1]) {
            answer += A[i - 1] + 1 - A[i];
            A[i] = A[i - 1] + 1;
        }
    }
    printf("%d
",answer);
}

div.1

CodeForces 461B Appleman and Tree

给定一棵n(<=1e5)个节点的树，每个节点有颜色(黑或白)，让你删掉一些边使得剩下的每个连通块内都恰好只有1个黑点。问删边的方案数。

那么就dp(u,c)表示节点u的子数，与u关联的连通块有/无黑点的状态是c，的方案数。

然后就是一个树dp啦。

#include <bits/stdc++.h>

const int MOD = (int)1e9 + 7;
const int N = 100000 + 5;
std::vector<int> edges[N];
int color[N];
int n;
int dp[N][2];

inline void add(int &a,int b) {
    a += b;
    if (a >= MOD) a -= MOD;
}

void dfs(int u) {
    if (color[u] == 1) {
        dp[u][1] = 1;
        dp[u][0] = 0;
    } else {
        dp[u][0] = 1;
        dp[u][1] = 0;
    }
    for (int i = 0; i < edges[u].size(); ++ i) {
        int v = edges[u][i];
        dfs(v);
        int tmp[2] = {};
        for (int a = 0; a < 2; ++ a) {
            for (int b = 0; b < 2; ++ b) {
                add(tmp[a | b],dp[u][a] * 1ll * dp[v][b] % MOD);
                if (a == 0 && b == 1) {
                    add(tmp[0],dp[u][a] * 1ll * dp[v][b] % MOD);
                }
            }
        }
        dp[u][0] = tmp[0];
        dp[u][1] = tmp[1];
    }

}

int work() {
    dfs(0);
    return dp[0][1];
}

int main() {
    scanf("%d",&n);
    for (int i = 1; i < n; ++ i) {
        int x;
        scanf("%d",&x);
        edges[x].push_back(i);
    }
    for (int i = 0; i < n; ++ i) {
        scanf("%d",color + i);
    }
    printf("%d
",work());
}