HDU - 5514 容斥原理

题意：

m个石头围成一个环，编号从0到m-1，有n个青蛙在编号为0的石头上开始往后跳，每只青蛙可以从第j个石头跳到第j+a[i]个石头，每个石头只要被青蛙跳到一次，就算被占领(永久)，问最后被占领的石头的编号总和是多少？

思路：

利用巧妙的容斥思想，并不是简单的套用模板。

首先能够观察到每个青蛙能跳到的位置是d[i] = k * gcd(a[i], m)，但是lcm(d[i], d[j])有重复，所以需要容斥。

很关键的一点是，要想到这里lcm一定是m的因子。那么其实最后就是在m的因子上进行计算贡献。

用vis和num分别表示这个因子是否被占领，以及到当前为止这个因子被计算的次数，很显然多算的就要减掉，少算的就要加上，所以对于每个因子fa[i]被计算的次数就是vis[i] - num[i]，并且每次还要更新之后的因子被计算的次数。

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 1e4 + 10;

int a[MAXN];
int vis[MAXN];		// vis表示最终这个位置的因子是否会被占领	
int num[MAXN];		// num表示这个因子被计算了多少次，正值就是多算了，负值就是少算了
vector <int> fa;

int gcd(int a, int b) {
    if (b == 0) return a;
    return gcd(b, a % b);
}

void Fact(int x) {			// 处理出因子
    fa.clear();
    int m = sqrt(x + 0.5);
    for (int i = 1; i <= m; i++) {
        if (x % i == 0) {
            fa.push_back(i);
            if (x / i != i) {
                fa.push_back(x / i);
            }
        }
    }
    sort(fa.begin(), fa.end());
}

ll cal(int x, ll m) {		// 计算贡献
    int t = (m - 1) / x;
    ll res = (ll)(t + 1) * t / 2 * x;
    return res;
}

int main() {
    //freopen("in.txt", "r", stdin);
    int T, cs = 0;
    scanf("%d", &T);
    while (T--) {
        int n, m;
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= n; i++) {
            scanf("%d", &a[i]);
            a[i] = gcd(a[i], m);
        }
        Fact(m);
        memset(num, 0, sizeof(num));		
        memset(vis, 0, sizeof(vis));
        int cnt = fa.size();
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j < cnt; j++) {
                if (fa[j] % a[i] == 0)		// vis[j] = 1说明fa[j]这个因子最终会被占领
                    vis[j] = 1;
            }
        }
        ll ans = 0;
        vis[cnt - 1] = 0;
        for (int i = 0; i < cnt; i++) {
            if (vis[i] - num[i] == 0) continue;		// 如果vis == num说明这个因子没有被多算也没有被少算
            ans += (vis[i] - num[i]) * cal(fa[i], m);
            int tmp = vis[i] - num[i];
            for (int j = i + 1; j < cnt; j++) {	
                if (fa[j] % fa[i] == 0) {
                    num[j] += tmp;		// 若当前fa[i]被多算了tmp次，那么表示fa[i]的倍数都会被多算tmp次
                }
            }
           // printf("%d %d\n", fa[i], t);
        }
        printf("Case #%d: %I64d\n", ++cs, ans);
    }
    return 0;
}