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];
 ],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=;
     e[cnt].cost=-c;
     e[cnt].next=head[v];
     head[v]=cnt;
 }

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

 bool judge(int i, int j){
     ;
     int tmp=max(a[i]/a[j], a[j]/a[i]);
     ; k<prime.size(); k++)
         if (prime[k]>=tmp) break;
         ) ;
     ;
 }

 void get_prime(){
     memset(notprime,,sizeof(notprime));
     ; i<=; i++)
         if (!notprime[i]){
             prime.push_back(i);
             ; j+=i)
                 notprime[j]=;
         }
 } 

 void build(){
     odd[]=even[]=;
     ; i<=n; i++){
         ;
         ; j<prime.size(); j++){
             int tmp=a[i];
             ) tmp/=prime[j],sum++;
         }
         ) odd[++odd[]]=i;
         ]]=i;
     }

     cnt=-;
     memset(head,-,sizeof(head));
     memset(e,,sizeof(e));

     ; i<=odd[]; i++)
         ; j<=even[]; j++)
             if (judge(odd[i], even[j]))
                 insert(odd[i],even[j],INF,-c[odd[i]]*c[even[j]]);
     s=n+; t=n+;
     ; i<=odd[]; i++)
         insert(s,odd[i],b[odd[i]],);
     ; i<=even[]; i++)
         insert(even[i],t,b[even[i]],);
 }

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

 bool flow(){
     int f=INF;
     ; i=pre[e[i^].to]) f=min(f,e[i].flow);
     ){
         ; i=pre[e[i^].to]){
             e[i].flow-=f; e[i^].flow+=f;
         }
         sum+=dis[t]*f;
         ans+=f;
         ;
     }
     else{
         ans-=(sum/dis[t]);
         ;
     }
 }

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

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