POJ 1979 Red and Black (回溯)

Descirbe:

There is a rectangular room, covered with square tiles. Each tile is colored either red or black. A man is standing on a black tile. From a tile, he can move to one of four adjacent tiles. But he can't move on red tiles, he can move only on black tiles.

Write a program to count the number of black tiles which he can reach by repeating the moves described above.

Input:

The input consists of multiple data sets. A data set starts with a line containing two positive integers W and H; W and H are the numbers of tiles in the x- and y- directions, respectively. W and H are not more than 20.

There are H more lines in the data set, each of which includes W characters. Each character represents the color of a tile as follows.

'.' - a black tile
'#' - a red tile
'@' - a man on a black tile(appears exactly once in a data set)
The end of the input is indicated by a line consisting of two zeros.

Output:

For each data set, your program should output a line which contains the number of tiles he can reach from the initial tile (including itself).

Sample Input:

6 9
....#.
.....#
......
......
......
......
......
#@...#
.#..#.
11 9
.#.........
.#.#######.
.#.#.....#.
.#.#.###.#.
.#.#..@#.#.
.#.#####.#.
.#.......#.
.#########.
...........
11 6
..#..#..#..
..#..#..#..
..#..#..###
..#..#..#@.
..#..#..#..
..#..#..#..
7 7
..#.#..
..#.#..
###.###
...@...
###.###
..#.#..
..#.#..
0 0

Sample Output:

45
59
6
13

题目传送门：POJ 1979

题目大意：

（翻译有限，凑合着看）

有一个棋盘，上面有黑的，又红的，现在你站在一个黑块上，只能往前后左右四个位置走，并且不能踩红块，黑块只能走一次，问总共能走多少黑块

解题思路：

比较典型的回溯法，用二维字符数组存入棋盘，递归搜索，如果符合条件，就继续递归，否则回溯，每一次踩到黑块就ans+1.

AC代码：

 

#include <stdio.h>
#include <iostream>
#include <cstring>
using namespace std;
char s[25][25]; // 二维数组存棋盘
int f[25][25];  // 标志数组，存是否走过这里的信息
int w,h,x,y;   // 列，行，起始位置x，y
int ans;    // 走过的黑块数
void Search(int m, int n)
{
    f[m][n] = 1; // 标志这个地方已经走过
    ans++;   // 块数加一，初始地方也是黑的，也要加一
    // 只要没有出界，并且是黑块，也没有走过，就可以走，继续搜索
    if(m+1 <= h && s[m+1][n] == '.' && f[m+1][n] == 0) Search(m+1,n);
    if(m-1 >= 1 && s[m-1][n] == '.' && f[m-1][n] == 0) Search(m-1,n);
    if(n+1 <= w && s[m][n+1] == '.' && f[m][n+1] == 0) Search(m,n+1);
    if(n-1 >= 1 && s[m][n-1] == '.' && f[m][n-1] == 0) Search(m,n-1);
}
int main()
{
    s[0][0] = 0; // 下标从1开始，0下标特殊处理一下
    while(~scanf("%d%d",&w,&h) && w+h)
    {
        memset(f,0,sizeof(f)); // 初始全部为未走过
        ans = 0;   // 注意，每个样例要先初始化答案
        for(int i = 1; i <= h; i++)
        {
            for(int j = 1; j <= w; j++)
            {
                //读入答案，因为总是读入换行之类的其他字符，所以用此方法
                // 感觉这样麻烦了，应该有更好办法
                scanf("%c",&s[i][j]);
                if(s[i][j] == '@' || s[i][j] == '.' || s[i][j] == '#') continue;
                else scanf("%c",&s[i][j]);
                // 如果在这里就找到初始位置'@'，并记录下来的话，会出错，
                // 暂时不知道为什么，就重新扫面一边
            }
        }
        // 扫描，找到起始位置，坑爹就坑爹到这了，解决了好长时间
        for(int i = 1; i <= h; i++)
        {
            for(int j = 1; j <= w; j++)
            {
                if(s[i][j] == '@')
                {
                    x = i;
                    y = j;
                }
            }


        }
        //进入函数
        Search(x,y);
        printf("%d\n",ans); // 打印答案
    }
    return 0;
}

 

小结：

回溯算是搜索的一种方式吧，有个初始条件，或者初始状态，开始在一定范围，一定条件下搜索，如果满足条件了，就记录下来，否则，如果出界了，或者违规了，就回溯，继续搜索。