【剑指offer】面试题12：矩阵中的路径【C++版本】

20180602

题目：

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

解题思路：

可以用回溯法来解决的典型问题。

回溯法：

回溯法可以看成蛮力法的升级版，它从解决问题的每一步的所有可能选项里系统地选择一个可行的解决方案。回溯法非常适合由多个步骤组成的问题，并且每个步骤都有多个选项。当我们在某一步选择了其中一个选项时，就进入下一步，然后又面临新的选项。就这样重复选择，直到到达最终的状态。
用回溯法解决的问题的所有选项可以形象的用树状结构表示。在某一步有n个可能的选项，那么该步骤可以看做是树状结构中的一个节点，每个选项看成树中节点连接线，经过这些连接线到达该节点的n个子节点。树的叶子节点对应着终结状态。如果树的叶节点满足题目的约束条件，那么我们就找到了一个可行的解决方案。
如果叶节点的状态不满足约束条件，那么只好回溯到它的上一个节点再尝试其他的选项。如果上一个节点的所有可能选项都已经试过了，并且不能到达满足约束条件的终结状态。则再次回溯到上一个节点。

首先在矩阵中任意选取一个格子作为起点。假设矩阵中某个格子的字符为ch，并且这个格子对应于路径上的第i个字符。如果路径上的第i个字符不是ch，那么这个格子不可能处在路径的第i个位置上。如果路径的第i个字符恰好是ch，那么到相邻的格子上寻找第i+1个字符。重复这个过程直到路径上的所有字符都在矩阵中找到相应的位置。由于回溯法的递归特性，路径可以被看做一个栈。

解题注意事项：

1.应该有一个布尔值矩阵来记录矩阵的哪些格子已经被使用过了
2.使用递归的方式求解。在使用递归的时候应该注意，在退出递归的时候需要根据需求对计数或者标志进行回退或者清楚等操作。

可以AC的代码（C++版本）

#include <vector>                   
#include <stdlib.h>                 
#include <algorithm>                
#include <string.h>                 
#include <iostream>                 

using namespace std;                

bool hasPathCore(const char *matrix,int rows,int cols,int row,int col,const char *str,int &pathLength,bool *visited)                            
{                                   
    //一定注意开头两个判定的顺序，如果str已经全部监测了，那么就直接返回true，不需要进行下一步检测
    if(str[pathLength] == '\0')return true;        

    //需要进一步检测才检查状态对不对                                                                                                                                                                                                        
    if((row < 0)||(col < 0)||(row >= rows)||(col >= cols)||(visited[row*cols+col]))return false;                                                

    bool resu = false;              
    if(matrix[row*cols+col] == str[pathLength]){                                                                                                
        pathLength++;               
        visited[row*cols+col] = true;                                                                                                           

        resu = hasPathCore(matrix,rows,cols,row+1,col,str,pathLength,visited)||                                                                 
            hasPathCore(matrix,rows,cols,row,col+1,str,pathLength,visited)||                                                                    
            hasPathCore(matrix,rows,cols,row-1,col,str,pathLength,visited)||                                                                    
            hasPathCore(matrix,rows,cols,row,col-1,str,pathLength,visited);                                                                     

        //如果resu为假，当前格子不可能处在路径的第pathLength个位置上（所有可能性都检查了）
        if(!resu){                                     
            pathLength--;                          //从当前分支退出，把pathLength减回去，visited清空                                            
            visited[row*cols+col] = false;                                                                                                      
        }                           
    }                               

    return resu;                    
}                                   

bool hasPath(char* matrix, int rows, int cols, char* str)                                                                                       
{                                   
    if((matrix == NULL)||(rows <= 0)||(cols <= 0)||(str == NULL)){                                                                              
        return false;               
    }                               

    bool *visited = (bool *)malloc(rows*cols);                                                                                                  
    memset(visited,false,rows*cols);

    bool resu;                      
    int pathLength = 0;             
    for(int i = 0;i != rows;i++){   
        for(int j = 0;j != cols;j++){                                                                                                           
            if(hasPathCore(matrix,rows,cols,i,j,str,pathLength,visited)){                                                                       
                free(visited);      
                return true;        
            }                       
        }                           
    }                               

    free(visited);                  
    return false;                   
}                                   

int main()                          
{                                   
    char test[] = "AAAAAAAAAAAA" ;
    char str[] = "AAAAAAAAAAAA"                   
    bool resu = hasPath(test,3,4,str);         

    return 0;                       
}