剑指offer 搜索与回溯算法【矩阵中的路径、机器人的运动范围】

矩阵中的路径.

代码：

class Solution {
public:
    /*
        实现思路：
        先暴力将每一个点作为起始位置，从起始位置开始搜索，将每一个点的四种走向全部分析完了，
        如果该点合法那么就以这个点作为第二次的起点，重复以上过程，直到将整个字符串遍历完了就返回true，
        如果中间出现当前字符与目标字符不相等的情况那么就不需要考虑了直接返回false。

        这里主要注意的是题目的题意：如果一条路径经过了矩阵中的某一个格子，则之后不能再次进入这个格子。
        这个思路其实也并不难，只需要将每一次走过的位置重新标记为'*'就行，最后使用回溯的思想将所有已经走过
        的位置并设置为'*'的位置重新还原回现场值 
    */
    bool exist(vector<vector<char>>& board, string &word) {
        //暴力枚举将每一个点作为初始地
        for(int i = 0; i < board.size(); i++)
            for(int j = 0; j < board[i].size(); j++)
                if(dfs(board, word,0, i, j)) return true;  //如果在搜索的过程以该点为起始位置并完全匹配上目标字符串那么就返回true


        return false; //假设的每一个点为起始位置去匹配目的字符串都无法正确匹配就返回false

    }

    //深度优先搜索
    bool dfs(vector<vector<char>> &v, string &str ,int u, int x, int y) //u 表示的目标字符串的起始位置， x和y表示一个点的横纵坐标
    {
        if(v[x][y] != str[u]) return false;
        //如果走到了str的最后一个字符了就返回true
        if(u == str.size() - 1) return true;
        //当前位置的字符并不匹配str[u]就返回false
        //定义上、下、左、右四种走向的常量
        static int dx[] = {-1, 0, 1, 0};
        static int dy[] = {0, 1, 0, -1};
        //保存现场值目的事为了遍历字符串完了回溯恢复现场值
        char ch = v[x][y];  
        v[x][y] = '*' ; 

        //枚举以该点位起始位置的四种情况
        for(int i = 0; i < 4; i++)
        {
            int tmpx = x + dx[i];
            int tmpy = y + dy[i];
            //如果坐标合法，那么就从该点为起始位置继续搜索目标字符串
            if(tmpx >= 0 && tmpx < v.size() && tmpy >= 0 && tmpy < v[tmpx].size())
            if(dfs(v, str, u + 1, tmpx, tmpy)) return true; 

        }
        v[x][y] = ch; //恢复现场值
        return false;
    }

};

机器人的运动范围.

代码：

/*
    解题思路：
    这道题的解题思路并不难，主要考察的是代码的边界控制能力，算法采用的思路是广度优先遍历，先从最开始的位置【0，0】
    开始遍历将该下标存放进队列中，再利用队列的性质（先进先出）每次取出该值判断是否遍历过，如果遍历过那么就跳过这次判断
    开始下一次的判断，如果没有那么就以这个点开始枚举他走向的4中情况（上下左右），再判断x横坐标和y纵坐标的值是否合法，
    如果合法那么则push进队列，并记数++一次，最后将整个队列遍历完了，返回所有走过的点的个数
*/

class Solution {
public:

    int get_sum(int x)
    {
        int ret = 0;
        while(x) 
        {
             ret += x % 10; //算出个位
             x /= 10; //算出十位
        }
        return ret; //返回十位数字和个位数字相加的和
    }

    int num(const pair<int, int>& p)
    {
        return get_sum(p.first) + get_sum(p.second);
    }

     int movingCount(int m, int n, int k)
    {
        if(!m|| !n) return 0;
        int ans = 0;  //计数器，判断走过多少的点位
        //设置二维矩阵
        vector<vector<bool>> v(m, vector<bool>(n, false)); //默认将值设置为false表示没有走过 
        queue<pair<int,int>> q; //pair对象存放下标

        //从最开始的位置【0，0】开始遍历
        //入队列
         q.push({0, 0});

        int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1}; //定义表示上、 下、 左、 右的四种状态向量 
        while(q.size()) //如果size为0表示已经走完
        {
            auto t = q.front();  //  //取出队头元素判断是否走过 1、没有走过，先标记为true ,2、如果走过那么就跳出本次循环进入下一次循环
            q.pop();
            if(v[t.first][t.second] || num(t) >  k) continue; //如果横坐标和纵坐标代表的这个点走过或者不合法都跳出循环

            //以上均是判断走过的情况，再来看看没有走过的情况
            v[t.first][t.second] = true;
            //枚举该点的四种走向，如果合法那么就push进队列
           for(int i = 0; i < 4; i++)
           {
               int x = dx[i] + t.first;
               int y = dy[i] + t.second;
                if(x >= 0 && x < m && y >= 0 && y < n) q.push({x, y}); //如果下标合法那么就push进队列
           }


            ans++; //如果该点位没有走过那么就计数，代表走了
        }




        //循环遍历终止返回ans
        return ans;
    }
};