图搜索基础

递归框架
int robbot(int x,int y) //机器人的输入
if(边界条件) //什么时候不用造了（自己就能造完）
return 0;
int a=robbot(x1,y1); //造一个小的自己帮忙干活
int b=robbot(x2,y2); //再造一个小的自己帮忙干活
return a+b; //自己要做的就是把别人的成果组转起来

比如有一道求子集的算法题，输入一组数组的数据，输出他们的子集。

 #include<iostream>
 using namespace std;
 int nums[]={1,2,3};
 bool visit[10000];

 void print(){
    for(int i=0;i<sizeof(nums)/sizeof(int);++i){
        if(visit[i])
        cout<<nums[i]<<" ";
     }
     cout<<endl;
 }

 void robbot(int idx,int nums[]){
    if(idx>sizeof(nums)/sizeof(int)){
        print();
        return ;
     }
     visit[idx]=true;;
     robbot(idx+1,nums);

     visit[idx]=false;
     robbot(idx+1,nums);
 }

 int main(){
    robbot(0,nums);
    return 0;
 }

输出：
1 2 3
1 2
1 3
1
2 3
2
3

最后一行为空。

深度优先搜索：伪代码
void DFS(int v)
         for(v的每一个邻接点)
             if(!visted[w])     //如果没被访问过
             visited[v]=true;
                 DFS(w)

Q-queen

#include<iostream>
using namespace std;
#define num 4
int path[100];
bool lie[100],zheng[100],fan[100]; 
void print(int n){
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            if(j==path[i]){
                cout<<"Q";
            }else{
                cout<<".";
            }
        }cout<<endl;
    }
    cout<<endl<<endl;
}

void DFS(int idx,int n){
    if(idx>=n){
    print(n);
    return ;
    }
    for(int i=0;i<n;++i){
        if(!lie[i]&&!zheng[idx+i]&&!fan[idx-i+n-1]){
            path[idx]=i;
            lie[i]=true;
            zheng[idx+i]=true;
            fan[idx-i+n-1]=true;
            DFS(idx+1,n);
            lie[i]=false;
            zheng[idx+i]=false;
            fan[idx-i+n-1]=false;
        }
    }
}

int main(){
    DFS(0,num);
    return 0;
}

骑士游历问题
在国际象棋中，马走日，问骑士从棋盘的左下角出发，能够不重复的遍历完整个棋盘。下面的代码框架和上面的N皇后问题完全一样。

int fx = {1,1,-1,-1,2,2,-2,-2};
int fy = {2,-2,2,-2,1,-1,1,-1}; // fx,fy 数组记录骑士的规则
void DFS(int xi,int yi,int n){
    if(idx>=n){
    print(n);
    return ;
    }
    for(int i=0;i<8;++i){
        int newx=xi+fx[i];
        int newy=yi+fy[i];
        if(!visit[newx][newy]){
            visit[newx][newy]=true;
            DFS(idx+1,n);
            visit[newx][newy]=false;
        }
    }
}

---

2018.1.30

我今天再次次写DFS的时候，我有点疑惑，不是说DFS后要还原现场嘛？把状态恢复为进入DFS之前的状态，但是我发现有的代码竟然没有还原，而我上面写的八皇后问题是有还原的，难道别人代码忘了写还原？带着这样一种疑惑，我进行了思考。
就比如我在Leetcode上面这道Number of Islands的题目中，我采用了DFS的写法，当搜到1后就把他改为0，以表这个位置已经搜过，可能有人会说DFS之后不是要把0再改会1吗？`class Solution {

//这是采用DFS的写法。

public:
int fx[4]={1,-1,0,0};
int fy[4]={0,0,1,-1};
int n,m;

void DFS(int i,int j,vector<vector<char>>& grid){
    grid[i][j]='0';
    for(int k=0;k<4;k++){
        int newx=i+fx[k];
        int newy=j+fy[k];
        if(newx>=0&&newx<n&&newy>=0&&newy<m&&grid[newx][newy]=='1'){
            DFS(newx,newy,grid);
        }
    }
}


int numIslands(vector<vector<char>>& grid) {
     n=grid.size();
    if(n==0)return 0;
     m=grid[0].size();

    int res=0;

    for(int i=0;i<n;++i){
        for(int j=0;j<m;++j){
            if(grid[i][j]=='1'){
                DFS(i,j,grid);
                ++res;
            }
        }
    }
    return res;
}

};`

其实事实是我们要明白为什么有些地方在DFS过后要将状态还原，就比如N-皇后问题，一行一行的放皇后，当某一行找不到可以放皇后时，这时候说明上一行的方法不对，需要“抹除”上一行的痕迹，重新放，这个“抹除”就对应代码中的还原操作，lie[i]=false;而上面leetcode的Number Of Islands的问题，却没有进行还原操作，原因就是N-皇后问题和Number Of Islands问题有着本质的区别，前者趋向于在状态树中搜索某一个状态，而后者类似于对图的游历。N-皇后问题是回溯时需要去除痕迹，岛问题是故意留下痕迹，以表示对陆地有探测到。

---

2018/3/29
更新
今天看到了去年第八届蓝桥杯题目中的一道方格分割的题目，贴出来，加深对DFS的理解。
标题：方格分割

6x6的方格，沿着格子的边线剪开成两部分。
要求这两部分的形状完全相同。

如图：p1.png, p2.png, p3.png 就是可行的分割法。

试计算：
包括这3种分法在内，一共有多少种不同的分割方法。
注意：旋转对称的属于同一种分割法。

请提交该整数，不要填写任何多余的内容或说明文字。

#include <algorithm>
#include <string.h>
#include <iostream>
#include <stdio.h>
#include <string>
#include <vector>
#include <queue>
#include <map>
#include <set>
using namespace std;
const int N = 6;
int ans = 0;
int mpt[N+1][N+1];
int dir[4][2] = {0,1,1,0,0,-1,-1,0};
void dfs(int x,int y)
{
    if(x == 0 || y == 0 || x == N || y == N){
        ans ++;
        return;
    }
    for(int i = 0 ; i < 4 ; i ++)
    {
        int tx = x + dir[i][0];
        int ty = y + dir[i][1];
        if(mpt[tx][ty])continue;
        mpt[tx][ty] = 1;
        mpt[N-tx][N-ty] = 1;
        dfs(tx,ty);
        mpt[tx][ty] = 0;
        mpt[N-tx][N-ty] = 0;
    }
}
int main()
{
    mpt[N/2][N/2] = 1;
    dfs(N/2,N/2);
    printf("%d\n",ans/4);
    return 0;
}

PS:可以看到这道题目中深搜之后是有进行回溯的，因为他每搜索完一条道路，都要从图上抹去。