矩阵中的路径：回溯法，递归与栈。

题目描述
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。 例如[a b c e s f c s a d e e]是3*4矩阵，其包含字符串"bcced"的路径，但是矩阵中不包含“abcb”路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。


解法一：非递归，用栈实现。

注意栈中Node的结构有个direction变量，表示上一次路径走过的方向。

struct Node
{
    int i;
    int j;
    int direction;
    Node(int x,int y,int di):i(x),j(y),direction(di){}
};

//回溯法使用栈模拟，非递归版本。

class Solution {
public:
    bool hasPath(char* matrix, int rows, int cols, char* str)
    {
        vector<vector<char>>m(rows,vector<char>(cols,' '));
        for (int i = 0; i < rows; ++i)
        {
            for (int j = 0; j < cols; ++j)
            {
                m[i][j]=*matrix++;
            }
        }
        vector<vector<bool>>visited(rows,vector<bool>(cols,false));
        for (int i = 0; i < rows; ++i)
        {
            for (int j = 0; j < cols; ++j)
            {
                if(m[i][j]==*str){
                    str++;
                    if(*str=='\0') return true;//若出现"A",1,1,"A"这种情况防止没有在四方向寻找中得到true,而直接退出stack,在for外面中得到false
                    stack<Node> st;
                    Node curNode(i,j,-1);
                    st.push(curNode);
                    visited[i][j]=true;
                    
                    while(!st.empty()){
                        Node& curNode=st.top();//reference
                        bool find=false;
                        int r,c;
                        while(curNode.direction<4&&find==false){
                            curNode.direction++;
                            switch(curNode.direction)
                            {
                                case 0:r=curNode.i-1;c=curNode.j;break;
                                case 1:r=curNode.i;c=curNode.j+1;break;
                                case 2:r=curNode.i+1;c=curNode.j;break;
                                case 3:r=curNode.i;c=curNode.j-1;break;
                            }
                            if(isValidPos(r,c,rows,cols)&&visited[r][c]==false){
                                if(m[r][c]==*str){
                                    str++;
                                    find=true;
                                    Node newNode(r,c,-1);
                                    st.push(newNode);
                                    visited[r][c]=true;
                                }
                                if(*str=='\0')
                                    return true;
                            }
                        }
                        if(find==false){
                            visited[curNode.i][curNode.j]=false;
                            st.pop();
                            str--;
                        }
                    }//while(!st.empty())
                }//if(m[i][j]==*str)
            }
        }
        return false;
    }

    bool isValidPos(int x,int y,int rows,int cols){
        return (x>=0&&x<rows&&y>=0&&y<cols);
    }

};

解法二：递归实现：

技巧：能用递归的就不用栈，否则就是自找麻烦！！！

class Solution {
public:
    bool hasPath(char* matrix, int rows, int cols, char* str)
    {
        bool*visited=new bool[rows*cols];
        //memset(visited,0,sizeof(visited));
       	for(int i=0;i<rows*cols;++i) visited[i]=false;//这里果然不能用memset(visited,0,sizeof(visited))
        int len=strlen(str);
        for (int i = 0; i < rows; ++i)
        {
            for (int j = 0; j < cols; ++j)
            {
                if(helper(matrix,rows,cols,i,j,str,0,len,visited))
                    return true;
            }
        }
        return false;
    }

    bool helper(char*matrix,int rows,int cols,int i,int j,char* str,int k,int len,bool*visited){
        if(k==len) return true;
        int index=i*cols+j;
        if(i<0||i>=rows||j<0||j>=cols||visited[index]==true||matrix[index]!=str[k])
            return false;
        //if(k==len-1) return true;
        visited[index]=true;
        if(  helper(matrix,rows,cols,i-1,j,str,k+1,len,visited)
           ||helper(matrix,rows,cols,i,j+1,str,k+1,len,visited)
           ||helper(matrix,rows,cols,i+1,j,str,k+1,len,visited)
           ||helper(matrix,rows,cols,i,j-1,str,k+1,len,visited)
        ){
            return true;}
        visited[index]=false;
        return false;

    }

};