bzoj4514: [Sdoi2016]数字配对--费用流

看了一眼题目&数据范围，觉得应该是带下界的费用流

原来想拆点变成二分图，能配对的连边，跑二分图，可行性未知

后来看到另外一种解法。。

符合匹配要求的数要满足：质因子的个数相差为1，且两者可整除

因此筛完素数、分解质因子，记录质因子的个数

奇数个分为一类，偶数个分为一类，那么连边一定是奇数向偶数才可以连，而其中能整除的且商为质数的连边

然后源点向奇数的点连边，偶数的点向汇点连边，跑费用流

至于下界，我们先把权值取负

由于是求最小费用，那么当求得费用刚好大于0时

上一次刚好小于零的费用流就是最终的流

答案就是上一次的流量

程序写的不是很简洁。。有些细节比如要开LL值得注意= =

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<vector>
#include<queue>
#define LL long long
#define INF 0x7fffffff
#define maxe 40000*2+10
#define maxn 1000
using namespace std;
struct node{
    int from,to,flow,next;
    LL cost;
}e[maxe];
int ans,cnt,head[maxn],pre[maxn],vis[maxn];
int n,s,t,a[maxn],b[maxn],notprime[32010],odd[maxn],even[maxn];
LL c[maxn],sum,dis[maxn];
vector<int> prime;

void insert(int u, int v, int f, LL c){
    e[++cnt].from=u;
    e[cnt].to=v;
    e[cnt].flow=f;
    e[cnt].cost=c;
    e[cnt].next=head[u];
    head[u]=cnt;
    e[++cnt].from=v;
    e[cnt].to=u;
    e[cnt].flow=0;
    e[cnt].cost=-c;
    e[cnt].next=head[v];
    head[v]=cnt;
}

void init(){
    scanf("%d", &n);
    for (int i=1; i<=n; i++) scanf("%d", &a[i]);
    for (int i=1; i<=n; i++) scanf("%d", &b[i]);
    for (int i=1; i<=n; i++) scanf("%lld", &c[i]);
}

bool judge(int i, int j){
    if (!a[i] || !a[j] || a[i]%a[j] && a[j]%a[i]) return 0;
    int tmp=max(a[i]/a[j], a[j]/a[i]);
    for (int k=0; k<prime.size(); k++)
        if (prime[k]>=tmp) break;
        else if (tmp % prime[k]==0) return 0;
    return 1;
}

void get_prime(){
    memset(notprime,0,sizeof(notprime));
    for (int i=2; i<=32000; i++)
        if (!notprime[i]){
            prime.push_back(i);
            for (int j=i*i; j<=32000; j+=i)
                notprime[j]=1;
        }
} 

void build(){
    odd[0]=even[0]=0;
    for (int i=1; i<=n; i++){
        int sum=0;
        for (int j=0; j<prime.size(); j++){
            int tmp=a[i];
            while (tmp%prime[j]==0) tmp/=prime[j],sum++;
        }
        if (sum&1) odd[++odd[0]]=i;
        else even[++even[0]]=i;
    }
    
    cnt=-1;
    memset(head,-1,sizeof(head));
    memset(e,0,sizeof(e));
    
    for (int i=1; i<=odd[0]; i++)
        for (int j=1; j<=even[0]; j++)
            if (judge(odd[i], even[j]))
                insert(odd[i],even[j],INF,-c[odd[i]]*c[even[j]]);
    s=n+1; t=n+2;
    for (int i=1; i<=odd[0]; i++)
        insert(s,odd[i],b[odd[i]],0);
    for (int i=1; i<=even[0]; i++)
        insert(even[i],t,b[even[i]],0);
}

bool spfa(){
    memset(pre,-1,sizeof(pre));
    memset(dis,127,sizeof(dis));
    queue<int> Q;
    Q.push(s);
    dis[s]=0; vis[s]=1;
    while (!Q.empty()){
        int now=Q.front();
        Q.pop();
        vis[now]=0;
        for (int i=head[now]; i!=-1; i=e[i].next){
            int v=e[i].to;
            if (e[i].flow>0 && dis[v]>dis[now]+e[i].cost){
                dis[v]=dis[now]+e[i].cost;
                pre[v]=i;
                if (!vis[v]){
                    vis[v]=1;
                    Q.push(v);
                }
            }
        }
    }
    if (pre[t]==-1) return 0; return 1;
}

bool flow(){
    int f=INF;
    for (int i=pre[t]; i!=-1; i=pre[e[i^1].to]) f=min(f,e[i].flow);
    if ((LL)sum+dis[t]*f<=0){
        for (int i=pre[t]; i!=-1; i=pre[e[i^1].to]){
            e[i].flow-=f; e[i^1].flow+=f;
        }
        sum+=dis[t]*f;
        ans+=f;
        return 1;
    }
    else{
        ans-=(sum/dis[t]); 
        return 0;
    }
}

void work(){
    ans=0; sum=0;
    while (spfa() && flow());
    printf("%d
", ans);
}

int main(){
    get_prime();
    init();
    build();
    work();
    return 0;
}