合唱团

题目：

有 n 个学生站成一排，每个学生有一个能力值，牛牛想从这 n 个学生中按照顺序选取 k 名学生，要求相邻两个学生的位置编号的差不超过 d，使得这 k 个学生的能力值的乘积最大，你能返回最大的乘积吗？
输入描述:
每个输入包含 1 个测试用例。每个测试数据的第一行包含一个整数 n (1 <= n <= 50)，表示学生的个数，接下来的一行，包含 n 个整数，按顺序表示每个学生的能力值 ai（-50 <= ai <= 50）。接下来的一行包含两个整数，k 和 d (1 <= k <= 10, 1 <= d <= 50)。
输出描述:
输出一行表示最大的乘积。
示例1
输入

3
7 4 7
2 50

输出

49

程序：

方法一：

递归，AC（80%），需要采用动态规划记录中间过程，递归超时

#include<iostream>
#include<vector>
#include<climits>

using namespace std;

long max_val=INT_MIN;


void solve(vector<int> &v,vector<int> &temp,int n,int k,int d,int index,int beg,long m_val)
{
    if(index==k)
    {
        //long val=1;
        //for(int i=0;i<temp.size();i++)
        //    val*=temp[i];
        if(m_val>max_val)
            max_val=m_val;
        return;
    }

    if(index==0)
    {
        for(int i=0;i<n-k+1;i++)
        {
            //temp.push_back(v[i]);
            solve(v,temp,n,k,d,index+1,i+1,m_val*v[i]);
            //temp.pop_back();
        }
    }
    else
    {
        for(int i=beg;i<n&&i<(beg+d);i++)
        {
           // temp.push_back(v[i]);
            solve(v,temp,n,k,d,index+1,i+1,m_val*v[i]);
           // temp.pop_back();
        }
    }
}

int main()
{
    int n;
    cin>>n;
    vector<int> input(n,0);
    for(int i=0;i<n;i++)
        cin>>input[i];
    int k,d;
    cin>>k>>d;
    vector<int> temp;
    long m_val=1;
    solve(input,temp,n,k,d,0,0,m_val);
    cout<<max_val<<endl;
    return 0;

}

方法二：

动态规划

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
    int n;
    while (cin >> n){
        vector<int> a(n);
        for (int i = 0; i < n; i++){
            cin >> a[i];
        }
        int k, d;
        cin >> k >> d;
        vector<vector<long long>> dp_max(n, vector<long long>(k + 1, 0));
        vector<vector<long long>> dp_min(n, vector<long long>(k + 1, 0));
        for (int i = 0; i < n; i++){
            dp_max[i][1] = a[i];
            dp_min[i][1] = a[i];
        }
        for (int i = 0; i < n; i++){
            for (int j = 2; j <= k; j++){
                for (int m = max(0, i - d); m <= i - 1; m++){
                    dp_max[i][j] = max(dp_max[i][j], max(dp_max[m][j - 1] * a[i], dp_min[m][j - 1] * a[i]));
                    dp_min[i][j] = min(dp_min[i][j], min(dp_min[m][j - 1] * a[i], dp_max[m][j - 1] * a[i]));
                }
            }
        }
        long long max_value = dp_max[k - 1][k];
        for (int i = k; i < n; i++){
            max_value = max(max_value, dp_max[i][k]);
        }
        cout << max_value << endl;
    }
    return 0;
}

点评：

此类问题属于最优化问题往往需要dp数组来存储中间过程，难点在于如何设计合理的动态数组以及正确写出状态方程