算法-合唱队

题目

计算最少出列多少位同学，使得剩下的同学排成合唱队形 说明：
N位同学站成一排，音乐老师要请其中的(N-K)位同学出列，使得剩下的K位同学排成合唱队形。
合唱队形是指这样的一种队形：设K位同学从左到右依次编号为1，2…，K，他们的身高分别为T1，T2，…，TK则他们的身高满足存在i（1<=i<=K）使得Ti

代码

这里使用动态规划求解，找到所有极大数（大于等于两边的数，只有这种数才可能是Ti），以该数为标准分别使用动态规划找到左边的最大升序数组和右边的降序数组

package level1;
import java.util.Arrays;
import java.util.Scanner;

/**
 * Created by linpeng123l on 2017/1/8.
 */
public class Chorus {

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

        int minPer = n;
        if (n > 1 && heights[0] > heights[1]) {
            minPer = count(heights, 0);
        }
        if (n > 1 && heights[n - 1] > heights[n - 2]) {
            int minPerTemp = count(heights, n - 1);
            if (minPerTemp < minPer) {
                minPer = minPerTemp;
            }
        }

        for (int i = 1; i < n - 1; i++) {
            if (heights[i] > heights[i - 1] && heights[i] >= heights[i + 1]) {
                int minPerTemp = count(heights, i);
                if (minPerTemp < minPer) {
                    minPer = minPerTemp;
                }
            }
        }
        System.out.println(minPer);
    }


    private static int count(int[] heights, int midPer) {
        //保存左边最大升序数组（第i个保存以Ti为结尾的左边最大升序数组）
        int[][] leftmaxPers = new int[midPer + 1][];
        leftmaxPers[0] = new int[]{heights[0]};
        //左边最大升序数组
        if (midPer > 0) {
            for (int i = 1; i <= midPer; i++) {
                int maxPerNum = 0;
                for (int j = 0; j < i; j++) {
                    int[] per_j = leftmaxPers[j];
                    if (per_j[per_j.length - 1] < heights[i] && maxPerNum < (per_j.length + 1)) {
                        maxPerNum = per_j.length + 1;
                        leftmaxPers[i] = Arrays.copyOf(per_j, per_j.length + 1);
                        leftmaxPers[i][maxPerNum - 1] = heights[i];
                    }
                }
                if (maxPerNum == 0) {
                    leftmaxPers[i] = new int[]{heights[i]};
                }
            }
        }

        //保存右边最大升序数组（第i个保存以Ti为结尾的右边最大升序数组）
        int[][] rightMaxPers = new int[heights.length - midPer ][];
        rightMaxPers[0] = new int[]{heights[heights.length - 1]};
        //右边最大降序数组
        if (midPer < heights.length - 1) {
            for (int i = heights.length - 2; i >= midPer; i--) {
                int maxPerNum = 0;
                for (int j = 0; j < heights.length - i - 1; j++) {
                    int[] per_j = rightMaxPers[j];
                    if (per_j[per_j.length - 1] < heights[i] && maxPerNum < (per_j.length + 1)) {
                        maxPerNum = per_j.length + 1;
                        rightMaxPers[heights.length - i - 1] = Arrays.copyOf(per_j, per_j.length + 1);
                        rightMaxPers[heights.length - i - 1][maxPerNum - 1] = heights[i];
                    }
                }
                if (maxPerNum == 0) {
                    rightMaxPers[heights.length - i - 1] = new int[]{heights[i]};
                }
            }
        }
        return heights.length - (leftmaxPers[midPer].length + rightMaxPers[heights.length - midPer - 1].length - 1);
    }

}