牛客 华为机试 HJ24 合唱队

牛客 华为机试 HJ24 合唱队

题目描述：HJ24 合唱队

描述

N 位同学站成一排，音乐老师要请最少的同学出列，使得剩下的 K 位同学排成合唱队形。

设 K 位同学从左到右依次编号为 1，2，…，K ，他们的身高分别为T₁，T₂， …， T_K，若存在 i （1≤i≤K） 使得 T₁< T₂ < … < T_i−1 <T_i 且 T_i >T_i+1 > … > T_k ，则称这 K 名同学排成了合唱队形。

通俗来说，能找到一个同学，他的两边的同学身高都依次严格降低的队形就是合唱队形。

例子：

123 124 125 123 121 是一个合唱队形

123 123 124 122不是合唱队形，因为前两名同学身高相等，不符合要求

123 122 121 122不是合唱队形，因为找不到一个同学，他的两侧同学身高递减。

你的任务是，已知所有N位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。

注意：不允许改变队列元素的先后顺序 且 不要求最高同学左右人数必须相等

数据范围：1 ≤ n ≤ 3000

输入描述：

用例两行数据，第一行是同学的总数 N ，第二行是 N 位同学的身高，以空格隔开

输出描述：

最少需要几位同学出列

示例1

输入：

8
186 186 150 200 160 130 197 200

复制

输出：

4

复制

说明：

由于不允许改变队列元素的先后顺序，所以最终剩下的队列应该为186 200 160 130或150 200 160 130           

解法1

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] nums = new int[n];
        for (int i = 0; i < n; i++) {
            nums[i] = in.nextInt();
        }
        // 动态规划
        int[] left = new int[n];
        int[] right = new int[n];
        Arrays.fill(left, 1);
        Arrays.fill(right, 1);
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    left[i] = Math.max(left[i], left[j] + 1);
                }
            }
        }
        for (int i = n - 2; i >= 0; i--) {
            for (int j = n - 1; j > i; j--) {
                if (nums[i] > nums[j]) {
                    right[i] = Math.max(right[i], right[j] + 1);
                }
            }
        }
        int ans = Integer.MAX_VALUE;
        for (int i = 0; i < n; i++) {
            ans = Math.min(ans, n - left[i] - right[i] + 1);
        }
        System.out.println(ans);
        in.close();
    }
}

解法2

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] nums = new int[n];
        for (int i = 0; i < n; i++) {
            nums[i] = in.nextInt();
        }

        // dp1[i]表示该位置结尾的最长递增子序列长度
        int[] dp1 = new int[n];
        // tail1表示维护的一个严格递增子序列
        int[] tail1 = new int[n];
        // tail1数组的最后一个元素下标
        int end1 = -1;
        for (int i = 0; i < n; i++) {
            // 如果tail1数组为空，或nums[i]大于tail1数组末尾元素，直接将nums[i]放在tail1数组末尾
            if (i == 0 || tail1[end1] < nums[i]) {
                tail1[++end1] = nums[i];
                dp1[i] = end1 + 1;
            }
            // 否则，二分法找到nums[i]在tail1数组中的位置
            else {
                int low = 0, high = end1;
                while (low < high) {
                    int mid = low + (high - low) / 2;
                    if (tail1[mid] >= nums[i]) {
                        high = mid;
                    } else {
                        low = mid + 1;
                    }
                }
                tail1[low] = nums[i];
                dp1[i] = low + 1;
            }
        }

        // dp2[i]表示该位置开头的最长递减子序列长度
        int[] dp2 = new int[n];
        // tail2表示维护的一个严格递增子序列
        int[] tail2 = new int[n];
        // tail2数组的最后一个元素下标
        int end2 = -1;
        for (int i = n - 1; i >= 0; i--) {
            // 如果tail2数组为空，或nums[i]大于tail2数组末尾元素，直接将nums[i]放在tail2数组末尾
            if (i == n - 1 || tail2[end2] < nums[i]) {
                tail2[++end2] = nums[i];
                dp2[i] = end2 + 1;
            }
            // 否则，二分法找到nums[i]在tail2数组中的位置
            else {
                int low = 0, high = end2;
                while (low < high) {
                    int mid = low + (high - low) / 2;
                    if (tail2[mid] >= nums[i]) {
                        high = mid;
                    } else {
                        low = mid + 1;
                    }
                }
                tail2[low] = nums[i];
                dp2[i] = low + 1;
            }
        }

        int ans = Integer.MAX_VALUE;
        for (int i = 0; i < n; i++) {
            ans = Math.min(ans, n - dp1[i] - dp2[i] + 1);
        }
        System.out.println(ans);
        in.close();
    }
}