【Codeforces Round 335 (Div 2) B】【模拟】Testing Robots 机器人逐步走 走到矿场就爆炸的最多行走步数

B. Testing Robots

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

The Cybernetics Failures (CF) organisation made a prototype of a bomb technician robot. To find the possible problems it was decided to carry out a series of tests. At the beginning of each test the robot prototype will be placed in cell (x₀, y₀) of a rectangular squared field of size x × y, after that a mine will be installed into one of the squares of the field. It is supposed to conduct exactly x·y tests, each time a mine is installed into a square that has never been used before. The starting cell of the robot always remains the same.

After placing the objects on the field the robot will have to run a sequence of commands given by string s, consisting only of characters 'L', 'R', 'U', 'D'. These commands tell the robot to move one square to the left, to the right, up or down, or stay idle if moving in the given direction is impossible. As soon as the robot fulfills all the sequence of commands, it will blow up due to a bug in the code. But if at some moment of time the robot is at the same square with the mine, it will also blow up, but not due to a bug in the code.

Moving to the left decreases coordinate y, and moving to the right increases it. Similarly, moving up decreases the x coordinate, and moving down increases it.

The tests can go on for very long, so your task is to predict their results. For each k from 0 to length(s) your task is to find in how many tests the robot will run exactly k commands before it blows up.

Input

The first line of the input contains four integers x, y, x₀, y₀ (1 ≤ x, y ≤ 500, 1 ≤ x₀ ≤ x, 1 ≤ y₀ ≤ y) — the sizes of the field and the starting coordinates of the robot. The coordinate axis X is directed downwards and axis Y is directed to the right.

The second line contains a sequence of commands s, which should be fulfilled by the robot. It has length from 1 to 100 000 characters and only consists of characters 'L', 'R', 'U', 'D'.

Output

Print the sequence consisting of (length(s) + 1) numbers. On the k-th position, starting with zero, print the number of tests where the robot will run exactly k commands before it blows up.

Sample test(s)

input

3 4 2 2
UURDRDRL

output

1 1 0 1 1 1 1 0 6

input

2 2 2 2
ULD

output

1 1 1 1

Note

In the first sample, if we exclude the probable impact of the mines, the robot's route will look like that: .

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<string>
#include<ctype.h>
#include<math.h>
#include<set>
#include<map>
#include<vector>
#include<queue>
#include<bitset>
#include<algorithm>
#include<time.h>
using namespace std;
void fre(){freopen("c://test//input.in","r",stdin);freopen("c://test//output.out","w",stdout);}
#define MS(x,y) memset(x,y,sizeof(x))
#define MC(x,y) memcpy(x,y,sizeof(x))
#define MP(x,y) make_pair(x,y)
#define ls o<<1
#define rs o<<1|1
typedef long long LL;
typedef unsigned long long UL;
typedef unsigned int UI;
template <class T1,class T2>inline void gmax(T1 &a,T2 b){if(b>a)a=b;}
template <class T1,class T2>inline void gmin(T1 &a,T2 b){if(b<a)a=b;}
const int N=500+5,M=1e5+10,Z=1e9+7,ms63=1061109567;
int n,m,y,x;
bool e[N][N];
char s[M];
int ans[M];
int main()
{
	while(~scanf("%d%d%d%d",&n,&m,&y,&x))
	{
		MS(e,0);
		scanf("%s",s);
		int l=strlen(s);
		ans[l]=n*m;
		for(int i=0;i<l;++i)
		{
			if(e[y][x]==0)
			{
				e[y][x]=1;
				ans[i]=1;
				--ans[l];
			}
			else ans[i]=0;
			if(s[i]=='L')
			{
				if(x>1)--x;
			}
			else if(s[i]=='R')
			{
				if(x<m)++x;
			}
			else if(s[i]=='U')
			{
				if(y>1)--y;
			}
			else//if(s[i]=='D')
			{
				if(y<n)++y;
			}
		}
		for(int i=0;i<=l;++i)printf("%d ",ans[i]);puts("");
	}
	return 0;
}
/*
【题意】
给你一个n*m（500*500）的棋盘，初始我们的机器人在（y，x），
然后执行一串上下左右的操作（操作序列s的长度不超过1e5），
如果前方不能走，机器人会不动。
如果前方是矿场，机器人会爆炸。
如果所有序列执行完，机器人也会爆炸。

问你，假如说矿场的位置出现在（1，1）~（n，m）的所有位置各一次。
对于这n*m种情况，输出机器人分别在恰好走[0~strlen(s)]步之后就会爆炸的情况数。

【类型】
模拟

【分析】
对于最终路径上的所有点，
如果这个点是第一次走到，那么在这一步就会爆炸。
如果这个点是第多次走到，之前走到过，现在还在走，说明这里不会爆炸。
地图上最终都没有走过（特殊照顾整个序列都走完然后走到的点）的点，计数到ans[strlen(s)]中。
然后输出答案就好啦

【时间复杂度&&优化】
O（strlen(s)）

*/