BZOJ#3218. a + b Problem——网络流最小割+树形建图

题目

黑暗爆炸P3218

题解

当你看到标题说用网络流做A+B时，第一反应：这怕是个恶搞博客

但是这题不是A+B，是a+b！（区分大小写），你看了题面就会发现不对劲...

搞入正题，我们可以先把问题转化一下：

先把所有减去，若该点是白色，或该点以及前面的符合要求的点都是黑色时加上。

这时如果搞出一个点S表示白，T表示黑，把数组中每个点拍在图上，定义与S之间有边相连的点为白点，与T之间有边相连的点为黑色，

这题就可以转换成一个最小割问题。

从S连过来的边容量为，连向T的边容量为（注意方向），

然后这个要求一堆点为黑色的条件怎么处理呢？

可以建一个虚点（相应地，数组中的点对应图上的点为实点），有一条容量为的边连向T，因为根据要求，如果该边没被割，虚点顺利连向T，那么对应必须为黑点的若干个实点也必须有边连向T，所以可以从每个点建立一条容量为INF的边连向虚点。因为容量为极大值，这种边不可能包含在最小割中，也就无法被割。

至此我们跑一个最大流Dinic求出最小割，然后用边容量的总和（除了INF的边）减去它不久解决了？

然而这题范围很不友好，，按照上面的建图法，虽然点数是级别，但是边数；

空间也不友好，每个测试点只有48MB，只好小心翼翼地开int。。

所以我们考虑通过多建些虚点来减少边的数量，具体由很多种做法，光分块就不止一种。

我只介绍一种很稳妥的做法，建虚点主席树。

具体来说，把所有a、l、r的值离散化过后，对每个前缀（1≤j≤i）的所有建立权值线段树，线段树上的每个区间代表的是图中的一个虚点，

我们先定义这种虚点为区间虚点（为了方便，前面建立的有容量为的边连向T的虚点为条件虚点），那么树上区间（l，r）对应的区间虚点必须满足所有的 j 对应图上的实点直接或经其它区间虚点间接连INF边连向它。

这句话有点长，但是绝对能看懂。为了满足这个条件，只需要把左儿子和右儿子区间对应的虚点连向它，而满足条件的实点连向叶节点，

因为  和  是等效的，所以每次在树上找到（）对应的若干个区间虚点，代替原本对应必须为黑点的若干个实点连向我们建立的条件虚点，由于最多对应有个区间，最多新建条边，

然后每棵树B我们用主席树动态开点建立，每次最多新建个点，条边，所以图上总点数不超过，总边数不超过（C、D为<10的常数），空间不会炸，Dinic也刚好跑得过。

代码

多加了几个没必要的优化，看得懂就行

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<climits>
#include<map>
#define ll long long
#define MAXN 400005    //边数点数大概是这个数量级
#define mst0(x) memset(x,0,sizeof(x))
#define INF 0x3f3f3f3f
using namespace std;
inline ll read(){
	ll x=0;bool f=1;char s=getchar();
	while((s<'0'||s>'9')&&s>0){if(s=='-')f^=1;s=getchar();}
	while(s>='0'&&s<='9')x=(x<<1)+(x<<3)+s-'0',s=getchar();
	return f?x:-x;
}
int n,IN,N;
int in[5005][6],SUM;
map<int,int>mp;
int root[MAXN],NN,XP,R;

int f[MAXN];
int d[MAXN],cur[MAXN];
struct edge{
	int v,id;edge(){}
	edge(int V,int I){v=V,id=I;}
};
vector<edge>G[MAXN];
queue<int>q;
bool ct[MAXN];
inline bool bfs(int S,int T){
	for(int i=0,lm=min(XP,MAXN-5);i<=lm;i++)d[i]=-1;
	q.push(S),d[S]=0;
	while(!q.empty()){
		int u=q.front();q.pop();
		for(int i=0;i<G[u].size();i++){
			int v=G[u][i].v,a=G[u][i].id;
			if(ct[v]&&f[a]>0&&d[v]<0)d[v]=d[u]+1,q.push(v);
		}
	}
	return d[T]>=0;
}
inline int dfs(int x,int lim,int T){
	if(x==T)return lim;
	int res=lim;
	for(int i=cur[x];i<G[x].size()&&res>0;i++){
		cur[x]=i;    //当前弧优化
		int v=G[x][i].v,a=G[x][i].id;
		if(ct[v]&&f[a]>0&&d[v]==d[x]+1){
			int ad=dfs(v,min(res,f[a]),T);
			f[a]-=ad,f[a^1]+=ad,res-=ad;
		}
	}
	if(lim==res)d[x]=-1;    //吔屎优化
	return lim-res;
}
inline int dinic(int S,int T){
	int res=0;
	while(bfs(S,T)){
		for(int i=0,lm=min(XP,MAXN-5);i<=lm;i++)cur[i]=0;
		while(int ad=dfs(S,INF,T))res+=ad;
	}
	return res;
}
inline void addedge(int u,int v,int w){
	if(w<INF)SUM+=w;
	f[IN]=w,f[IN^1]=0;
	G[u].push_back(edge(v,IN));
	G[v].push_back(edge(u,IN^1));
	IN+=2;
}

struct itn{
	int ls,rs,id;
}t[MAXN];
inline void add(int x,int y,int l,int r,int u){
	if(y>0)addedge(t[y].id,t[x].id,INF);    //把先前点y的信息通过连边转过来
	if(l==r){addedge(u,t[x].id,INF);return;}
	int mid=(l+r)>>1;
	if(in[u][0]<=mid){
		t[x].rs=t[y].rs,t[x].ls=++NN,t[t[x].ls].id=++XP;//另一儿子无需连边，因为先前点y的信息已经转过来了
		add(t[x].ls,t[y].ls,l,mid,u);
		addedge(t[t[x].ls].id,t[x].id,INF);
	}
	else{
		t[x].ls=t[y].ls,t[x].rs=++NN,t[t[x].rs].id=++XP;
		add(t[x].rs,t[y].rs,mid+1,r,u);
		addedge(t[t[x].rs].id,t[x].id,INF);
	}
}
inline void sch(int x,int l,int r,int a,int b,int p){
	if(x==0)return;
	if(l==a&&r==b){addedge(t[x].id,p,INF);return;}
	int mid=(l+r)>>1;
	if(a<=mid)sch(t[x].ls,l,mid,a,min(mid,b),p);
	if(b>mid)sch(t[x].rs,mid+1,r,max(a,mid+1),b,p);
}
inline void DFS(int x){
	if(ct[x])return;ct[x]=1;
	for(int i=0;i<G[x].size();i++)
		if(G[x][i].id&1)DFS(G[x][i].v);
}

int main()
{
	n=read(),N=(n<<1)+1;
	for(int i=1;i<=n;i++){
		for(int j=0;j<6;j++)in[i][j]=read();
		SUM-=in[i][5];
		mp[in[i][0]]=1,mp[in[i][3]]=1,mp[in[i][4]]=1;
	}
	map<int,int>::iterator it;
	for(it=mp.begin();it!=mp.end();it++)it->second=++R;
	for(int i=1;i<=n;i++)
		in[i][0]=mp[in[i][0]],in[i][3]=mp[in[i][3]],in[i][4]=mp[in[i][4]];
	XP=N;
	for(int i=1;i<=n;i++){
		addedge(0,i,in[i][2]+in[i][5]);
		if(i==1)addedge(i,N,in[i][1]+in[i][5]);
		else addedge(i,N,in[i][1]),
		addedge(n+i,N,in[i][5]),addedge(i,n+i,INF);
		sch(root[i-1],1,R,in[i][3],in[i][4],n+i);
		if(i<n){
			root[i]=++NN,t[root[i]].id=++XP;
			add(root[i],root[i-1],1,R,i);
		}
	}
	DFS(N);    //把最终无法通向T的点删去，免跑
	printf("%d\n",SUM-dinic(0,N));
	return 0;
}