2019.01.11【BZOJ3308】【ProjectEuler335】九月的咖啡店/Maximal coprime subset（费用流）-CSDN博客

传送门

讲题前的扯淡：

目前这个结论真的是令人窒息的找不到证明：

1.答案集合中的每个数至多包含两个不同的质因子。
2.如果含有两个不同质因子，必然一个比 $\sqrt n$ 大而另一个比 $\sqrt n$ 小。

更窒息的是，它似乎是对的。

由于不会翻墙，我也没去国外网站找题解。

令人震惊的是欧拉计划里面的thread里面有一位dalao居然用加了特技的贪心用Python在6s里面跑出来了2e6的解。
我：？？？

然后接下来两位dalao丢出了上面这个结论，我就开始凌乱了，因为他们没有放证明。。。

接下来一位dalao用他WA的经历告诉我们，一个数确实不能由超过两个不同质因子构成。
我：？？？

然后一位dalao通过找规律发现了这个结论。。。

我看到thread的最后，一位dalao说这道题像一道经典的NP_Complete问题，我已经不敢看了：https://en.wikipedia.org/wiki/Set_packing

其他dalao不是写的贪心就是模糊搜索，或者模拟退火，还有就是网络流和二分图匹配。。。

突然看到一位dalao放了一个链接，说是做这道题的过程，我满怀感激地打开，还是没有证明！！！
https://cs.stackexchange.com/questions/60677/set-with-maximum-sum-consisting-of-mutually-co-prime-numbers#
不过他又发现了这个结论。。。

为什么欧拉计划不首先让出题人给出一个证明啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊！！！！！

思路：

这道这个结论是不是很好做了？

怎么做？~~模拟退火~~

我们发现所有在 $[\lceil n/2\rceil,n]$ 的所有质数，都不可能再得到更大的数，所以我们可以直接把它们放到答案中。

剩下的先求出最大幂加到答案里面。

然后按照结论分两部分构图，连边为两个质数合在一起的最大幂减去原来两个的贡献。

跑最大费用可行流。

注意是可行流（没试过最大流能不能过）

代码：

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define re register
#define gc get_char
#define pc put_char
#define cs const

struct edge{
	int to,cap,rev;
	ll cost;
	edge(cs int &_to,cs int &_cap,cs ll &_cost,cs int &_rev):to(_to),cap(_cap),cost(_cost),rev(_rev){}
};

cs int N=200005;
vector<edge> G[N];
inline void addedge(int u,int v,int flow,ll cost){
	G[u].push_back(edge(v,flow,cost,G[v].size()));
	G[v].push_back(edge(u,0,-cost,G[u].size()-1));
}

ll dist[N];
int cur[N];
queue<int> q;
bool vis[N];

cs int S=0,T=N-1;
inline bool SPFA(){
	memset(dist,-0x3f,sizeof dist);
	memset(cur,0,sizeof cur);
	memset(vis,0,sizeof vis);
	dist[S]=0;
	q.push(S);
	while(!q.empty()){
		re int u=q.front();
		q.pop();vis[u]=false;
		for(int re e=0;e<G[u].size();++e){
			re int v=G[u][e].to;
			if(G[u][e].cap){
				if(dist[v]<dist[u]+G[u][e].cost){
					dist[v]=dist[u]+G[u][e].cost;
					if(!vis[v])q.push(v),vis[v]=true;
				}
			}
		}
	}
	return dist[T]>0;
}

inline ll dfs(int u,cs ll &flow,ll &cost){
	if(u==T){
		cost+=dist[T]*flow;
		return flow;
	}
	vis[u]=true;
	re ll ans=0;
	for(int re &e=cur[u];e<G[u].size();++e){
		re int v=G[u][e].to,rev=G[u][e].rev;
		if(!vis[v]&&G[u][e].cap&&dist[u]+G[u][e].cost==dist[v]){
			ll delta=dfs(v,min(flow-ans,(ll)G[u][e].cap),cost);
			if(delta){
				ans+=delta;
				G[u][e].cap-=delta;
				G[v][rev].cap+=delta;
				if(ans==flow){
					vis[u]=false;
					return ans;
				}
			}
		}
	}
	vis[u]=false;
	return ans;
}

inline ll MCAF(){//Max Cost Avaiable Flow
	ll cost=0;
	while(SPFA())dfs(S,0x3f3f3f3f3f3f,cost);
	return cost;
}

int prime[N],pcnt;
bool mark[N];
inline void linear_sieves(int len=N-5){
	for(int re i=2;i<=len;++i){
		if(!mark[i])prime[++pcnt]=i;
		for(int re j=1;i*prime[j]<=len;++j){
			mark[i*prime[j]]=true;
			if(i%prime[j]==0)break;
		}
	}
}

ll ans;

inline ll get_max_pow(ll limit,int base){
	ll t=1;
	while(t*base<=limit)t*=base;
	return t;
}

inline void build_G(int n){
	vector<int> A,B;
	for(int re i=1;i<=pcnt;++i){
		re int p=prime[i];
		if(p*2>n)ans+=p;
		else {
			if(p*p>n){
				addedge(i,T,1,0);
				ans+=p;
				B.push_back(i);
			}
			else {
				addedge(S,i,1,0);
				ans+=get_max_pow(n,p);
				A.push_back(i);
			}
		}
	}
	for(int re i=0;i<A.size();++i)
	for(int re j=0;j<B.size();++j){
		re int a=prime[A[i]],b=prime[B[j]];
		if(a*b>n)break;
		int tmp=get_max_pow(n/b,a)*b;
		if(tmp>get_max_pow(n,a)+b){
			addedge(A[i],B[j],1,tmp-get_max_pow(n,a)-b);
		}
	}
}

int n;
signed main(){
	scanf("%d",&n);
	linear_sieves(n);
	build_G(n);
	printf("%lld",ans+MCAF()+1);
	return 0;
}