回溯扫盲

    何为回溯？？下面是百度释意。
    回溯算法也叫试探法，它是一种系统地搜索问题的解的方法。回溯算法的基本思想是：从一条路往前走，能进则进，不能进则退回来，换一条路再试。用回溯算法解决问题的一般步骤为：
    1、定义一个解空间，它包含问题的解。
所谓解空间，就是一个求解范围，比如：要从一个房间找到某样东西，已经事先知道是哪个房间，没有必要把所有的房间都进行一次判断。
    2、利用适于搜索的方法组织解空间。
意思通俗易懂，就是要往最适合用搜素的方向思考，寻找求解方法。
    3、利用深度优先法搜索解空间。
    4、利用限界函数避免移动到不可能产生解的子空间。
指定搜索的空间，不可以从一个无限大的范围内查找。

    回溯算法，说的再通俗一点，可以叫做回退算法，对于一条走不下去的路，没有必要再继续往下走，回到当前点的上一个点，再从上一个点进行判断，如果说上一个点还有其他路径，则继续查找；否则，继续回溯。

    回溯结束的条件：1.找到所求问题的解(此时可能会有两种情况，其一：找到一组解就可以；其二：可能还有其他解或者说目前所求的不是问题的最优解，此时并不能终止查询，还要继续)。2.所有可能的路线都已经判断完毕。

    回溯算法的时间优化：对于回溯算法来说，如何优化时间，是最令人头疼的问题，因为算法本身的设计可能包含很多无意义的搜索路径，如果从这条路径上继续搜的话，会有很大的时间开销，当然，此时也会大量的消耗内存。回溯算法的优化，即为剪枝，对于剪枝，通俗的说就是把所有的没有必要的搜索路径都给剔除。当然，这个需要自己慢慢积累才可以。

    由于回溯主要是针对于图来说，毕竟见到的此类问题最多的也就是图。下面从图的角度来说。

解决回溯算法的数据准备：方向选择数组(八个方向还是四个方向)。存储图的数组。还有一个就是标记数组(用于对路径进行判断)。查找结束的标志(基本上都是flag)。(当然，这只是针对于大多数问题来说，还要对具体问题具体分析)

以例为证

福克斯在玩一款手机解迷游戏，这个游戏叫做”两点”。基础级别的时候是在一个n×m单元上玩的。像这样：

 

每一个单元有包含一个有色点。我们将用不同的大写字母来表示不同的颜色。

这个游戏的关键是要找出一个包含同一颜色的环。看上图中4个蓝点，形成了一个环。一般的，我们将一个序列 d₁,d₂,...,d_k 看成一个环，当且仅当它符合下列条件时：

1.    这k个点不一样，即当 i≠j时， d_i 和 d_j不同。

2.    k至少是4。

3.    所有的点是同一种颜色。

4.    对于所有的 1≤i≤k-1: d_i 和 d_i+1 是相邻的。还有 d_k 和 d₁ 也应该相邻。单元 x 和单元 y 是相邻的当且仅当他们有公共边。

当给出一幅格点时，请确定里面是否有环。

Input

单组测试数据。
第一行包含两个整数n和m (2≤n,m≤50):板子的行和列。
接下来n行，每行包含一个有m个字母的串，表示当前行每一个点的颜色。每一个字母都是大写字母。

Output

如果有环输出Yes，否则输出No。

Input示例

3 4
AAAA
ABCA
AAAA
3 4
AAAA
ABCA
AADA

Output示例

Yes
No

#include <bits/stdc++.h>

using namespace std;

char a[111][111];
bool vis[111][111],flag;
int n,m;
int dir[4][2] = {{0,1},{1,0},{0,-1},{-1,0}};

bool judge(int x,int y,int xx,int yy, char c)
{
    for(int i = 0; i < 4; i ++)
    {
        int tx = x + dir[i][0];
        int ty = y + dir[i][1];
        if(tx >= 0 && tx < n && ty >= 0 && ty < m && tx == xx && ty == yy && a[tx][ty] == c)
            return true;
    }
    return false;
}

void dfs(int x,int y,int xx,int yy, char c,int num)
{
    if(judge(x,y,xx,yy,c) && num >= 3)
    {
        flag = 1;
        return;
    }
    for(int i = 0; i < 4; i ++)
    {
        int tx = x + dir[i][0];
        int ty = y + dir[i][1];
        if(tx >= 0 && tx < n && ty >= 0 && ty < m && a[tx][ty] == c && !vis[tx][ty])
        {
            vis[tx][ty] = 1;
            ++ num;
            dfs(tx,ty,xx,yy,c,num);
            if(flag)
            {
                return;
            }

            -- num;
            vis[tx][ty] = 0;
        }
    }
}

int main()
{

    while(~scanf("%d%d",&n,&m))
    {
        memset(vis,0,sizeof(vis));
        memset(a,0,sizeof(a));
        flag = 0;
        for(int i = 0; i < n; i ++)
            scanf("%s",a[i]);

        for(int i = 0; i < n && !flag; i ++)
        {
            for(int j = 0; j < m && !flag; j ++)
            {
                memset(vis,0,sizeof(vis));
                vis[i][j] = 1;
                dfs(i,j,i,j,a[i][j],0);
            }
        }
        if(!flag)
            printf("No\n");
        else
            printf("Yes\n");
    }

    return 0;
}

示例2
问题描述：在一个n*n的网格里，每个网格可能为“墙壁”（用‘X’表示）和“街道”（用‘.’表示）。现在在街道放置碉堡，每个碉堡可以向上下左右四个方向开火，子弹射程无限远。墙壁可以阻挡子弹。问最多能放置多少个碉堡，使它们彼此不会互相摧毁。


如下面四张图，墙壁用黑正方形表示，街道用空白正方形表示，圆球就代表碉堡。1,2,3是正确的，4,5是错误的。题目要求同一行或者同一列中两个碉堡不能够相互打到对方





Sample input: 
4
.X.. 
.... 
XX.. 
.... 

2 
XX 

.X 

3 
.X. 
X.X 

.X. 

4 
.... 
.... 
.... 
.... 
Sample output: 
5 
1 
5 
4 

#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <string.h>


using namespace std;


int n,MAX;
bool vis[5][5];
char Map[5][5];


bool judge(int x,int y) ///以点(x,y)为起点，遍历四个方向，每个方向都遍历完
{
    if(Map[x][y] == 'X')
        return false;
    for(int i = x + 1; i < n; i ++)
    {
        if(Map[i][y] == 'X')
            break;
        if(vis[i][y])
            return false;
    }
    for(int i = x - 1; i >= 0; i --)
    {
        if(Map[i][y] == 'X')
            break;
        if(vis[i][y])
            return false;
    }
    for(int i = y + 1; i < n; i ++)
    {
        if(Map[x][i] == 'X')
            break;
        if(vis[x][i])
            return false;
    }
    for(int i = y - 1; i >= 0; i --)
    {
        if(Map[x][i] == 'X')
            break;
        if(vis[x][i])
            return false;
    }
    return true;
}


void DFS(int pos)
{
    int r = pos / n;
    int c = pos % n;
    if(pos >= n * n)
    {
        int sum = 0;    ///统计放的个数
        for(int i = 0; i < n; i ++)
            for(int j = 0; j < n; j ++)
                if(vis[i][j])
                    ++ sum;
        MAX = max(MAX,sum);
        return;
    }
    if(judge(r,c))  ///判断该行是不是可以放置
    {
        ///可以放置的话也有两种选择，放或者不放


        ///放
        vis[r][c] = 1;
        DFS(pos + 1);
        vis[r][c] = 0;  ///回溯


        ///不放
        DFS(pos + 1);
    }
    else    ///不可以放置
        DFS(pos + 1);
    return;
}


int main()
{
    while(scanf("%d",&n) && n)
    {
        for(int i = 0; i < n; i ++)
            scanf("%s",Map[i]);


        memset(vis,0,sizeof(vis));
        MAX = -0x3f3f3f;
        DFS(0);
        printf("%d\n",MAX);
    }
    return 0;
}