LeetCode 力扣 刷题记录 热题 HOT 100（62，64，70，72，75）题目+算法分析+Cpp解答

GitHub链接：https://github.com/WilliamWuLH/LeetCode

如果你觉得不错可以 ⭐Star 和 Fork ❤

62.Unique Paths

动态规划：

​ 保存每个位置可能到达该位置的路径数目。

class Solution {
public:
    int uniquePaths(int m, int n) {
        int map[m][n];
        for(int i=0; i<m; i++){
            for(int j=0; j<n; j++){
                if(i == 0 || j == 0)
                    map[i][j] = 1;
                else{
                    map[i][j] = map[i-1][j] + map[i][j-1];
                }
            }
        }
        return map[m-1][n-1];
    }
};

64.Minimum Path Sum

动态规划：

​ 记录到达每个位置的最小路径和，最后得到到达目标位置的最小路径和。

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int m = grid.size(), n = grid[0].size();            
        for(int i=0; i<m; i++){
            for(int j=0; j<n; j++){
                if(i == 0 && j != 0)
                    grid[i][j] += grid[i][j-1];
                else if(i != 0 && j == 0)
                    grid[i][j] += grid[i-1][j];
                else if(i != 0 && j != 0)
                    grid[i][j] += min(grid[i][j-1],grid[i-1][j]);
            }
        }
        return grid[m-1][n-1];
    }
};

70.Climbing Stairs

动态规划：

​ 记录保存爬到每一层楼梯的路径数目，当层数大于等于 2 时，该层的路径数目等于前一层的路径数目加上前两层的路径数目。

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

72.Edit Distance

动态规划：

​ 看似很难，其实解法相当巧妙——大问题变成小问题——最优子结构性质

​ 当其中某一个字符串的长度为 0 时，答案为另一个字符串的长度。

​ 讨论两个字符串当前的字符：

• 如果当前的两个字符相同，则不需要进行任何操作，所以此时的编辑数为加入这两个字符之前的两个字符串的编辑数。
• 如果当前的两个字符不相同，说明需要进行操作，需要选择此时三个操作（插入字符 dp [ i ] [ j-1 ]，删去字符 dp [ i-1 ] [ j ]，替换字符 dp [ i-1 ] [ j-1 ] ）中编辑数最少的，作为此时两个字符串的编辑数。

class Solution {
public:
    int minDistance(string word1, string word2) {
        int len1 = word1.length();
        int len2 = word2.length();
        int dp[len1+1][len2+1];
        for(int i=0; i<=len1; i++)
            dp[i][0] = i;
        for(int i=0; i<=len2; i++)
            dp[0][i] = i;
        for(int i=1; i<=len1; i++){
            for(int j=1; j<=len2; j++){
                if(word1[i-1] == word2[j-1])
                    dp[i][j] = dp[i-1][j-1];
                else
                    dp[i][j] = min(dp[i-1][j-1], min(dp[i][j-1], dp[i-1][j]))+1;
            }
        }
        return dp[len1][len2];
    }
};

75.Sort Colors

统计颜色个数 + 重新排列：

class Solution {
public:
    void sortColors(vector<int>& nums) {
        int count[3] = {0,0,0};
        int len = nums.size();
        for(int i=0; i<len; i++){
            count[nums[i]]++;
        }
        int temp = 0;
        for(int i=0; i<3; i++){
            for(int j=0; j<count[i]; j++){
                nums[temp] = i;
                temp++;                           
            }
        }
    }
};

三指针：

​ 一个指针指向 0 的尾部，一个指针指向 2 的开头，一个指针进行遍历。

class Solution {
public:
    void sortColors(vector<int>& nums) {
        int len = nums.size();
        int left = 0, right = len-1, curr = 0;
        while(curr <= right){
            if(nums[curr] == 0)
                swap(nums[curr++], nums[left++]);
            else if(nums[curr] == 2)
                swap(nums[curr], nums[right--]);
            else
                curr++;
        }
    }
};