CodeForces 498C Array and Operations 最大流

题目：http://codeforces.com/problemset/problem/498/C

题意：给定一个长度为n的数组，有m对(i, j)，i + j一定为奇数，意味着可以从数组中拿出第i个数和第j个数，然后除以它们的公约数（大于1），再放回数组中，持续这样操作，问最多可以操作多少次

思路：i + j一定为质数，可以二分偶数奇数建图。想要操作最多，那么肯定每次除以他们的质因子，因为数据范围为1e9，所以枚举质数到1e5，对于当前枚举的质因子，从每个数中除掉当前质因子，统计每个数中有几个，然后从源点向奇数点两边，容量为这个数含有当前质因子的数量，从偶数点向汇点连边，容量为这个数含有当前质因子的数量， 然后奇数点向偶数点连边，容量为两者质因子数量的较小值。最后剩下不为1的数，肯定为大于1e5的质数，对于两个大质数只有相等才能进行一次操作，连边容量为1，分别和源点汇点连边容量为1

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#define debug() puts("here")
using namespace std;

const int N = 110, M = 100100;
const int INF = 0x3f3f3f3f;
struct edge
{
    int to, cap, next;
} g[N*N*2];
int cnt, nv, head[N], level[N], gap[N], cur[N], pre[N], arr[M];
int prime[M], k, x[N], y[N], a[N];
int cas;
void add_edge(int v, int u, int cap)
{
    g[cnt].to = u, g[cnt].cap = cap, g[cnt].next = head[v], head[v] = cnt++;
    g[cnt].to = v, g[cnt].cap = 0, g[cnt].next = head[u], head[u] = cnt++;
}
int sap(int s, int t)
{
    memset(level, 0, sizeof level);
    memset(gap, 0, sizeof gap);
    memcpy(cur, head, sizeof head);
    gap[0] = nv;
    int v = pre[s] = s, flow = 0, aug = INF;
    while(level[s] < nv)
    {
        bool flag = false;
        for(int &i = cur[v]; i != -1; i = g[i].next)
        {
            int u = g[i].to;
            if(g[i].cap > 0 && level[v] == level[u] + 1)
            {
                flag = true;
                pre[u] = v;
                v = u;
                aug = min(aug, g[i].cap);
                if(v == t)
                {
                    flow += aug;
                    while(v != s)
                    {
                        v = pre[v];
                        g[cur[v]].cap -= aug;
                        g[cur[v]^1].cap += aug;
                    }
                    aug = INF;
                }
                break;
            }
        }
        if(flag) continue;
        int minlevel = nv;
        for(int i = head[v]; i != -1; i = g[i].next)
        {
            int u = g[i].to;
            if(g[i].cap > 0 && minlevel > level[u])
                minlevel = level[u], cur[v] = i;
        }
        if(--gap[level[v]] == 0) break;
        level[v] = minlevel + 1;
        gap[level[v]]++;
        v = pre[v];
    }
    return flow;
}
void table()
{
    k = 0;
    for(int i = 2; i < M; i++)
        if(! arr[i])
        {
            prime[++k] = i;
            for(int j = i * 2; j < M; j += i)
                arr[j] = 1;
        }
}
bool jud(int val)
{
    if(val >= M) return true;
    else return false;
}
int main()
{
    table();
    int n, m;
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i++) scanf("%d", &a[i]);
    for(int i = 1; i <= m; i++)
    {
        scanf("%d%d", &x[i], &y[i]);
        if(y[i] & 1) swap(x[i], y[i]);
    }
    int ss = 0, tt = n + 1, res = 0;
    for(int i = 1; i <= k; i++)
    {
        int num[N];
        memset(num, 0, sizeof num);
        for(int j = 1; j <= n; j++)
            while(a[j] % prime[i] == 0)
            {
                num[j]++, a[j] /= prime[i];
            }
        cnt = 0;
        memset(head, -1, sizeof head);
        for(int j = 1; j <= n; j += 2) add_edge(ss, j, num[j]);
        for(int j = 2; j <= n; j += 2) add_edge(j, tt, num[j]);
        for(int j = 1; j <= m; j++) add_edge(x[j], y[j], min(num[x[j]], num[y[j]]));
        nv = tt + 1;
        res += sap(ss, tt);
    }
    cnt = 0;
    memset(head, -1, sizeof head);
    for(int i = 1; i <= n; i += 2)
        if(jud(a[i])) add_edge(ss, i, 1);
    for(int i = 2; i <= n; i += 2)
        if(jud(a[i])) add_edge(i, tt, 1);
    for(int i = 1; i <= m; i++)
        if(jud(a[i]) && a[x[i]] == a[y[i]]) add_edge(x[i], y[i], 1);
    nv = tt + 1;
    res += sap(ss, tt);
    printf("%d\n", res);
    return 0;
}