BZOJ4514: [Sdoi2016]数字配对

BZOJ4514: [Sdoi2016]数字配对

Description

有 n 种数字，第 i 种数字是 ai、有 bi 个，权值是 ci。

若两个数字 ai、aj 满足，ai 是 aj 的倍数，且 ai/aj 是一个质数，

那么这两个数字可以配对，并获得 ci×cj 的价值。

一个数字只能参与一次配对，可以不参与配对。

在获得的价值总和不小于 0 的前提下，求最多进行多少次配对。

Input

第一行一个整数 n。

第二行 n 个整数 a1、a2、……、an。

第三行 n 个整数 b1、b2、……、bn。

第四行 n 个整数 c1、c2、……、cn。

Output

 一行一个数，最多进行多少次配对

Sample Input

3
2 4 8
2 200 7
-1 -2 1

Sample Output

4

HINT

 n≤200，ai≤10^9，bi≤10^5，∣ci∣≤10^5

---

题解Here!

 

比较裸的最大费用最大流，然而我调了$1h$，后来发现全改$long\ long$就过了。。。

什么鬼。。。

首先扎住题目关键：

一个数字能且只能匹配一次。

一次代表什么？代表用到一定上限就不能再用，同时每用一次会产生价值。
上限？价值？
网络流！
把一次匹配设为一点流量，那产生的价值不就是费用了吗？
我们考虑把一种数字抽象成一个点，可以匹配的数字之间连边，费用为$c[i]\times c[j]$，流量上限为.....
等等，流量上限怎么设？
而且还有一个问题：这里的匹配是双向的，虽然可以$O(n^2)$出所有匹配对，但是网络流要求是单向边啊！
别急，我们先来分析一下两个满足匹配条件的数，有什么性质。
设$i=p\times j$，其中$p$是一个质数。
那我们考虑$i$和$j$的质因数分解，会发现：它们俩分解出的质因数个数之间正好差一！
这说明了什么？
这说明匹配只有可能在质因数个数奇偶性不同的数对之间存在，而如果根据质因数个数的奇偶性把数分成两组，那么所有边都在两组之间！
这是什么？
二分图啊！
那么我们就可轻易把每条边定向成从奇数侧到偶数侧了！
接下来的事就简单了：
建立源点$S$和汇点$T$，从$S$连边到所有质因数个数为奇数的点$i$，费用为$0$，容量为$b[i]$，质因数个数为偶数的点连到$T$，同理。
这样，我们也一同限制了每个点最多流出去不超过$b[i]$的流量，也就是不发生超过$b[i]$次和这个数字有关的匹配。
因此对于原图中的可行匹配，只要连边，费用为$c[i]\times c[j]$，流量上限$MAX$。
然后跑最大费用最大流。
等一下，这道题是要求费用非负时的最大流量啊？
没关系，我们来贪心一波：
我们每次在图中做一个$SPFA$，找到费用最大的增广路，设它的总长度（费用）为$maxn$，同时设当前总费用为$maxcost$。
如果$maxn<-maxcost$，那么即使加上$1$的流量，总费用也负数了，这个时候结束循环，输出总流量$maxflow$即可
否则，如果$maxn>=0$，那么非常高兴，我们随便加，流量越多越好。
如果$maxn<0$，那么也没有问题，我们只要令流的流量为$min(flow[t],\frac{maxcost}{-maxn})$，其中$flow[t]$为当前增广路的流量上限。
这样一直循环，直到因为上面的原因跳出，或者图不连通了为止，输出总流量$maxflow$，就是最大匹配数了。
贪心的证明很显然，我们每次都是取最优走，而且后面的决策肯定没有当前优，就证完了。

最大费用最大流怎么做？emmm......

把所有的费用变成相反数，跑最小费用最大流，最后把费用再变成相反数即可。

然而并不知道那些直接把$>$改成$<$的人是怎么过的。。。

附代码：

#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\n",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;
}

 

转载于:https://www.cnblogs.com/Yangrui-Blog/p/9527373.html