hdu Illusive Chase 1364 dfs

Illusive Chase

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 174 Accepted Submission(s): 74

Problem Description

Tom the robocat is presented in a Robotics Exhibition for an enthusiastic audience of youngsters, placed around an m n field. Tom which is turned off initially is placed in some arbitrary point in the field by a volunteer from the audience. At time zero of
the show, Tom is turned on by a remote control. Poor Tom is shown a holographic illusion of Jerry in a short distance such that a direct path between them is either vertical or horizontal. There may be obstacles in the field, but the illusion is always placed
such that in the direct path between Tom and the illusion, there would be no obstacles. Tom tries to reach Jerry, but as soon as he gets there, the illusion changes its place and the chase goes on. Let's call each chase in one direction (up, down, left, and
right), a chase trip. Each trip starts from where the last illusion was deemed and ends where the next illusion is deemed out. After a number of chase trips, the holographic illusion no more shows up, and poor Tom wonders what to do next. At this time, he
is signaled that for sure, if he returns to where he started the chase, a real Jerry is sleeping and he can catch it.

To simplify the problem, we can consider the field as a grid of squares. Some of the squares are occupied with obstacles. At any instant, Tom is in some unoccupied square of the grid and so is Jerry, such that the direct path between them is either horizontal
or vertical. It's assumed that each time Tom is shown an illusion; he can reach it by moving only in one of the four directions, without bumping into an obstacle. Tom moves into an adjacent square of the grid by taking one and only one step.

The problem is that Tom's logging mechanism is a bit fuzzy, thus the number of steps he has taken in each chase trip is logged as an interval of integers, e.g. 2 to 5 steps to the left. Now is your turn to send a program to Tom's memory to help him go back.
But to ease your task in this contest, your program should only count all possible places that he might have started the chase from.



Input

The first line of the input file contains a single integer t (1 <= t <= 10), the number of test cases, followed by the input data for each test case. The first line of each test case contains two integers m and n, which are the number of rows and columns of
the grid respectively (1 <= m, n <= 100). Next, there are m lines, each containing n integers which are either 0 or 1, indicating whether the corresponding cell of the grid is empty (0) or occupied by an obstacle (1). After description of the field, there
is a sequence of lines, each corresponding to a chase trip of Tom (in order). Each line contains two positive integers which together specify the range of steps Tom has taken (inclusive), followed by a single upper-case character indicating the direction of
the chase trip, which is one of the four cases of R (for right), L (for left), U (for up), and D (for down). (Note that these directions are relative to the field and are not directions to which Tom turns). This part of the test case is terminated by a line
containing exactly two zeros.



Output

For each test case, there should be a single line, containing an integer indicating the number of cells that Tom might have started the chase from.



Sample Input

2

6 6

0 0 0 0 0 0

0 0 0 1 1 0

0 1 0 0 0 0

0 0 0 1 0 0

0 0 0 1 0 1

0 0 0 0 0 1

1 2 R

1 2 D

1 1 R

0 0

3 4

0 0 0 0

0 0 0 0

0 0 0 0

1 2 R

3 7 U

0 0



Sample Output

10

0



题意：输入一个地图，0表示可以走，1表示不能走。接下来再出现0 0 之前，输入若干个操作。前两个数字代表走的步数范围，每次走的步数都可以是在这个范围里的任意步。最后一个字母代表 走的方向。 输出有多少个 为0的位置可以作为起始点。起始位置的要求是，有一种的走法，可以使其 走完 给的若干个操作后，在走的过程中 不会遇到障碍1 ，并且不会超出地图范围。

第二个案例，因为第二个操作 最少向上走三步， 所以肯定超出范围了。所以没有点可以做为起始点。

做法：枚举所有点，dfs 所有走的步数范围。 注意 如果步数范围 在3-7 之间，那么 在小于三步的范围内，不能出现障碍，否者不能走。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <malloc.h>
#include <ctype.h>
#include <math.h>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;
#include <stack>
#include <queue>
#include <vector>
#include <deque>
#include <set>
#include <map> 
 
 
int lim;
int mp[150][150];
int n,m;
int lr[100017][2];
char ch[100017];

int ok(int x,int y)
{
	if(x<=n&&x>=1&&y>=1&&y<=m)
	{
		if(mp[x][y]==0)
			return 1;
	}
	return 0;
}
int dfs(int x,int y,int nw)//f R (for right), L (for left), U (for up), and D (for down). (N
{
	if(!ok(x,y))
		return 0;
	if(nw==lim)
		return 1;
	if(ch[nw]=='R')//nw+1
	{ 
		for(int i=1;i<lr[nw][0];i++)
		{
			if(!ok(x,y+i))
				return 0;
		}
		for(int i=lr[nw][0];i<=lr[nw][1];i++)
		{ 
			if(!ok(x,y+i))
				break;
			if(dfs(x,y+i,nw+1))
				return 1; 
		}
	}
	if(ch[nw]=='L')//nw+1
	{
		for(int i=1;i<lr[nw][0];i++)
		{
			if(!ok(x,y-i))
				return 0;
		}
		for(int i=lr[nw][0];i<=lr[nw][1];i++)
		{ 
			if(!ok(x,y-i))
				break;
			if(dfs(x,y-i,nw+1))
				return 1; 
		}
	}
	if(ch[nw]=='U')//nw+1
	{
		for(int i=1;i<lr[nw][0];i++)
		{
			if(!ok(x-i,y))
				return 0;
		}

		for(int i=lr[nw][0];i<=lr[nw][1];i++)
		{ 
			if(!ok(x-i,y))
				break;
			if(dfs(x-i,y,nw+1))
				return 1; 
		}
	}
	if(ch[nw]=='D')//nw+1
	{
		for(int i=1;i<lr[nw][0];i++)
		{
			if(!ok(x+i,y))
				return 0;
		}

		for(int i=lr[nw][0];i<=lr[nw][1];i++)
		{ 
			if(!ok(x+i,y))
				break;
			if(dfs(x+i,y,nw+1))
				return 1; 
		}
	}
	return 0;
}

int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d%d",&n,&m);
		for(int i=1;i<=n;i++)
			for(int j=1;j<=m;j++)
				scanf("%d",&mp[i][j]);
		int l,r;
		lim=0;
		char c;
		while(scanf("%d%d",&l,&r),l||r)
		{
			getchar();
			cin>>c;
			if(l>r)
				swap(l,r);

			lr[lim][0]=l;
			lr[lim][1]=r;
			ch[lim++]=c;
		}
		int ans=0;
		for(int ii=1;ii<=n;ii++)
		{
			for(int j=1;j<=m;j++)
			{  
				if(ok(ii,j)&&dfs(ii,j,0))
					ans++;
			}
		}
		printf("%d\n",ans);  
	}
	return 0;
}