Description
Input
Output
一行一个数，最多进行多少次配对
Sample Input
2 4 8
2 200 7
-1 -2 1
Sample Output
HINT
n≤200，ai≤10^9，bi≤10^5，∣ci∣≤10^5
题解Here!
一次代表什么？代表用到一定上限就不能再用，同时每用一次会产生价值。
上限？价值？
网络流！
把一次匹配设为一点流量，那产生的价值不就是费用了吗？
我们考虑把一种数字抽象成一个点，可以匹配的数字之间连边，费用为$c[i] imes c[j]$，流量上限为.....
等等，流量上限怎么设？
而且还有一个问题：这里的匹配是双向的，虽然可以$O(n^2)$出所有匹配对，但是网络流要求是单向边啊！
别急，我们先来分析一下两个满足匹配条件的数，有什么性质。
设$i=p imes j$，其中$p$是一个质数。
那我们考虑$i$和$j$的质因数分解，会发现：它们俩分解出的质因数个数之间正好差一！
这说明了什么？
这说明匹配只有可能在质因数个数奇偶性不同的数对之间存在，而如果根据质因数个数的奇偶性把数分成两组，那么所有边都在两组之间！
这是什么？
二分图啊！
那么我们就可轻易把每条边定向成从奇数侧到偶数侧了！
接下来的事就简单了：
建立源点$S$和汇点$T$，从$S$连边到所有质因数个数为奇数的点$i$，费用为$0$，容量为$b[i]$，质因数个数为偶数的点连到$T$，同理。
这样，我们也一同限制了每个点最多流出去不超过$b[i]$的流量，也就是不发生超过$b[i]$次和这个数字有关的匹配。
因此对于原图中的可行匹配，只要连边，费用为$c[i] imes c[j]$，流量上限$MAX$。
然后跑最大费用最大流。
等一下，这道题是要求费用非负时的最大流量啊？
没关系，我们来贪心一波：
我们每次在图中做一个$SPFA$，找到费用最大的增广路，设它的总长度（费用）为$maxn$，同时设当前总费用为$maxcost$。
如果$maxn<-maxcost$，那么即使加上$1$的流量，总费用也负数了，这个时候结束循环，输出总流量$maxflow$即可
否则，如果$maxn>=0$，那么非常高兴，我们随便加，流量越多越好。
如果$maxn<0$，那么也没有问题，我们只要令流的流量为$min(flow[t],frac{maxcost}{-maxn})$，其中$flow[t]$为当前增广路的流量上限。
这样一直循环，直到因为上面的原因跳出，或者图不连通了为止，输出总流量$maxflow$，就是最大匹配数了。
贪心的证明很显然，我们每次都是取最优走，而且后面的决策肯定没有当前优，就证完了。
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<queue>
#define MAXN 210
#define MAXM 100010
#define MAX (1LL<<62)
using namespace std;
int n,s,t,c=2;
long long maxflow=0,maxcost=0;
int head[MAXN],deep[MAXN],fa[MAXN];
long long path[MAXN],flow[MAXN];
bool vis[MAXN];
int k=0,prime[MAXM];
bool np[MAXM];
struct Graph{
int next,to;
long long w,cost;
}a[MAXM<<1];
struct Number{
long long a,b,c,s;
}num[MAXN];
inline long long read(){
long long date=0,w=1;char c=0;
while(c<'0'||c>'9'){if(c=='-')w=-1;c=getchar();}
while(c>='0'&&c<='9'){date=date*10+c-'0';c=getchar();}
return date*w;
}
void make(){
int m=MAXN-10;
np[0]=np[1]=true;
for(int i=2;i<=m;i++){
if(!np[i])prime[++k]=i;
for(int j=1;j<=k&&prime[j]*i<=m;j++){
np[prime[j]*i]=true;
if(i%prime[j]==0)break;
}
}
}
inline int count(int x){
int s=0;
for(int i=1;i<=k&&prime[i]*prime[i]<=x&&x>1;i++){while(x%prime[i]==0){x/=prime[i];s++;}}
if(x>1)s++;
return s;
}
inline int relax(int u,int v,int i,long long w,long long cost){
if(path[v]>path[u]+cost){
path[v]=path[u]+cost;
fa[v]=u;
deep[v]=i;
flow[v]=min(flow[u],w);
return 1;
}
return 0;
}
inline void add(int u,int v,long long w,long long cost){
a[c].to=v;a[c].w=w;a[c].cost=-cost;a[c].next=head[u];head[u]=c++;
a[c].to=u;a[c].w=0;a[c].cost=cost;a[c].next=head[v];head[v]=c++;
}
bool spfa(){
int u,v;
queue<int> q;
for(int i=1;i<=t;i++){path[i]=MAX;vis[i]=false;fa[i]=-1;deep[i]=0;}
path[s]=0;
vis[s]=true;
fa[s]=0;
flow[s]=MAX;
q.push(s);
while(!q.empty()){
u=q.front();
q.pop();
vis[u]=false;
for(int i=head[u];i;i=a[i].next){
v=a[i].to;
if(a[i].w&&relax(u,v,i,a[i].w,a[i].cost)&&!vis[v]){
vis[v]=true;
q.push(v);
}
}
}
if(path[t]==MAX)return false;
return true;
}
void EK(){
long long nowflow;
while(spfa()){
path[t]=-path[t];
if(path[t]+maxcost<0)break;
if(path[t]>=0)nowflow=flow[t];
else nowflow=min(flow[t],maxcost/(-path[t]));
maxflow+=nowflow;
maxcost+=nowflow*path[t];
for(int i=t;i!=s;i=fa[i]){
a[deep[i]].w-=nowflow;
a[deep[i]^1].w+=nowflow;
}
}
}
void work(){
EK();
printf("%lld
",maxflow);
}
void init(){
make();
n=read();
s=n+1;t=n+2;
for(int i=1;i<=n;i++){
num[i].a=read();
num[i].s=count(num[i].a);
}
for(int i=1;i<=n;i++){
num[i].b=read();
if(num[i].s&1)add(s,i,num[i].b,0);
else add(i,t,num[i].b,0);
}
for(int i=1;i<=n;i++)num[i].c=read();
for(int i=1;i<=n;i++)
for(int j=i+1;j<=n;j++)
if((num[i].a%num[j].a==0&&num[i].s==num[j].s+1)||(num[j].a%num[i].a==0&&num[j].s==num[i].s+1)){
if(num[i].s%2)add(i,j,MAX,num[i].c*num[j].c);
else add(j,i,MAX,num[i].c*num[j].c);
}
}
int main(){
init();
work();
return 0;
}