LeetCode-0727

最新推荐文章于 2024-04-28 16:03:45 发布

Parzivval

最新推荐文章于 2024-04-28 16:03:45 发布

阅读量183

点赞数

分类专栏： LeetCode 文章标签： leetcode 算法

本文链接：https://blog.csdn.net/lannister_awalys_pay/article/details/131960646

版权

LeetCode 专栏收录该内容

72 篇文章 0 订阅

订阅专栏

SQL50 基础

1633

  select contest_id,
  Round(count(*) * 100/(select count(*) from Users),2) as percentage 
  from Users cross join Register
  using(user_id)
  group by contest_id
  order by count(*) desc,contest_id

1211

select query_name , Round(avg(rating/position),2) as quality,
Round(sum(IF(rating<3,1,0))*100/count(*),2) as poor_query_percentage
from Queries 
group by query_name

动态规划基础版

198.打家劫舍

class Solution {
    public int rob(int[] nums) {
        
        int n = nums.length;
        int dp[] = new int[n];
        dp[0] = nums[0];
        if(n>=2)dp[1] = Math.max(nums[0],nums[1]);

        for(int i=2;i<n;i++){
            dp[i] = Math.max(dp[i-1],dp[i-2]+nums[i]);
        }
      	
        return dp[n-1];
    }
}

740.删除并获得点数

class Solution {
    public static int deleteAndEarn(int[] nums) {

        Map<Integer,Integer> mp = new TreeMap<>();

        for(int num:nums)mp.put(num,mp.getOrDefault(num,0)+num);

        int n = mp.size();
        int dp[][] = new int[n][2];
        int i = 0;

        for(Map.Entry<Integer,Integer>entry:mp.entrySet()){
            dp[i][0] = entry.getKey();
            dp[i][1] = entry.getValue();
            i++;
        }

        for(int j=1;j<n;j++){

            if(dp[j][0]-dp[j-1][0]>1)dp[j][1] += dp[j-1][1];
            else {
                dp[j][1] = Math.max((j-2>=0?dp[j-2][1]:0)+dp[j][1],dp[j-1][1]);
            }
        }

        return dp[n-1][1];
    }
}

62.不同路径

class Solution {
    public int uniquePaths(int m, int n) {

        int dp[][] = new int[m][n];

        for(int i=0;i<m;i++)dp[i][0] = 1;
        for(int i=0;i<n;i++)dp[0][i] = 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];
    }
}

64.最小路径和

class Solution {
    public int minPathSum(int[][] grid) {
        int n = grid.length;
        int m = grid[0].length;

        for(int i=1;i<n;i++)grid[i][0] += grid[i-1][0];
        for(int j=1;j<m;j++)grid[0][j] += grid[0][j-1];

        for(int i=1;i<n;i++){
            for(int j=1;j<m;j++)
                grid[i][j] += Math.min(grid[i-1][j],grid[i][j-1]);
        }
        return grid[n-1][m-1];
    }
}

63.不同路径II

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int n = obstacleGrid.length;
        int m = obstacleGrid[0].length;

        int dp[][] = new int[n][m];

        for(int i=0;i<n;i++){
            if(obstacleGrid[i][0]==1)break;
            dp[i][0] = 1;
        }
        for(int j=0;j<m;j++){
            if(obstacleGrid[0][j]==1)break;
            dp[0][j] = 1;
        }

        for(int i=1;i<n;i++){
            for(int j=1;j<m;j++){
                if(obstacleGrid[i][j]==1)continue;
                dp[i][j] = dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[n-1][m-1];
    }
}