剑指offer - 面试题12:矩阵中的路径 - C++

class Solution {
public:
    bool hasPath(char* matrix, int rows, int cols, char* str)
    {
        if(matrix==nullptr || rows<1 || cols<1 || str==nullptr ) {
            return false;
        }
        
        bool* visited = new bool[rows*cols];
        memset(visited, 0, rows*cols);
        int pathLength = 0;
        
        for(int row=0; row<rows; row++) {
            for(int col=0; col<cols; col++) {
                if(hasPathCore(matrix, rows, cols, row, col,
                               str, pathLength, visited)) {
                    return true;
                }
            }
        }
        delete[] visited;
        return false;
    }
    bool hasPathCore(const char* matrix, int rows, int cols, int row, int col,
                     const char* str, int& pathLength, bool* visited) {
        if(str[pathLength] == '\0') {
            return true;
        }
        bool hasPath = false;
        if(row>=0 && row<rows && col>=0 && col<cols
          && matrix[row*cols+col] == str[pathLength]
          && !visited[row*cols+col]) {
            pathLength++;
            visited[row*cols+col] = true;
            
            hasPath = hasPathCore(matrix, rows, cols, row, col-1, 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+1, col, str, pathLength, visited); 
            if(!hasPath) {
                --pathLength;
                visited[row*cols+col] = false;
            }
        }
        return hasPath;     
    }

};

 

涉及的递归比较复杂，所以照抄书上的解了。

第三次过。因为代码比较长，抄错了。

第0次自检：发现一个分支没有return，加上。

第1次：改了两次矩阵visited按下标取值方括号写成了圆括号，提示visited不是function后改正。if语句中两个条件之间不小心加了分号。

改完第一次提示编译成功但case通过率30+%，于是按照给出的没过的case检查，检查半天觉得没问题，于是看到visited[row*cols+col]的*写成了+，改正后答案通过。

总结

矩阵问题实现有几个对应：

1. 矩阵->二维数组

2.上下左右走->row+-1,col+-1;

递归要素：

1. 递归的尽头返回

2. 复杂一般情况递归调用自身，取返回值。

此题对我来说还是比较难。

 

 

二刷

class Solution {
public:
    bool hasPath(char* matrix, int rows, int cols, char* str)
    {
        if(matrix==nullptr || rows<1 || cols<1 || str==nullptr) return false;
            
        // 重复调用Core时visited需存有以前的数据，所以要在这里创建
        bool* visited = new bool[rows*cols];
        memset(visited, 0, rows*cols);  // 矩阵初始化
        
        for(int row=0; row<rows; row++) {  // 矩阵遍历
            for(int col=0; col<cols; col++) {
                if(hasPathCore(matrix, rows, cols, str, row, col, visited)) {
                    return true;
                }
            }
        }
        return false;
    }
    
    bool hasPathCore(char* matrix, int rows, int cols,  // 原数据
                     char* s, int row, int col,  // 起点
                     bool* visited) {
        if(*s == '\0') {  // 字符串结束标志
            return true;  // 递归结束条件
        }
        
        bool hasPath = false;  // 不满足条件直接返回false
        // 判断
        if(row>=0 && row<rows && col>=0 && col<cols
        && !visited[row*cols+col]  // 不能用visited[row][col]访问
        && matrix[row*cols+col] == *s) {
            visited[row*cols+col] = 1;
            s++;
            
            hasPath = hasPathCore(matrix, rows, cols, s, row-1, col, visited)
                   || hasPathCore(matrix, rows, cols, s, row+1, col, visited)
                   || hasPathCore(matrix, rows, cols, s, row, col-1, visited)
                   || hasPathCore(matrix, rows, cols, s, row, col+1, visited);
            
            if(!hasPath) {
                visited[row*cols+col] = 0;
                s--;
            }
        }
        
        return hasPath;
    }
};

第三次过。这次还是参考着第一次的写的，但是边写边思考了，思考结果都在注释里了。

一处敲错一处粘贴完忘改，visited不能用visited[row][col]访问因为它只是一个单纯的小指针，并没有被申明为二维数组。

这次我没加pathLength这个参数，直接用指针写的，简洁了一些～值得表扬：）