hdu 3500 Fling (dfs)

Fling

Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 65535/65535 K (Java/Others)
Total Submission(s): 354    Accepted Submission(s): 143

Problem Description

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

 

Author

EvilSeraph

 

Source

2010 ACM-ICPC Multi-University Training Contest（7）——Host by HIT

 

Recommend

zhouzeyong   |   We have carefully selected several similar problems for you:  3504 3506 3507 3501 3502 

 

 

这题和hdu

2821

Pusher

类似。

开始时不知道怎么处理比较好，先打算用个图保存，然后每个’O‘点另用数组保存，再深搜保存的点，这是处于对时间复杂度的优化；后来发现很难实现，于是就用下面这种方法，

比较暴力，直接暴力7*8的图，这题和之前做的2821 Pusher有点类似，而且数据也不难过，就是写的时候出了点小问题，后来1Y了，感觉还行。

 

 

 //625MS    248K    2295 B    G++
 #include<stdio.h>
 #include<string.h>
 char g[][];
 int ans[][];
 char op[]="ULRD";
 int mov[][]={-,,,-,,,,};
 int n,flag;
 int judge(int x,int y)
 {
     if(x>= && x< && y>= && y<) return ;
     return ;
 }
 void dfs(int cnt)
 {
     if(cnt==n-) flag=;
     if(flag) return;
     for(int i=;i<;i++)
         for(int j=;j<;j++)
             if(g[i][j]=='O'){
                 for(int k=;k<;k++){
                     int x=i;
                     int y=j;
                     if(!judge(x+mov[k][],y+mov[k][]) || g[x+mov[k][]][y+mov[k][]]=='O') continue;
                     int tx[],ty[],tt=;
                     while(judge(x,y)){
                         if(g[x][y]=='O'){
                             tx[tt]=x;
                             ty[tt++]=y;
                         }
                         x+=mov[k][];
                         y+=mov[k][];
                     }
                     if(tt==) continue;    

                     for(int ii=;ii<tt;ii++){
                         g[tx[ii-]][ty[ii-]]='X';
                         g[tx[ii]-mov[k][]][ty[ii]-mov[k][]]='O';
                     }
                     g[tx[tt-]][ty[tt-]]='X';
                     ans[cnt][]=i;
                     ans[cnt][]=j;
                     ans[cnt][]=k;

                     dfs(cnt+);
                     if(flag) return;

                     x=i;y=j;
                     while(judge(x,y)){
                         g[x][y]='X';
                         x+=mov[k][];
                         y+=mov[k][];
                     }
                     for(int ii=;ii<tt;ii++)
                         g[tx[ii]][ty[ii]]='O';
                 }
             }
     return;
 }
 int main(void)
 {
     int m,k=;
     while(scanf("%s",g[])!=EOF)
     {
         for(int i=;i<;i++) scanf("%s",g[i]);
         if(k>) printf("\n");
         n=;
         flag=;
         for(int i=;i<;i++)
             for(int j=;j<;j++)
                 if(g[i][j]=='O')
                     n++;
         dfs();
         printf("CASE #%d:\n",k++);
         for(int i=;i<n-;i++){
             printf("%d %d %c\n",ans[i][],ans[i][],op[ans[i][]]);
         }
     }
     return ;
 }