回溯法 剑指OFFER第12题，矩阵中的路径，自己写的，清晰明白

先看题：

a    b    t    g

c    f    c    s

j    d    e    h

题目：请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。

例如，上面的3x4的矩阵中包含一条字符串"bfce"的路径（路径中的字母用下划线标出）。但矩阵中不包含字符串"abfb"的路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子后，路径不能再次进入这个格子。

思路：字符串的第一个字符可以遍历二维矩阵，第一个字符找到后就需要从第一个字符开始的上、右、下、左去查找第二个字符，并且当前路径上已经串过的格子不能被再次考察，为此需要维护一个"位图"（类似于Linux EXT4文件系统的data block的位图，一个bit表征一个data block使用与否），位图和存储路径的容器在递归调用中要引用传递，从而不需要将递归调用链上填充的路径再回溯返回（通过返回值上溯返回，或全程传递一个准备接收成功路径的路径容器并只在最后搜索成功时填充）。至于位图，只要在递归调用途中发现此路不通，那就逐层上溯释放已经填充的位置，所以当前位图总是对应当前搜索路径，不用值拷贝（虽然值拷贝也可以，搜索失败时还不用回退）。

代码：

//二维字符数组是否能串出给定字符串，不能回串，可上下左右
bool FindStrPath(char **arr,int m,int n,int row,int col,int ichar
    ,const char *str,std::stack<std::pair<int,int> >&path,int **pos=nullptr){
    //二维数组m行n列，当前路径上一个坐标(row,col)，path存储路径，pos是位图
    //char arr[][],error: array has incomplete element type 'int []'
    if(ichar>=strlen(str))return true;  //字符串都成功找出了，探底返回
    if(ichar==0){
        //找第一个字符，可以在整个二维字符数组中找
        //生成pos位图，初始化位图，也可以放在主调函数
        pos=new int*[m];
        for(int i(0);i<n;i++)pos[i]=new int[n];
        for(int i(0);i<m;i++){
            for(int j(0);j<n;j++){
                pos[i][j]=0;
            }
        }
        for(int i(0);i<m;i++){
            for(int j(0);j<n;j++){
                if(arr[i][j]==str[ichar]){
                    pos[i][j]=1;    //标记
                    path.push(std::make_pair(i,j)); //压栈路径
                    if(FindStrPath(arr,m,n,i,j,ichar+1,str,path,pos)) return true;
                    else{ //此路不通，释放位图，弹出路径当前点，继续找
                        pos[i][j]=0;
                        path.pop();
                        continue;
                    }
                }
            }
        }
        return false;
    }
    //不是第一个字符，上下左右找
    if(row-1>=0 && arr[row-1][col]==str[ichar] &&pos[row-1][col]==0){
        //上
        pos[row-1][col]=1;  //标记
        path.push(std::make_pair(row-1,col));   //压栈路径
        if(FindStrPath(arr,m,n,row-1,col,ichar+1,str,path,pos)) return true;
        else{
            //此路不通，释放位图，弹出路径当前点，继续后面其他方向
            pos[row-1][col]=0;
            path.pop();
        }
    }
    if(col+1<n && arr[row][col+1]==str[ichar] &&pos[row][col+1]==0){
        //右
        pos[row][col+1]=1;
        path.push(std::make_pair(row,col+1));
        if(FindStrPath(arr,m,n,row,col+1,ichar+1,str,path,pos)) return true;
        else{
            //此路不通，释放位图，弹出路径当前点，继续后面其他方向
            pos[row][col+1]=0;
            path.pop();
        }
    }
    if(row+1<m && arr[row+1][col]==str[ichar] &&pos[row+1][col]==0){
        //下
        pos[row+1][col]=1;
        path.push(std::make_pair(row+1,col));
        if(FindStrPath(arr,m,n,row+1,col,ichar+1,str,path,pos)) return true;
        else{
            //此路不通，释放位图，弹出路径当前点，继续后面其他方向
            pos[row+1][col]=0;
            path.pop();
        }
    }
    if(col-1>=0 && arr[row][col-1]==str[ichar] &&pos[row][col-1]==0){
        //左
        pos[row][col-1]=1;
        path.push(std::make_pair(row,col-1));
        if(FindStrPath(arr,m,n,row,col-1,ichar+1,str,path,pos)) return true;
        else{
            //此路不通，释放位图，弹出路径当前点，也没有其他方向了，将返回false
            //，但还是把pos和path给还原，回溯到某个分岔点去找
            pos[row][col-1]=0;
            path.pop();
        }
    }
    return false;
};

测试：

void func2(){
    int row(3),col(4);
    char **arr=new char*[row];
    for(int i(0);i<row;i++)arr[i]=new char[col];
    arr[0][0]='a';arr[0][1]='b';arr[0][2]='t';arr[0][3]='g';
    arr[1][0]='c';arr[1][1]='f';arr[1][2]='c';arr[1][3]='s';
    arr[2][0]='j';arr[2][1]='d';arr[2][2]='e';arr[2][3]='h';
    const char *str="bfce";
    std::cout<<strlen(str)<<"\n";   //期望是4
    std::stack<std::pair<int,int> >path;
    bool bRes=FindStrPath(arr,row,col,-1,-1,0,str,path,nullptr);
    std::cout<<bRes<<"\n";
    if(bRes){
        // for(std::pair<int,int> & rele:path)std::cout<<rele.first<<"-"<<rele.second<<"\n";
        //stack<T>没有begin成员函数
        while(path.size()>0){
            std::pair<int,int> ele=path.top();
            std::cout<<ele.first<<"-"<<ele.second<<"\n";
            path.pop();
        }
    }
}

结果：

1
2-2
1-2
1-1
0-1
HaypinsMBP:MultiThread haypin$