Fling——K

K. Fling

Fling is a kind of puzzle games available on phone.
This game is played on a board with 7 rows and 8 columns. Each puzzle consists of a set of furballs placed on the board. To solved a puzzle, you need to remove the furballs from board until there is no more than one furball on the board. You do this by ´flinging´ furballs into other furballs, to knock them off the board. You can fling any furballs in four directions (up, left, right, down). The flung furball stops at the front grid of another one as soon as knocking it. And the knocked furball continues to rolling in the same direction until the last knocked one goes off the board. For instance, A furball at (0, 0) rolls right to the furball at (0, 5), then it will stop at (0, 4). Moreover, the latter will roll to right. You cannot fling a furball into a neighbouring furball, the one next to in any of four directions. However, it is permitted for a rolling ball knocks into a ball with a neighbour in that direction.

 

Input

The input contains multiple test cases.
For each case, the 7 lines with 8 characters describe the board. ´X´ represents a empty grid and ´O´ represents a grid with a furball in it. There are no more than 12 furballs in any board.
Each case separated by a blank line.

 

Output

For each case, print a line formatted as "CASE #NUM:", where NUM is the number of current case.
Then every ´fling´ prints a line. Each line contains two integers X, Y and a character Z. The flung furball is located at grid (X, Y), the top-left grid is (0, 0). And Z represents the direction this furball towards: U (Up), L (Left), R (Right) and D (Down);
Print a blank line between two cases.
You can assume that every puzzle could be solved.
If there are multiple solve sequences, print the smallest one. That is, Two sequences A (A1, A2, A3 ... An) and B (B1, B2, B3 ... Bn). Let k be the smallest number that Ak != Bk.
Define A < B :
(1) X in Ak < X in Bk;
(2) Y in Ak < Y in Bk and X in Ak = X in Bk;
(3) Z in Ak < Z in Bk and (X,Y) in Ak = (X,Y) in Bk;
The order of Z: U < L < R < D.

 

Sample Input

XXXXXXXX
XXOXXXXX
XXXXXXXX
XXXXXXXX
XOXXXXOX
XXXXXXXX
XXXXXXXX

XXXXXXXX
XOXOXOOX
XXXXXXXX
XXXXXXXX
XXXXXXXX
XXXXXXXX
XXXXXXXX

Sample Output

CASE #1:
4 6 L
1 2 D

CASE #2:
1 1 R
1 4 L
1 3 R
题意：

在一个7*8的板子上，有若干个球（小于12个，经测试最多11个）。你每次可以选择一个球向上下左右推动，

能推动的条件是推动的方向上有球但是不能粘在一起，中间必需得隔一个及以上的格子。然后你推动这个球后它

会一直在这个方向上滚动，直到碰到下一个球或者掉下板子去。如果碰到下一个球他的动能会传递下去，如果碰

到的球紧挨着另一个球就隔山打牛，而原来的球就停在碰到的球的前一个位置上。然后结束标志是板子上只剩一

个球。输出每次操作的球的坐标和推动的方向（ULRD）。

#include <iostream>
#include <string>
#include <iomanip>
#include <cstring>
#include <algorithm>
#include <stdio.h>
using namespace std;
char ch[][];
int cur[][] = {{-,},{,-},{,},{,}}; //U、L、R、D
char ch1[] = "ULRD";
int n=,m=,cnt;
int path[];int pathc[];
int cmp(int bx,int by)
{
      if(bx<||by<||bx>=n||by>=m)
       return ;
   return ;

}

int dfs(int ax)
{
    if(ax==cnt-)
        return ;

int tx[],ty[],i,j,k,dx,dy;
for( i=;i<n;i++)
{
    for(j=;j<m;j++)
    if(ch[i][j]=='O')
    {

        for(k=;k<;k++)
        {
            int mo=;int cd=;
            dx=i+cur[k][];
            dy=j+cur[k][];
            if(ch[dx][dy]=='O')
                 continue;
            while(cmp(dx,dy))
            {
                if(ch[dx][dy]=='O')
                {
                    mo=;
                    tx[cd]=dx;
                    ty[cd++]=dy;
                }
                dx+=cur[k][];
                dy+=cur[k][];
            }
            if(mo)
            {
                ch[i][j]='X';
                for(int ii=;ii<cd;ii++)
                {
                    ch[tx[ii]][ty[ii]]='X';
                    ch[tx[ii]-cur[k][]][ty[ii]-cur[k][]]='O';
                }

                path[ax]=i*m+j;
                pathc[ax]=k;
                if(dfs(ax+)) return ;
                ch[i][j]='O';
                dx=i+cur[k][];
                dy=j+cur[k][];
                while(cmp(dx,dy))
                {
                    if(ch[dx][dy]=='O')
                        ch[dx][dy]='X';
                    dx+=cur[k][];
                    dy+=cur[k][];
                }
                for(int ii=;ii<cd;ii++)
                           ch[tx[ii]][ty[ii]]='O';
            }
        }
    }
}
return ;
}
int main()
{
    int i,j,p=;
    while(~scanf("%s",&ch[]))
    {
        for(i=;i<n;i++)
         cin>>ch[i];
    cnt=;
    for(i=;i<n;i++)
        for(j=;j<m;j++)
            if(ch[i][j]=='O')
            cnt++;
    dfs();
    if(p) cout<<endl;
    cout<<"CASE #"<<++p<<":"<<endl;
    for(i=;i<cnt-;i++)
    cout<<path[i]/m<<" "<<path[i]%m<<" "<<ch1[pathc[i]]<<endl;
}
return ;
}