网易2017年合唱团

做题经验：
对于一个复杂的题，若是附加条件太多，不能一步到位的解决，可以逐渐的减少附加条件，也就是逐渐的减少参数，等有思路了，再把参数添加进去。

对于这题，作者就是这么想的，一开始，把附加条件d去掉，就是一个很典型的DP问题，然后建模， 递归实现，DP算法实现，最后再把d添加进去。

一、递归实现

这里需要提醒的是，因为能力值有正有负，在下一个值不知道正负性的情况下，是不能确定应该返回哪一个值的，很可能这一次的最小值乘以负数就变成最大值了。
因此不是每次返回一个值，而是每次返回两个值。一个最大值，一个最小值。

import sys

n =  36
ability = [7,-15,31,49,-44,35,44,-47,-23,15,-11,10,-21,10,-13,0,-20,-36,22,-13,-39,-39,-31,-13,-27,-43,-6,40,5,-47,35,-8,24,-31,-24,-1]
k,d = 2, 31

def chorus(n, ability, k):
    if k == 1:
        return [max(ability),min(ability)]
    if k == n:
        result = 1
        for i in range(n):
            result = result * ability[i]
        return [result,result]

    #选中最后一个同学，会得到最大值与最小值
    last_list = chorus(n-1,ability[0:n-1],k-1)
    #未选中最后一个同学，得到最大值与最小值
    no_last_list = chorus(n-1,ability[0:n-1],k)
    #不能认为，index为0的就是max，因为ability[-1]的不确定性，所以可能会不断改变
    #因此需要再每一步都判断一下，得到最大或最小值
    return [max(last_list[0]*ability[-1],
                last_list[1]*ability[-1],
                max(no_last_list)),
            min(last_list[0] * ability[-1],
                last_list[1] * ability[-1],
                min(no_last_list))]

print(chorus(n, ability, k))

二、DP实现（不加d）

这里因为只有两个参数，n和k，分析状态转移方程，可以知道，k一定时，f[k][n_id]的每个状态都可以由k-1的每个状态决定，因此这里只需要维护两个一维数组即可。

代码实现：

n =  36
ability = [7,-15,31,49,-44,35,44,-47,-23,15,-11,10,-21,10,-13,0,-20,-36,22,-13,-39,-39,-31,-13,-27,-43,-6,40,5,-47,35,-8,24,-31,-24,-1]
k,d = 3, 31


def chorus(n, ability, k):
    pre_res_max = []
    pre_res_min = []
    if k == 1:
        return max(ability)
    else:
        for i in range(n):
            pre_res_max.append(max(ability[0:i+1]))
            pre_res_min.append(min(ability[0:i+1]))


    for k_id in range(2,k+1):
        after_res_max = []
        after_res_min = []
        for n_id in range(n):
            if k_id > n_id:
                res = 1
                for i in range(n_id+1):
                    res = res * ability[i]
                after_res_max.append(res)
                after_res_min.append(res)
            else:
                #对于这一点尤其要注意，用哪个元素，千万不能错了。
                #这里要是用n_id，就是49*49了，元素就重复了。
                max1 = pre_res_max[n_id-1]*ability[n_id]
                min1 = pre_res_min[n_id-1] * ability[n_id]
                max2 = after_res_max[n_id-1]
                min2 = after_res_min[n_id-1]
                result_list = [max1,max2,min1,min2]
                after_res_max.append(max(result_list))
                after_res_min.append(min(result_list))

        pre_res_max = after_res_max
        pre_res_min = after_res_min


    return max(pre_res_max)

print(chorus(n, ability, k))

三、DP实现（加d）

因为这里有三个参数n,k,d，需要好好定义一下需要保存的数组。

f[k][i]代表的是，选择k个学生并且以第i个学生作为结尾时的最大（或最小）乘积。

如何定义需要保存的数组，也是一门玄学？

基本上，是根据动态转移方程中的参数的值，来确定需要保存的东西。
比如国王与金矿问题中，下一行的某个状态，由上一行的某两个状态决定，因为需要维护一个一维数组，用来保存上一行的最优值。
然而在LeetCode第62题中，因为状态转移方程是dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，当前状态由上一行的第j列与当前行的前一个决定，所以只需要保存两个数据即可。

要根据状态转移方程确定需要保存的东西。

因此在k等于1时，初始化数组时，需要注意初始化的正确性。

建模分析

根据f[k][i]的定义，我们可以得到最优子结构与状态转移方程。
一定要举例说明

• 1、例如f[3][6]，已经选择第7个同学作为结尾，那么ability的第7个值就作为乘积，若是前一个同学选择第6个，那么就是f[2][5] * ability[6]，这是其中一个最优子结构，同理，若是倒数第二个同学是第5个，那么就是f[2][4] * ability[6]。

• 2、理论上，对于n_id，有n_id-1个子结构。因此应该在range(0,n_id)中遍历每个序号作为倒数第二个同学，在遍历的就结果中选择最大最小值。

• 3、又因为这里加了限制，倒数第二个同学的编号与最后一个编号不能超过d。
  于是，修改循环的取值，若n_id大于d，则从0开始，小于d就从 n_id - d开始
  改为range(max(0, n_id - d), n_id)。
  这里真的是根据题意得到的一个小技巧。

代码实现：

n = int(input())
ability = [int(x) for x in input().split()]
k, d = [int(x) for x in input().split()]


def chorus_dp2(n,ability,k,d):
    # 初始化两个数组，分别存储最大值最小值
    # 其中，f[k][i]代表的是，选择k个学生并且以第i个学生作为结尾时的最大（或最小）乘积
    f_max = []
    f_min = []
    for k_id in range(k):
        f_max.append([])
        f_min.append([])
        for n_id in range(n):
            if k_id == 0:
                #在k等于1 的时候，根据f[k][i]的定义可知，第i个值就应该是ability[i]
                f_max[k_id].append(ability[n_id])
                f_min[k_id].append(ability[n_id])
            else:
                f_max[k_id].append(0)
                f_min[k_id].append(0)

    for k_id in range(1,k):
            res_mid_max = []
            res_mid_min = []
            for j in range(max(0, n_id - d), n_id):
                res_mid_max.append(max(f_max[k_id-1][j] * ability[n_id],
                                       f_min[k_id-1][j] * ability[n_id]))
                res_mid_min.append(min(f_max[k_id-1][j] * ability[n_id],
                                       f_min[k_id-1][j] * ability[n_id]))
            f_max[k_id][n_id] = max(res_mid_max)
            f_min[k_id][n_id] = min(res_mid_min)

    return f_max

print(max(chorus_dp2(n,ability,k,d)[k-1]))


#这段代码并没有考虑k等于n的情况。有bug。
#题目中也没有给k大于n时应该怎么办，是不是允许重复的。题目这一点也出的不好。