【剑指offer】50.矩阵中的路径

总目录：

算法之旅导航目录

 

1.问题描述

请设计一个函数，用来判断在一个n乘m的矩阵中是否存在一条包含某长度为len的字符串所有字符的路径。

路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。

例如

[a,b,c,e;

s,f,c,s;

a,d,e,e]矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。

数据范围：0≤n,m≤20,1≤len≤25

2.问题分析

 1回溯法

先在大循环里找到匹配的入口，然后上下左右找下一个匹配的字符进行递归，需要使用一个全局表来记录某个坐标是否已经被占用

3.代码实例

回溯法，很笨的实现

class Solution {
  public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param matrix char字符型vector<vector<>>
     * @param word string字符串
     * @return bool布尔型
     */
    //辅助空间
    const char illigalChar = '\0';
    int rowCnt, colCnt, charCnt;
    vector<vector<bool>> flagMat;

    //按方向步进
    bool getNextLocation(const int dir, const int curRow, const int curCol,
                         int& newRow,
                         int& newCol) {
        newRow = 0;
        newCol = 0;

        switch (dir) {
            case 0:
                if (curRow <= 0) return false;
                newRow = curRow - 1;
                newCol = curCol;
                break;
            case 1:
                if (curCol <= 0) return false;
                newRow = curRow;
                newCol = curCol - 1;
                break;
            case 2:
                if (curRow >= (rowCnt - 1)) return false;
                newRow = curRow + 1;
                newCol = curCol;
                break;
            case 3:
                if (curCol >= (colCnt - 1)) return false;
                newRow = curRow;
                newCol = curCol + 1;
                break;
            default:
                break;
        }

        return true;
    }

    //按方向匹配
    char getNearChar(vector<vector<char> >& matrix, const int curRow,
                     const int curCol,
                     int dir) {
        //dir 0-上，1-左，2-下，3-右
        int newRow, newCol;
        bool canNext = getNextLocation(dir, curRow, curCol, newRow, newCol);
        if (!canNext) {
            return illigalChar;
        }
        return flagMat[newRow][newCol]
               ? illigalChar : matrix[newRow][newCol] ;
    }

    //蔓延，递归
    int depth = 0;
    bool Spread(vector<vector<char> >& matrix, const int curRow, const int curCol,
                string word, int tgtCharId) {
        printf("depth=%d", depth++);

        //中止条件，该搜索的已经搜索完
        if (tgtCharId >= charCnt) {
            return true;
        }

        //遍历方向
        //dir 0-上，1-左，2-下，3-右
        bool isMatch = false;
        bool canNext = false;
        int newRow = 0, newCol = 0;
        for (int dir = 0; dir < 4; dir++) {
            //指定方向的字符不匹配
            if (getNearChar(matrix, curRow, curCol, dir) != word[tgtCharId]) {
                continue;
            }

            //在字符继续搜索
            getNextLocation(dir, curRow, curCol, newRow, newCol);
            flagMat[newRow][newCol] = true;//标记占用
            isMatch = Spread(matrix, newRow, newCol, word, tgtCharId + 1);
            if (isMatch) {
                return true;
            }
            flagMat[newRow][newCol] = false;//解除占用
        }

        return false;
    }


    //程序入口
    bool hasPath(vector<vector<char> >& matrix, string word) {
        //边界保护
        if (matrix.size() <= 0 || matrix[0].size() <= 0) {
            if (word.size() > 0) {
                return false;
            }
        }

        //辅助空间
        rowCnt = matrix.size();
        colCnt = matrix[0].size();
        charCnt = word.size();
        for (int rowId = 0; rowId < rowCnt; rowId++) {
            flagMat.push_back(vector<bool>(colCnt, false));
        }

        //边界保护
        if (rowCnt * colCnt < charCnt) {
            return false;
        }

        //从首字符开始
        bool isMatch = false;
        for (int curRow = 0; curRow < rowCnt; curRow++) {
            for (int curCol = 0; curCol < colCnt; curCol++) {
                //匹配首字符
                if (matrix[curRow][curCol] != word[0]) {
                    continue;
                }

                //找到入口，蔓延搜索
                flagMat[curRow][curCol] = true;//标记占用
                isMatch = Spread(matrix, curRow, curCol, word, 1);
                if (isMatch) {
                    return true;
                }
                flagMat[curRow][curCol] = false;//解除占用
            }
        }

        return isMatch;
    }
};