D - Seat Assignment ZOJ - 3997（最大流）

题意：
有10种人，第$i$种人只想做到$i$倍数编号座位上。每种人有$a[i]$个。
一共有$m$个座位，求最多让多少个人坐座位。

思路：
一个数可以是1~10中多个数的倍数，所以如果你优先放$i$的倍数，那么还可能会影响其他数的倍数。这就得去重。

先找出1~10中任意数字组成的公倍数，去重后剩下48个。假设第$i$个数字是$num[i]$，则$num[i]$的数目为$cnt[i]=\frac{m}{num[i]}$。

---

接下来得去重（相当于容斥），从后往前一次遍历$num$数组，对于$num[i]$这个数字，找到$num$数组中比他大并且是其倍数的数$num[j]$，则有$cnt[i]=cnt[i]-cnt[j]$。

这样对于每个数$num[i]$能分配多少个座位就分配好了。

---

接下来就是建图，
源点设置为0，汇点设置为100，则源点向每种人建图，容量为这种人个数$a[i]$，
每种人向其$num$数组中其倍数建图，容量为$cnt[i]$，
$num$数组总每种数向汇点建图，容量为$cnt[i]$，
结果就是最大流。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
typedef long long ll;

//网络流开始
const int inf = 1 << 30, N = 2005, M = 2005;
int head[N], ver[M], edge[M], Next[M], d[N];
int n, m, s, t, tot;
int maxflow;
queue<int> q;
void add(int x, int y, int z) {
    
    
    ver[++tot] = y, edge[tot] = z, Next[tot] = head[x], head[x] = tot;
    ver[++tot] = x, edge[tot] = 0, Next[tot] = head[y], head[y] = tot;
}

bool bfs() {
    
     // 在残量网络上构造分层图
    memset(d, 0, sizeof(d));
    while (q.size()) q.pop();
    q.push(s); d[s] = 1;
    while (q.size()) {
    
    
        int x = q.front(); q.pop();
        for (int i = head[x]; i; i = Next[i])
            if (edge[i] && !d[ver[i]]) {
    
    
                q.push(ver[i]);
                d[ver[i]] = d[x] + 1;
                if (ver[i] == t) return 1;
            }
    }
    return 0;
}

int dinic(int x, int flow) {
    
     // 在当前分层图上增广
    if (x == t) return flow;
    int rest = flow, k;
    for (int i = head[x]; i && rest; i = Next[i])
        if (edge[i] && d[ver[i]] == d[x] + 1) {
    
    
            k = dinic(ver[i], min(rest, edge[i]));
            if (!k) d[ver[i]] = 0; // 剪枝，去掉增广完毕的点
            edge[i] -= k;
            edge[i ^ 1] += k;
            rest -= k;
        }
    return flow - rest;
}


int cal() {
    
    
    int flow = 0;
    while (bfs())
        while (flow = dinic(s, inf)) maxflow += flow;
    return maxflow;
}

//网络流结束

int num[2005],cnt;

int gcd(int n,int m) {
    
    
    return m == 0 ? n : gcd(m,n % m);
}

void dfs(int x,int now) {
    
    
    if(x == 11) {
    
    
        num[++cnt] = now;
        return;
    }
    int tmp = gcd(now,x);
    dfs(x + 1,now * x / tmp); //算公倍数
    dfs(x + 1,now); //不算
}

void Pre() {
    
    
    dfs(1,1);
    sort(num + 1,num + 1 + cnt);
    cnt = unique(num + 1,num + 1 + cnt) - (num + 1);
}

void init() {
    
    
    s = 0;t = 100;
    tot = 1;
    maxflow = 0;
    memset(head,0,sizeof(head));
}

int cnt_p[20]; //输入的1~10
int cnt_n[N]; //每个数字对应的个数

int main() {
    
    
    Pre();
    int T;scanf("%d",&T);
    while(T--) {
    
    
        scanf("%d",&n);
        init();
        for(int i = 1;i <= 10;i++) {
    
    
            scanf("%d",&cnt_p[i]);
        }
        for(int i = 1;i <= cnt;i++) {
    
    
            cnt_n[i] = n / num[i];
        }
        for(int i = cnt;i >= 1;i--) {
    
    
            for(int j = i + 1;j <= cnt;j++) {
    
    
                if(num[j] % num[i] == 0) {
    
    
                    cnt_n[i] -= cnt_n[j];
                }
            }
            if(cnt_n[i] != 0) {
    
    
                add(i + 10,100,cnt_n[i]);
            }
        }
        for(int i = 1;i <= 10;i++) {
    
    
            if(cnt_p[i] == 0) continue;
            add(0,i,cnt_p[i]);
            for(int j = 1;j <= cnt;j++) {
    
    
                if(num[j] > n) break;
                if(num[j] % i == 0 && cnt_n[j] != 0) {
    
    
                    add(i,j + 10,cnt_n[j]);
                }
            }
        }
        printf("%d\n",cal());
    }
    return 0;
}