hdu多校第三场

第三场

D - Tokitsukaze and Multiple

thinking ：

题意是将给出的数相加计算出 其中p 的倍数的最大个数。由题意可得，在任意两个数相加时，其模值必在0—p-1之间，将两数相加的模值替换掉之前的两个数字，得到长度减一的效果，用0和1 标记对应模值是否出现，从而代表被处理过的但还没有达到 p 的倍数的值， 直到某次得到的模值为 0 时，再清空之前的标记（代表得到了 p 的倍数）；在此过程中记录清空标记的次数，b

code ：

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

int main(){
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);

    int T; cin >> T;
    while (T --){
        int n;
        int p;
        int x;
        cin >> n >> p;
        map<int, int> mp;//标记0--p-1是否出现
        mp[0] = 1;
        int now = 0, res = 0;
        for(int i = 0; i < n; i ++){
            cin >> x;
            now = (now + x) % p;
            if(mp.count(now)){//若出现过，则清栈
                res ++;
                mp.clear();
                mp[0] = 1;
                now = 0;
            }
            else{mp[now] = 1;}
        }
        cout << res << endl;
    }
    return 0;
}

E - Little W and Contest

thinking :

由题意可得，三个人为一组的小队中，至少需要两名能力为 2 的选手，最多需要一名能力为 1 的选手；而附加条件为任意两个选手之间不相互认识。当两个能力为1 的选手相互认识时，这显然对我们的组合结果没有影响，而当能力为 2 的选手与任意能力的选手认识时，组合的结果会在没有任何人相互认识的结果要小。由这个性质，我们可以先用二位数组ki[i][j]表示 i 位选手能力为 j 时的组合数，再先后一一添加在介绍后相互认识的选手，组成连通块，然后减去此连通块下，造成的组合数减少的数量，从而达到选手之间两两不相识的效果。

code :

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

typedef long long ll;
const int N = 100005;
const ll Mod = 1e9 + 7;
int one[N];
int two[N];
int x, n;
int u, v;
struct functions{
    ll ki[4][7];
    functions(){//构造函数
        memset(ki, 0, sizeof(ki));
        ki[0][0] = 1;
    }

    void init(){//初始化
        memset(ki, 0, sizeof(ki));
        ki[0][0] = 1;
    }

    void add_nCm(ll a, ll b){
        for(int i = 3; i; i--){
            for(int j = 6; j; j--){
                ki[i][j] += a * ki[i-1][j-1] % Mod;
                if(j > 1) ki[i][j] += b * ki[i-1][j-2] % Mod;
                ki[i][j] %= Mod;
            }
        }
    }

    void reduce_union(ll a, ll b){
        for(int i = 1; i <= 3; i++){
            for(int j = 1; j <= 6; j++){
                ki[i][j] -= a * ki[i-1][j-1] % Mod;
                if(j > 1) ki[i][j] -= b * ki[i-1][j-2] % Mod;
                ki[i][j] = (ki[i][j] % Mod + Mod) % Mod;
            }
        }
    }

    ll res() { return (ki[3][5] + ki[3][6]) % Mod; }

}solve;

int pos[N];

int find_pos(int p){ return pos[p] == p ? p : pos[p] = find_pos(pos[p]); }

void unions(ll x, ll y){
    const int pos_x = find_pos(x);
    const int pos_y = find_pos(y);
    one[pos_y] += one[pos_x];
    two[pos_y] += two[pos_x];
    pos[pos_x] = pos_y;
}

int main(){
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);

    int T; cin >> T;
    while(T--){
        solve.init();
        cin >> n;
        for(int i = 1; i <= n; i++){
            cin >> x;
            pos[i] = i;
            one[i] = two[i] = 0;
            if(x == 1) one[i] ++;
            else two[i] ++;
            solve.add_nCm(one[i], two[i]);
        }
        cout << solve.res() << endl;
        for(int i = 1; i < n; i++){
            cin >> u >> v;
            const int pos_u = find_pos(u);
            const int pos_v = find_pos(v);
            solve.reduce_union(one[pos_u], two[pos_u]);
            solve.reduce_union(one[pos_v], two[pos_v]);
            unions(u, v);
            solve.add_nCm(one[find_pos(u)], two[find_pos(u)]);
            cout << solve.res() << endl;
        }
    }
    return 0;
}