Leetcode 101刷题记录（5）

695. 岛屿的最大面积

class Solution {
public:
    int dir[4][2] = {-1,0,0,-1,1,0,0,1};//gird.size()表示x轴方向上长，gird[0].size表示y轴方向上
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        if(grid.empty() || grid[0].empty())
            return 0;
        int Max = 0;
        for(int i = 0;i < grid.size();i++)
            for(int j = 0;j < grid[0].size();j++){
                if(grid[i][j])
                    Max = max(Max, dfs(grid, i, j));
            }
        return Max;
    }
    int dfs(vector<vector<int>>& grid, int l, int r){
        if(!grid[l][r])
            return 0;
        grid[l][r] = 0;//已遍历，标0
        int area = 1;
        int x, y;
        for(int i = 0;i < 4;i++){
            x = l + dir[i][0];
            y = r + dir[i][1];
            if(x >= 0 && x < grid.size() && y >= 0 && y < grid[0].size())//防止越界
                area += dfs(grid, x, y);
        }
        return area;
    }
};

搜索复健，很简单的DFS入门

547. 朋友圈

class Solution {
public:
    int findCircleNum(vector<vector<int>>& M) {
        int size = M.size();
        vector<int>vis(size, 0);
        int cnt = 0;
        for(int i = 0;i < size;i++)
            if(!vis[i]){//遇见新的未搜索到的人
                dfs(M, vis, i);
                cnt++;
            }
        return cnt;
    }
    void dfs(vector<vector<int>>& M, vector<int>& vis, int i){
        vis[i] = 1;//标1
        for(int k = 0;k < M.size();k++)
            if(M[i][k] && !vis[k])//第i位与第k位有关系，且第k位从未被搜索过
                dfs(M, vis, k);//继续深搜
    }
};

可以用并查集做，不过我这里的方法就是简单搜索

70. 爬楼梯

class Solution {
public:
    int climbStairs(int n) {
        vector<int>a(n + 1,0);
        if(n == 1 || n == 0 || n == 2)
            return n;
        a[1] = 1;
        a[2] = 2;
        for(int i = 3;i <= n;i++)
            a[i] = a[i - 1] + a[i - 2];//能走到第i阶的方法为i - 1 与i - 2之和
        return a[n];
    }
};
//a[i] = a[i - 1] + a[i - 2]

入门级别的DP

198. 打家劫舍

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.empty())
            return 0;
        int size = nums.size();
        vector<int>dp(size + 1, 0);
        if(size == 1)
            return nums[size - 1];
        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);
        for(int i = 2;i < size;i++)
            dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
        return dp[size - 1];
    }
};
//dp[i] = max(dp[i - 1], dp[i - 2] + a[i - 1]) i >= 2 dp对应nums

我现在是发现了，Leetcode对边界条件的检查超级严格…卡在size = 1 || size = 2两个点好久

413. 等差数列划分

class Solution {
public:
    int numberOfArithmeticSlices(vector<int>& A) {
        if(A.empty())
            return 0;
        int size = A.size();
        if(size < 3)
            return 0;
        vector<int>dp(size, 0);
        int sum = 0;
        for(int i = 2;i < size;i++)
            if(A[i] + A[i - 2] == A[i - 1] * 2){
                dp[i] = dp[i - 1] + 1;
                sum += dp[i];
            }
        return sum;
    }
};

因为等差数列的数量包含自己，所以需要对数列dp加和

64.最小路径和

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        if(grid.empty())
            return 0;
        vector<vector<int>>a(grid.size(), vector<int>(grid[0].size(), 0));//再创建一个相同尺寸的vector
        a[0][0] = grid[0][0];
        for(int i = 0;i < a.size();i++)
            for(int j = 0;j < a[0].size();j++){
                if(j == 0 && i != 0)
                    a[i][j] = a[i - 1][j] + grid[i][j];
                else if(i == 0 && j != 0)
                    a[i][j] = a[i][j - 1] + grid[i][j];
                else if(i == 0 && j == 0)
                    continue;
                else
                    a[i][j] = min(a[i - 1][j], a[i][j - 1]) + grid[i][j];
                
            }
        return a[a.size() - 1][a[0].size() - 1];
    }
};
//dp[i][j] = min(dp[i - 1][j] , dp[i][j - 1]) + gird[i][j]

542. 01 矩阵

class Solution {
public:
    vector<vector<int>> updateMatrix(vector<vector<int>>& matrix) {
        if(matrix.empty())
            return {};
        int n = matrix.size();
        int m = matrix[0].size();
        vector<vector<int>>dp(n, vector<int>(m, INT_MAX - 1));//初始化最大值
        for(int i = 0;i < n;i++)
            for(int j = 0;j < m;j++){
                if(matrix[i][j] == 0)
                    dp[i][j] = 0;
                else{
                    if(i > 0)
                        dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j]);
                    if(j > 0)
                        dp[i][j] = min(dp[i][j - 1] + 1, dp[i][j]);
                }
            }
        for(int i =  n - 1;i >= 0;i--)
            for(int j = m - 1;j >= 0;j--)
                if(matrix[i][j] == 0)
                    matrix[i][j] = 0;
                else{
                    if(i < n - 1)
                        dp[i][j] = min(dp[i + 1][j] + 1, dp[i][j]);
                    if(j < m - 1)
                        dp[i][j] = min(dp[i][j + 1] + 1, dp[i][j]);
                }
        return dp;
    }
};