2018 CCPC E.Escape

题目大意

给你一个$N\ast M$的方格，中间有障碍物，给你$a$个机器人以及$b$个出口，机器人开始都在$(0,a_i)$的位置，出口在$(N+1,b_i)$，开始机器人的前进方向为竖直向下。

要求你通过在方格中放置若干“NE”，“NW”，“SW”，“SE”四种装置，要求所有的机器人都从出口出来，判断是否可行。

其中四种装置的具体操作如下：

\quad\quad "NW’’ 装置会把从格子上方走来的机器人的运动方向变成向左，以及把从格子左方走来的机器人的运动方向变成向上，不允许机器人从格子的右方及下方进入。

\quad\quad ""NE’’ 装置会把从格子上方走来的机器人的运动方向变成向右，以及把从格子右方走来的机器人的运动方向变成向上，不允许机器人从格子的左方及下方进入。

\quad\quad ""SW’’ 装置会把从格子下方走来的机器人的运动方向变成向左，以及把从格子左方走来的机器人的运动方向变成向下，不允许机器人从格子的右方及上方进入。

\quad\quad ""SE’’ 装置会把从格子下方走来的机器人的运动方向变成向右，以及把从格子右方走来的机器人的运动方向变成向下，不允许机器人从格子的左方及上方进入。
$$1<=T<=10,1<=N,M<=100$$

思路和分析

看到数据范围其实就能够想到是最大流问题，因为数据范围明显不是状压，而且以前也做过类似的将方格中的每个点拆分建图的问题，当时卡死在A题上面，没有早点看这个题，不然应该能做出来。
首先来分析一下问题，观察一下转弯装置的性质，由于只能够从一边进一边出完成一个变向的过程，再根据机器人初始方向一致的条件，不难分析出不存在两个机器人使用同一个装置的可能性。所以我们把每个点拆成左右走的和上下走的点就可以很好的解决问题，最后跑一边最大流，判一下就可。
还有一些显然的性质，为了尽量不产生交错，所以4个方向中可以去掉两个，维护单调性。

#include <bits/stdc++.h>
#define rep( i , l , r ) for( int i = (l) ; i <= (r) ; ++i )
#define per( i , r , l ) for( int i = (r) ; i >= (l) ; --i )
#define erep( i , u ) for( int i = head[(u)] ; ~i ; i = e[i].nxt )
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 40010;
const int maxm = 1000010;
int dep[maxn] , head[maxn] , _t;
struct edge{
	int u , v , nxt;
	int c;
} e[maxm];
inline void addedge( int u , int v , int c , int op ){
	e[_t].u = u , e[_t].v = v , e[_t].nxt = head[u] , e[_t].c = c , head[u] = _t++;
	e[_t].u = v , e[_t].v = u , e[_t].nxt = head[v] , e[_t].c = op ? 0 : c , head[v] = _t++; 
}
int N , M , S , T;
int cur[maxn];
bool bfs(){ // 给图分层 
	memset( dep , 0x3f , sizeof dep );
	memcpy( cur , head , sizeof head );
	dep[S] = 0;
	queue<int> q;
	q.push( S );
	
	while( !q.empty() ){
		int u = q.front(); q.pop();
		erep( i , u ){
			int v = e[i].v;
			if( dep[v] > dep[u] + 1 && e[i].c  > 0 ){
				dep[v] = dep[u] + 1;
				q.push( v );
				if( v == T ) return 1;
			}
		}
	}
	return 0;
}
inline int _min( int a , int b ){
	return a > b ? b : a;
}
// recursive version

//bool vis = 0;
//int max_flow = 0;
//int dfs( int u , int flow ){
//	int cur_low = 0; 
//	if( u == T ){
//		vis = 1;
//		max_flow += flow; // 直接累加 
//		return flow; 
//	}
//	int used = 0; // 当前已经使用的流量 
//	for( int i = cur[u] ; ~i ; cur[u] = i = e[i].nxt ){
//		int v = e[i].v;
//		if( e[i].c > 0 && dep[v] == dep[u] + 1 ){
//			if( cur_low = dfs( v , _min( flow - used , e[i].c ) ) ){
//				used += cur_low;
//				e[i].c -= cur_low;
//				e[i^1].c += cur_low;
//				if( used == flow ) break; // 流量使用完说明这个点无法增广了 
//			}
//		}
// 	}
// 	return used; // 返回已经使用的流量 
//}
//int Dinic(){
//	while( bfs() ){
//		for( vis = 1 ; vis ; ){
//			vis = 0;
//			dfs( S , INF );
//		}
//	}
//	return max_flow;
//} 


// non-recursive version
int Dinic(){
	int res = 0;
	int top = 0;
	int stack[maxn];
	while( bfs() ){
		int u = S;
		top = 0;
		for(;;){
			if( u == T ){
				int mi = INF , loc;
				for( int i = 0 ; i < top ; ++i )
					if( mi > e[stack[i]].c ){
						loc = i;
						mi = e[stack[i]].c;
					}
				for( int i = 0 ; i < top ; ++i ){
					e[stack[i]].c -= mi;
					e[stack[i]^1].c += mi;
				}
				res += mi;
				top = loc;
				u = e[stack[top]].u;
			}
			for( int i = cur[u] ; ~i ; cur[u] = i = e[i].nxt )
				if( e[i].c > 0 && dep[e[i].v] == dep[u] + 1 ){
					break;
				}
			if( cur[u] != -1 ){
				stack[top++] = cur[u];
				u = e[cur[u]].v;
			}else{
				if( top == 0 ) break;
				dep[u] = INF;
				u = e[stack[--top]].u;
			}
		} 
	}
	return res;
}
const int MAXN = 111;
int g[MAXN][MAXN];
int m;
inline int id( int x , int y ){
	return x * m + y;
}
char s[MAXN];
int main(){
	int cas = 0;
	scanf("%d" , &cas);
	while( cas-- ){
		memset( head , 0xff , sizeof head );
		_t = 0;
		int n , a , b;
		scanf("%d%d%d%d" , &n , &m , &a , &b);
		char ch;
		rep( i , 1 , n ){
			scanf("%s" , s);
			rep( j , 1 , m ){
				g[i][j] = s[j - 1] - '0';	
			}
		}
		int x , base = (n + 2) * m;
		S = base * 2 + 5 ;
		T = S + 1;
		rep( i , 1 , a ){
			scanf("%d" , &x);
			if( g[1][x] != 1 )
				addedge( S , id(1,x) , 1 , 1 );
		}
		rep( i , 1 , b ){
			scanf("%d" , &x);
			if( g[n][x] != 1 )
				addedge( id(n,x) , T , 1 , 1 );
		}
		
		rep( i , 1 , n )
			rep( j , 1 , m ){
				if( g[i][j] == 1 ) continue;
				if( i > 1 && g[i - 1][j] == 0 ) addedge( id(i,j) , id(i-1,j) , 1 , 0 );
				//if( i < n && g[i + 1][j] == 0 ) addedge( id(i,j) , id(i+1,j) , 1 );
				if( j > 1 && g[i][j - 1] == 0 ) addedge( id(i,j) + base , id(i,j-1) + base , 1 , 0 );
				//if( j < m && g[i][j + 1] == 0 ) addedge( id(i,j) + base , id(i,j+1) + base , 1 ); 
				addedge( id(i,j) , id(i,j) + base , 1 , 0 );
				addedge( id(i,j) + base , id(i,j) , 1 , 0 );
			} 
		puts( Dinic() == a ? "Yes" : "No" );
	}
	return 0;
}