LeetCode HOT 100 --- 2021/7/31

不同路径

分析：
  动态规划：设dp[i][j]表示从00处到ij处的路径数量。边界条件：由于每次只能向右或者向下移动一步，所以第0行和第0列的所有网格的路径数都为1，即：

dp[i][0] = dp[0][j] = 1;

  转移方程：只有[i-1][j]和[i][j-1]两处位置才能到达ij处，所以到达ij处的路径数实际上为二者之和，即转移方程为：

dp[i][j] = dp[i - 1][j] + dp[i][j - 1];

代码：

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m, vector<int>(n));
        for(int i = 0; i < m; i++) {
            dp[i][0] = 1;
        }
        for(int j = 0; j < n; j++) {
            dp[0][j] = 1;
        }
        for(int i = 1; i < m; i++) {
            for(int j = 1; j < n; j++) {
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }
    //C(m + n - 2)(m - 1);
};

最小路径和

分析：
  简单的动态规划，dp[i][j]表示从00处到ij处的最小路径和。
代码：

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

颜色分类

方法一：
  原地排序，可以使用冒泡排序。
代码：

class Solution {
public:
    void sortColors(vector<int>& nums) {
        int n = nums.size();
        for(int i = 0; i < n - 1; i++) {
            for(int j = 0; j < n - 1 - i; j++) {
                if(nums[j] > nums[j + 1]) {
                    swap(nums[j], nums[j + 1]);
                }
            }
        }
    }
};

方法二：
  单指针：我们可以考虑对数组进行两次遍历。在第一次遍历中，我们将数组中所有的0交换到数组的头部。在第二次遍历中，我们将数组中所有的1交换到头部的0之后。此时，所有的2都出现在数组的尾部，这样我们就完成了排序。
代码：

class Solution {
public:
    void sortColors(vector<int>& nums) {
        int n = nums.size();
        int ptr = 0;
        for (int i = 0; i < n; ++i) {
            if (nums[i] == 0) {
                swap(nums[i], nums[ptr]);
                ++ptr;
            }
        }
        for (int i = ptr; i < n; ++i) {
            if (nums[i] == 1) {
                swap(nums[i], nums[ptr]);
                ++ptr;
            }
        }
    }
};

方法三：
  双指针：两个指针分别指向0和n-1，遍历过程中将2放到最后面，0放到最前面。
代码：

class Solution {
public:
    void sortColors(vector<int>& nums) {
        int n = nums.size();
        if (n < 2) {
            return;
        }
        int p = 0, q = n - 1;
        for (int i = 0; i <= q; ++i) {
            if (nums[i] == 0) {
                nums[i] = nums[p];
                nums[p] = 0;
                ++p;
            }
            if (nums[i] == 2) {
                nums[i] = nums[q];
                nums[q] = 2;
                --q;
                if (nums[i] != 1) {
                    --i;
                }
            }
        }
        return;
    }
};