合唱团（动态规划）

动态规划

一、题目描述
题目链接

二、解决方案

//  注意 index 为 1 ，就是第一个同学
int[] team = new int[n + 1];

1. 敲定状态：F（i，j）表示 以第 i 个同学结尾，取 j 个同学的 最大的能力值乘积；（i <=n ; j <= k）
2. 状态方程：F（i，j）= max{ F（i，j），F（m，j - 1）* arr[ i ] } （i - d <= m <= i - 1 并且 m >= j - 1）

第 i 个同学结尾，取 j 个同学的最大能力值乘积 = 第 m 个同学（第 i - d 个同学与第 i - 1 个同学间的任意一个）结尾，取 j - 1 个同学的最大能力值的乘积；取最大值

对于 i < j 的情况不做处理，m >= j - 1 避免这种情况

3. 初始状态：F（i，1）= arr[ i ]；
4. 得到结果：遍历完成，找到最大的F（i，k）返回即可

这种解决方案仅适用于所有同学的能力值都 >= 0 的情况下
事与愿违，猪队友无处不在，防不胜防，总有同学能力值为负
如果 arr[ i ] 为负的话，此时依次再用前面的最大值F（m，j - 1） * arr[ i ]，得不到我们想要的最大值；
负负得正，如果依次用前面的最小值(可能为负) * arr[ i ]，可以得到我们想要的最大值
因此，需要同时维护两个状态

1. 状态方程：
   maxF（i，j）表示 以第 i 个同学结尾，取 j 个同学的 最大能力值乘积；（i <= n；j <= k）
   minF（i，j）表示 以第 i 个同学结尾，取 j 个同学的 最小能力值乘积；（i <= n；j <= k）
2. 状态转移方程：
   maxF（i，j）= max{ maxF（m，j - 1）* arr[ i ]，minF（m，j - 1）* arr[ i ] } （i - d <= m <= i - 1 并且 m >= j - 1）
   minF（i，j）= min{ maxF（m，j - 1）* arr[ i ]，minF（m，j - 1）* arr[ i ] } （i - d <= m <= i - 1 并且 m >= j - 1）

对于 i < j 的情况，就相当于 第2个同学结尾，取 3 个同学，这是不可能的
不作处理，同时 m >= j - 1 也是避免这种情况

3. 初始状态：
   maxF（i，1）= arr[ i ]；
   minF（i，1）= arr[ i ]；
4. 获取结果
   遍历maxF（i，k），取最大值

三、代码实现

import java.util.Scanner;

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

        int k = scanner.nextInt();
        int d = scanner.nextInt();

        long[][] maxF = new long[n + 1][k + 1];
        long[][] minF = new long[n + 1][k + 1];

        // 初始化状态
        for (int i = 1; i <= n; i++) {
            maxF[i][1] = team[i];
            minF[i][1] = team[i];
        }


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

                // 对于 i < j情况，不作处理
                if(i < j){
                 continue;
                }

                long max = Long.MIN_VALUE;
                long min = Long.MAX_VALUE;
                for (int m = i - 1; m >= i - d && m >= j - 1; m--) {
                    max = Math.max(max, Math.max(maxF[m][j - 1] * team[i], minF[m][j - 1] * team[i]));
                    min = Math.min(min, Math.min(minF[m][j - 1] * team[i], maxF[m][j - 1] * team[i]));
                }
                maxF[i][j] = max;
                minF[i][j] = min;
            }
        }

        long result = Long.MIN_VALUE;
        for (int i = 1; i <= n; i++) {
            result = Math.max(result, maxF[i][k]);
        }
        System.out.println(result);
    }
}

齐风陶韵，生态淄博

山东淄博