CodeForces - 589J —（DFS）

Masha has recently bought a cleaner robot, it can clean a floor without anybody's assistance.

Schematically Masha's room is a rectangle, consisting of w × h square cells of size 1 × 1. Each cell of the room is either empty (represented by character '.'), or occupied by furniture (represented by character '*').

A cleaner robot fully occupies one free cell. Also the robot has a current direction (one of four options), we will say that it looks in this direction.

The algorithm for the robot to move and clean the floor in the room is as follows:

1. clean the current cell which a cleaner robot is in;
2. if the side-adjacent cell in the direction where the robot is looking exists and is empty, move to it and go to step 1;
3. otherwise turn 90 degrees clockwise (to the right relative to its current direction) and move to step 2.

The cleaner robot will follow this algorithm until Masha switches it off.

You know the position of furniture in Masha's room, the initial position and the direction of the cleaner robot. Can you calculate the total area of the room that the robot will clean if it works infinitely?

Input

The first line of the input contains two integers, w and h (1 ≤ w, h ≤ 10) — the sizes of Masha's room.

Next w lines contain h characters each — the description of the room. If a cell of a room is empty, then the corresponding character equals '.'. If a cell of a room is occupied by furniture, then the corresponding character equals '*'. If a cell has the robot, then it is empty, and the corresponding character in the input equals 'U', 'R', 'D' or 'L', where the letter represents the direction of the cleaner robot. Letter 'U' shows that the robot is looking up according to the scheme of the room, letter 'R' means it is looking to the right, letter 'D' means it is looking down and letter 'L' means it is looking to the left.

It is guaranteed that in the given w lines letter 'U', 'R', 'D' or 'L' occurs exactly once. The cell where the robot initially stands is empty (doesn't have any furniture).

Output

In the first line of the output print a single integer — the total area of the room that the robot will clean if it works infinitely.

Examples

Input

2 3
U..
.*.

Output

4

Input

4 4
R...
.**.
.**.
....

Output

12

Input

3 4
***D
..*.
*...

Output

6

Note

In the first sample the robot first tries to move upwards, it can't do it, so it turns right. Then it makes two steps to the right, meets a wall and turns downwards. It moves down, unfortunately tries moving left and locks itself moving from cell (1, 3) to cell (2, 3) and back. The cells visited by the robot are marked gray on the picture.

题意：给出了一个n*m的字符矩阵，矩阵由‘ * ’和‘ . ’组成，‘ . ’表示空白位置，‘ * ’表示被占用的位置，在矩阵中有一个机器人，用字母‘U’，‘R’，‘D’，或’L‘表示，字母代表了机器人的初始方向，它将往那个方向移动一格，若那个方向走不通（那格是’*‘或边界外），机器人将顺时针旋转90度改变方向。问机器人最终总共走了多少个不重复的格子。

思路：用DFS模拟就好了，而DFS的结束条件就是到达某个格子的次数不超过某一个数，我在代码中设置了10次，其实5次就够了（4次wa了）。

代码：

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<string>
 #include<cmath>
 #include<algorithm>
 #include<stack>
 #include<queue>
 #define eps 1e-7
 #define ll long long
 #define inf 0x3f3f3f3f
 #define pi 3.141592653589793238462643383279
 using namespace std;
 char map[][];
 int n,m,visit[][],ans,flag;
 void change(char &dire) //改变方向
 {
     if(dire == 'U')
         dire = 'R';
     else if(dire == 'R')
         dire = 'D';
     else if(dire == 'D')
         dire = 'L';
     else if(dire == 'L')
         dire = 'U';
 }

 void go(char dire,int x,int y,int &xx,int &yy) //前进一格
 {
     if(dire == 'U')
     {
         xx = x - ;
         yy = y;
     }
     else if(dire == 'L')
     {
         xx = x;
         yy = y - ;
     }
     else if(dire == 'D')
     {
         xx = x+;
         yy = y;
     }
     else
     {
         xx = x;
         yy = y + ;
     }
 }

 void DFS(int x,int y,char dire)
 {
     if(flag) return;
     int xx,yy;
     go(dire,x,y,xx,yy); //前进一格
     while(map[xx][yy] == '*' || xx>=n || xx< || yy>=m || yy<) //如果那一个不和要求
     {
         change(dire); //就改变方向，修改的是未前进前的格子处的方向
         visit[x][y]++; //标记+1
         go(dire,x,y,xx,yy); //再次前进
         if(visit[x][y] >= ) //若到达指定次数，就结束递归
         {
             flag = ;
             return;
         }
     }
     if(map[xx][yy] != '*' && xx<n && x>= && yy<m && yy>=) //到达的格子满足要求
     {
         if(!visit[xx][yy]) ans++; //未走过走过格子，ans++
         visit[xx][yy]++;
         if(visit[xx][yy] >= ) //到达指定次数
         {
             flag = ;
             return;
         }
         DFS(xx,yy,dire); //递归
     }
 }

 int main()
 {
     while(cin>>n>>m)
     {
         char dire;
         int x,y;
         ans = ;
         flag = ;
         memset(visit,,sizeof(visit));
         for(int i=; i<n; ++i)
             for(int j=; j<m; ++j)
             {
                 cin>>map[i][j];
                 if(map[i][j] >='A' && map[i][j] <= 'Z')
                 {
                     dire = map[i][j];
                     visit[i][j] = ;
                     x = i;
                     y = j;
                 }
             }
         DFS(x,y,dire);
         cout<<ans<<endl;
     }
     return ;
 }