【TC SRM 577】BoardPainting（最小割）

传送门

---

题解：

这题有两种完全不同的最小割解法。

解法1：

首先考虑每个点单独刷一遍。

然后考虑合并相邻两个点，每合并两个点我们就会将刷的次数-1。

发现这种合并是有问题的，因为我们不支持拐弯和横跨。

对于每个合并操作建立虚点，源点向横向合并连容量为1的边，纵向的合并操作向汇点连容量为1的边。横向操作向它影响的两个点连容量为1的边，每个点还需要向影响它的纵向的合并操作连容量为1的点。

发现这时候存在非法操作（即拐弯操作的时候），S-T是连通的，换句话说，要是的操作合法，我们要在新的图里面找一个割集，每个边的权值会导致多的操作的产生，所以我们要找的就是最小割。

发现是一个0/1容量二分图，写一个Dinic会更加高效。

解法二：

注意到最优决策下，所有粉刷操作的终止位置的下一个位置要么是障碍（边界也算障碍），要么是从另一个方向粉刷的点。

源点向所有点连容量为这个点纵向相邻的障碍数，所有点向汇点连容量为这个点横向相邻的障碍数。所有相邻的点连容量为1的双向边。

跑最小割，与S连通的点我们认为是横着被刷，否则我们认为是竖着被刷。

此时最小割大小就是操作端点数量，除以二就是答案。

---

代码1：

#include<bits/stdc++.h>
#define ll long long
#define re register
#define cs const

using std::string;

class BoardPainting{
	private:
		static cs int N=2e4+7,M=55;
		int S,T,tot,n,m,id[M][M];
		
		struct edge{int to,cap,rev;};
		typedef std::vector<edge>::iterator iter;
		std::vector<edge> G[N];iter cur[N];
		inline void adde(int u,int v,int val){
			G[u].push_back((edge){v,val,G[v].size()});
			G[v].push_back((edge){u,0,G[u].size()-1});
		}
		
		int lev[N];
		inline bool BFS(){
			memset(lev+1,0,sizeof(int)*(tot));
			std::queue<int> q;q.push(S);
			lev[S]=1;cur[S]=G[S].begin();
			while(!q.empty()){
				int u=q.front();q.pop();
				for(auto e:G[u])if(e.cap&&!lev[e.to]){
					lev[e.to]=lev[u]+1;cur[e.to]=G[e.to].begin();
					if(e.to==T)return true;
					q.push(e.to);
				}
			}
			return false;
		}
		
		int dfs(int u,int flow){
			if(u==T)return flow;
			int ans=0;
			for(iter &e=cur[u];e!=G[u].end();++e)
			if(e->cap&&lev[e->to]==lev[u]+1){
				int delta=dfs(e->to,std::min(flow-ans,e->cap));
				if(delta){
					e->cap-=delta;
					G[e->to][e->rev].cap+=delta;
					if((ans+=delta)==flow)return flow;
				}
			}
			return ans;
		}
		
		inline int Flow(){
			int flow=0;
			while(BFS())flow+=dfs(S,0x3f3f3f3f);
			return flow;
		}
	public:
		BoardPainting(){}
		int minimalSteps(std::vector<string> s){
			n=s.size(),m=s[0].size();
			S=tot=1,T=++tot;int ans=0;
			for(int re i=0;i<n;++i)
			for(int re j=0;j<m;++j)
			if(s[i][j]=='#'){++ans;id[i][j]=++tot;}
			for(int re i=0;i<n;++i)
			for(int re j=0;j<m;++j)if(id[i][j]){
				if(i&&id[i-1][j]){
					--ans;++tot;
					adde(S,tot,1);
					adde(tot,id[i][j],1);
					adde(tot,id[i-1][j],1);
				}
				if(j&&id[i][j-1]){
					--ans;++tot;
					adde(tot,T,1);
					adde(id[i][j],tot,1);
					adde(id[i][j-1],tot,1);
				}
			}
			return ans+Flow();
		}
};

#ifdef zxyoi

BoardPainting Solver;

signed main(){
	std::cout<<Solver.minimalSteps(
	{
		"###",
		"#.#",
		"###"
	}
	)<<"\n";
	return 0;
} 

#endif 

代码2：

#include<bits/stdc++.h>
#define ll long long
#define re register
#define cs const

using std::string;

struct BoardPainting{
	private:
		static cs int N=5e3+7,M=55;
		int S,T,tot,n,m,id[M][M],d[M][M][2];
		
		struct edge{int to,cap,rev;};
		typedef std::vector<edge>::iterator iter;
		std::vector<edge> G[N];iter cur[N];
		
		inline void adde(int u,int v,int uv,int vu=0){
			G[u].push_back((edge){v,uv,G[v].size()});
			G[v].push_back((edge){u,vu,G[u].size()-1});
		}
		
		int lev[N],gap[N],finish;
		inline void BFS(){
			memset(lev+1,0,sizeof(int)*tot);
			memset(gap+1,0,sizeof(int)*tot);
			std::queue<int> q;q.push(T);gap[1]=lev[T]=1;
			while(!q.empty()){
				int u=q.front();q.pop();cur[u]=G[u].begin();
				for(auto e:G[u])if(!lev[e.to]){
					lev[e.to]=lev[u]+1;
					++gap[lev[e.to]];
					q.push(e.to);
				}
			}
			finish=lev[S]==0;
		}
		
		int dfs(int u,int flow){
			if(u==T)return flow;
			int ans=0;
			for(iter &e=cur[u];e!=G[u].end();++e)
			if(e->cap&&lev[e->to]+1==lev[u]){
				int delta=dfs(e->to,std::min(flow-ans,e->cap));
				if(delta){
					e->cap-=delta;
					G[e->to][e->rev].cap+=delta;
					if((ans+=delta)==flow)return ans;
				}
			}
			if(!--gap[lev[u]++])finish=true;
			++gap[lev[u]],cur[u]=G[u].begin();
			return ans;
		}
		
		inline int Flow(){
			int flow=0;BFS();
			while(!finish)flow+=dfs(S,0x3f3f3f3f);
			return flow;
		}
		
	public:
		BoardPainting(){}
		int minimalSteps(std::vector<string> s){
			n=s.size(),m=s[0].size();
			S=tot=1,T=++tot;
			for(int re i=0;i<n;++i)
			for(int re j=0;j<m;++j)
			if(s[i][j]=='#')id[i][j]=++tot;
			for(int re i=0;i<n;++i)
			for(int re j=0;j<m;++j)if(id[i][j]){
				int d[2]={0,0};
				for(int re k=0;k<4;++k){
					static cs int dx[]={1,0,-1,0};
					static cs int dy[]={0,1,0,-1};
					int x=i+dx[k],y=j+dy[k];
					if(!~x||!~y||x==n||y==m||!id[x][y])++d[k&1];
					else if(k<2)adde(id[i][j],id[x][y],1,1);
				}
				if(d[0])adde(S,id[i][j],d[0]);
				if(d[1])adde(id[i][j],T,d[1]);
			}
			return Flow()>>1;
		}
};

#ifdef zxyoi

BoardPainting Solver;

signed main(){
	std::cout<<Solver.minimalSteps(
	{
		"..#",
		"..#",
		"###"
	}
	)<<"\n";
	return 0;
} 

#endif