leetcode：图相关算法

01 矩阵中的路径

#include<vector>
#include<string>
using namespace std;

class Solution {
public:
    //解法一：深度优先搜索
    bool exist(vector<vector<char>>& board, string word) 
    {
        for (int i = 0; i < board.size(); i++)
        {
            for (int j = 0; j < board[0].size(); j++)
            {
                if (DFS(board, word, 0, i, j))
                {
                    return true;
                }
            }
        }
        return false;
    }
    bool DFS(vector<vector<char>>& board, string& word, int k, int i, int j)
    {
        if (k >= word.size()) return true;
        if ((i < 0)
            || (i >= board.size())
            || (j < 0)
            || (j >= board[0].size())
            || (board[i][j] != word[k])
            || (board[i][j] == '\0'))
        {
            return false;
        }

        char ch = board[i][j];
        board[i][j] = '\0';
        bool res = (DFS(board, word, k + 1, i + 1, j)
            || DFS(board, word, k + 1, i - 1, j)
            || DFS(board, word, k + 1, i, j + 1)
            || DFS(board, word, k + 1, i, j - 1));

        if (!res)
        {
            board[i][j] = ch;
        }
        return res;
    }
};

02 机器人可达路径范围

解法一 广度优先搜索

class Solution {
public:
    //解法1：广度优先搜索算法
    int movingCount(int m, int n, int k) {
        vector<vector<int>> record;
        for (int i = 0; i < m; i++)
        {
            vector<int> record_i;
            for (int j = 0; j < n; j++)
            {
                record_i.push_back(0);
            }
            record.push_back(record_i);
        }

        int res = 1;
        queue<position> que;
        position start = { 0,0 };
        que.push(start);
        while (!que.empty())
        {
            position popOut = que.front();
            que.pop();
            if (isPositionArrivble(m, n, k, popOut.position_i + 1, popOut.position_j, record))
            {
                res++;
                position temp = { popOut.position_i + 1,popOut.position_j };
                que.push(temp);
            }
            if (isPositionArrivble(m, n, k, popOut.position_i, popOut.position_j + 1, record))
            {
                res++;
                position temp = { popOut.position_i,popOut.position_j + 1 };
                que.push(temp);
            }
        }
        return res;
    }

    struct position {
        int position_i;
        int position_j;
    };

    bool isPositionArrivble(int m, int n, int k, int i, int j, vector<vector<int>>& record)
    {
        //位置范围判断 以及是否走过判断
        if ((i < 0)
            || (i >= m)
            || (j < 0)
            || (j >= n)
            || (record[i][j] != 0)
            ) return 0;

        //限制条件判断
         //返回结果
        record[i][j] = 1;

        int value = 0;

        while (i >= 10)
        {
            value += i % 10;
            i /= 10;
        }

        value += i;

        while (j >= 10)
        {
            value += j % 10;
            j /= 10;
        }

        value += j;

        if (value <= k) return true;

        return false;
    }

};

解法二 深度优先搜索

class Solution {
public:
    //解法1：广度优先搜索算法
    int movingCount(int m, int n, int k) {
        vector<vector<int>> record;
        for (int i = 0; i < m; i++)
        {
            vector<int> record_i;
            for (int j = 0; j < n; j++)
            {
                record_i.push_back(0);
            }
            record.push_back(record_i);
        }

        return DFS(m, n, k, 0, 0, record);
    }

    int DFS(int m, int n, int k, int i, int j, vector<vector<int>>& record)
    {
        int ri = i;
        int rj = j;
        //位置范围判断 以及是否走过判断
        if ((i < 0)
            || (i >= m)
            || (j < 0)
            || (j >= n)
            || (record[i][j] != 0)
            ) return 0;

        //限制条件判断
         //返回结果
        record[i][j] = 1;

        int value = 0;

        while (i >= 10)
        {
            value += i % 10;
            i /= 10;
        }

        value += i;

        while (j >= 10)
        {
            value += j % 10;
            j /= 10;
        }

        value += j;

        if (value > k) return 0;

       

        int res = 1;
        res +=  (DFS(m, n, k, ri + 1, rj, record)  + DFS(m, n, k, ri, rj + 1, record));
        return res;

    }
};

03 礼物价值最大

解题思路这一类题目的解法就是动态规划+正向解题思路

class Solution {
public:
    int maxValue(vector<vector<int>>& grid) {

        //初始化第一列
        for(int i = 1;i < grid.size();i++)
        {
            grid[i][0] += grid[i-1][0];
        }

        //初始化第一行
        for(int j = 1;j < grid[0].size();j++)
        {
            grid[0][j] += grid[0][j-1];
        }

        //计算其它位置的值
        for(int i = 1;i<grid.size();i++)
        {
            for(int j = 1;j<grid[0].size();j++)
            {
                if(grid[i][j-1] > grid[i-1][j])
                {
                    grid[i][j] += grid[i][j-1];
                }
                else
                {
                    grid[i][j] += grid[i-1][j];
                }
            }
        }
        return grid[grid.size()-1][grid[0].size()-1];
    }

   
};