题解25-30

echo-su

已于 2024-02-11 14:16:40 修改

阅读量731

点赞数 13

分类专栏： hot100题解文章标签：深度优先算法数据结构 leetcode

于 2024-02-11 14:15:50 首次发布

本文链接：https://blog.csdn.net/m0_53201842/article/details/136095718

版权

hot100题解专栏收录该内容

8 篇文章 0 订阅

订阅专栏

64. 最小路径和 - 力扣（LeetCode）

给定一个包含非负整数的 *m* x *n* 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

**说明：**每次只能向下或者向右移动一步。

示例 1：

输入：grid = [[1,3,1],[1,5,1],[4,2,1]]
输出：7
解释：因为路径 1→3→1→1→1 的总和最小。

示例 2：

输入：grid = [[1,2,3],[4,5,6]]
输出：12

提示：

m == grid.length
n == grid[i].length
1 <= m, n <= 200
0 <= grid[i][j] <= 200

思路:

这道题也可以同时用记忆化搜索和动态规划来实现

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

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int n = grid.size();
        if (!n) return 0;
        int m = grid[0].size();

        // 初始化记忆数组
        memo = vector<vector<int>>(n, vector<int>(m, INT_MAX));

        // 调用递归函数
        return dfs(grid, n - 1, m - 1);
    }

private:
    vector<vector<int>> memo; // 记忆数组

    int dfs(const vector<vector<int>>& grid, int i, int j) {
        // 如果当前位置已经计算过，直接返回记忆数组中的结果
        if (memo[i][j] != INT_MAX)
            return memo[i][j];

        // 如果是起点，则直接返回其值
        if (i == 0 && j == 0)
            return memo[i][j] = grid[i][j];

        // 更新当前位置的最小路径和
        int minPath = INT_MAX;
        if (i > 0)
            minPath = min(minPath, dfs(grid, i - 1, j) + grid[i][j]);
        if (j > 0)
            minPath = min(minPath, dfs(grid, i, j - 1) + grid[i][j]);

        // 将结果存入记忆数组并返回
        return memo[i][j] = minPath;
    }
};
class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int n = grid.size();
        if (!n) return 0;
        int m = grid[0].size();

        vector<vector<int>> f(n, vector<int>(m, INT_MAX));
        for (int i = 0; i < n; i ++ )
            for (int j = 0; j < m; j ++ ) {
                if (!i && !j) f[i][j] = grid[i][j];
                else {
                    if (i) f[i][j] = min(f[i][j], f[i - 1][j] + grid[i][j]);
                    if (j) f[i][j] = min(f[i][j], f[i][j - 1] + grid[i][j]);
                }
            }

        return f[n - 1][m - 1];
    }
};

70. 爬楼梯 - 力扣（LeetCode）

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

示例 1：

输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶

示例 2：

输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

提示：

1 <= n <= 45

思路:

用动态规划完成,注意初始变量的定义

class Solution {
public:
    int climbStairs(int n) {
        vector<int>f(n + 1);
        f[0] = 1;
        f[1] = 1;
        for (int i = 2; i <= n; i ++ )
            f[i] = f[i - 1] + f[i - 2];
        return f[n];
    }
};

72. 编辑距离 - 力扣（LeetCode）

给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数 。

你可以对一个单词进行如下三种操作：

插入一个字符
删除一个字符
替换一个字符

示例 1：

输入：word1 = "horse", word2 = "ros"
输出：3
解释：
horse -> rorse (将 'h' 替换为 'r')
rorse -> rose (删除 'r')
rose -> ros (删除 'e')

示例 2：

输入：word1 = "intention", word2 = "execution"
输出：5
解释：
intention -> inention (删除 't')
inention -> enention (将 'i' 替换为 'e')
enention -> exention (将 'n' 替换为 'x')
exention -> exection (将 'n' 替换为 'c')
exection -> execution (插入 'u')

提示：

0 <= word1.length, word2.length <= 500
word1 和 word2 由小写英文字母组成

思路:

用动态规划来实现

替换操作：这意味着我们需要将 word1 中的第 i 个字符替换为 word2 中的第 j 个字符，此时编辑距离会增加 1。因此，f[i - 1][j - 1] 表示了替换操作的编辑距离。
删除操作：这意味着我们需要删除 word1 中的第 i 个字符，使得 word1 的前 i-1 个字符与 word2 的前 j 个字符匹配。这个删除操作会导致编辑距离增加 1。因此，f[i - 1][j] 表示了删除操作的编辑距离。
插入操作：这意味着我们需要在 word1 中的第 i 个字符之前插入 word2 中的第 j 个字符，使得 word1 的前 i 个字符与 word2 的前 j-1 个字符匹配。这个插入操作也会导致编辑距离增加 1。因此，f[i][j - 1] 表示了插入操作的编辑距离。

class Solution {
public:
    int minDistance(string word1, string word2) {
        word1 = ' ' + word1, word2 = ' ' + word2;
        int n = word1.size(), m = word2.size();

        vector<vector<int>> f(n + 1, vector<int>(m + 1));
        for(int i = 0; i <= n; i ++)
            f[i][0] = i;
        for(int i = 0; i <= m; i ++)
            f[0][i] = i;
        for(int i = 1; i <= n; i ++)
        {
            for(int j = 1; j <= m; j ++)
            {
                if(word1[i] == word2[j])
                    f[i][j] = f[i - 1][j - 1];
                else
                //注意f[i - 1][j - 1]表示替换一个字符 f[i - 1][j]
                    f[i][j] = min(f[i - 1][j - 1] + 1, min(f[i - 1][j], f[i][j - 1]) + 1);
            }
        }
        return f[n][m];
    }
};

75. 颜色分类 - 力扣（LeetCode）

给定一个包含红色、白色和蓝色、共 n 个元素的数组 nums ，**原地**对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。

我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。

必须在不使用库内置的 sort 函数的情况下解决这个问题。

示例 1：

输入：nums = [2,0,2,1,1,0]
输出：[0,0,1,1,2,2]

示例 2：

输入：nums = [2,0,1]
输出：[0,1,2]

提示：

n == nums.length
1 <= n <= 300
nums[i] 为 0、1 或 2

进阶：

你能想出一个仅使用常数空间的一趟扫描算法吗？

思路:

用三指针三路快排,维护三个区间分别为值是0,值是1,值是2

class Solution {
public:
    void sortColors(vector<int>& nums) {
        int n = nums.size();
        int left = 0, right = n - 1;
        for(int i = 0; i < n; i ++)
        {
            while(i <= right && nums[i] == 2)//注意这里是while,直到当前已经不是2了才结束
            {
                
                swap(nums[i], nums[right --]);
                
            }
            if(nums[i] == 0)
                swap(nums[i], nums[left ++]);
        }
    }
};

76. 最小覆盖子串 - 力扣（LeetCode）

todo

78. 子集 - 力扣（LeetCode）

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集不能包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：

输入：nums = [0]
输出：[[],[0]]

提示：

1 <= nums.length <= 10
-10 <= nums[i] <= 10
nums 中的所有元素 互不相同

思路:

可以采用二进制枚举或者dfs来实现,下面看看两种代码

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int>> ans;
        int n = nums.size();
        for(int i = 0; i < (1 << n); i ++)
        {
            vector<int> temp;
            for(int j = 0; j < n; j ++)
            {
                if(i >> j & 1)
                    temp.push_back(nums[j]);
            }
            ans.push_back(temp);
        }
        return ans;
    }
};

class Solution {
public:
    vector<int> path;
    vector<vector<int>> ans;
    void dfs(int index, vector<int> nums)
    {
        ans.push_back(path);
        if(index > nums.size())
            return ;
        for(int i = index; i < nums.size(); i ++)
        {
            path.push_back(nums[i]);
            dfs(i + 1, nums);
            path.pop_back();
        }
    }
    vector<vector<int>> subsets(vector<int>& nums) {
        dfs(0, nums);
        return ans;
    }
};