java力扣第300题和蓝桥杯合唱队_力扣上的春招题会出现在蓝桥杯吗

力扣第300题和蓝桥杯合唱队
都是采用动态规划

来回忆一下动态规划步骤：前者的结果对后者有影响，或者最优，最短等字眼第一感觉就是用动态规划
1.定义dp数组，初始化dp数组
2.模拟枚举前几个得出 动态转移方程
3.返回最终的解(注意当输入为0 ，1这些边界问题应该返回的值是否与dp数组一致。)

力扣300 https://leetcode-cn.com/problems/longest-increasing-subsequence/
给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

class Solution {
    public int lengthOfLIS(int[] nums) {
        int len = nums.length;
        int[] dp = new int[len];
        dp[0] = 1;//初始化
        int maxans = 1;
        for (int i = 1; i < nums.length; i++) {
            dp[i] = 1;//初始化dp无论哪一个位置至少是1
            for (int j = 0; j < i; j++) { 
                if (nums[i] > nums[j]) {//只有nums[i] > nums[j] 才会出现递增的情况
      		        /**
                     * 动态转移方程：dp[i]代表当前位置有的值
                     * dp[j]+1代表  在遍历过程中，在j到i区间里  因为nums[i] > nums[j]
                     * 推出了 多了一个递增的数 所以dp[i]可能等于dp[j]+1
                     * 显然可能等于就是取dp[i]和dp[j+1]之间的大者
                     */
			  		dp[i] = Math.max(dp[i], dp[j] + 1);
                    
                }
            }
            maxans = Math.max(maxans, dp[i]);//计算dp中的最大值
        }
        return maxans;

}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

题目描述
NN 位同学站成一排，音乐老师要请其中的 (N-K)(N−K) 位同学出列，使得剩下的 KK 位同学排成合唱队形。

合唱队形是指这样的一种队形：设 KK 位同学从左到右依次编号为 1-K，他们的身高分别为T1-TK ， 则他们的身高满足 中间高两边低，就像^形状一样。
你的任务是，已知所有 NN 位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。

思路：就是求剩下最多人
从左到右求递增序列的
从右到左求单调递增序列
二者和最大就是剩下最多

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        int len=scan.nextInt();
        int [] arr=new int[len];
        for (int i = 0; i < len; i++) {
            arr[i]=scan.nextInt();
        }
        int[] dp=new int[len];//存储最大递增子序列
        int[] dp2=new int[len];//最大递减子序列
        //力扣300的求法
        dp[0]=dp2[0]=1;
        for (int i = 1; i < len; i++) {
            dp[i]=1;
            for (int j = 0; j < i; j++) {
                if (arr[i]>arr[j]){
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
        }
        //反向遍历求法和变成递增子序列，实质是递减
        for (int i = len-1; i >= 0; i--) {
            dp2[i]=1;
            for (int k = len-1; k > i; k--) {
                if (arr[i]>arr[k]){
                    dp2[i] = Math.max(dp2[i], dp2[k] + 1);
                }
            }
        }
        //二者中取和最大，但是中间值被算了两次所以减1
        int max=0;
        for (int i = 0; i < len; i++) {
            max=Math.max(max,dp[i]+dp2[i]-1);
        }

        System.out.println(len-max);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37