蓝桥杯 ALGO-116 最大的算式

  算法训练 最大的算式  

时间限制：1.0s   内存限制：256.0MB

    

问题描述

　　题目很简单，给出N个数字，不改变它们的相对位置，在中间加入K个乘号和N-K-1个加号，（括号随便加）使最终结果尽量大。因为乘号和加号一共就是N-1个了，所以恰好每两个相邻数字之间都有一个符号。例如：
　　N=5，K=2，5个数字分别为1、2、3、4、5，可以加成：
　　1*2*(3+4+5)=24
　　1*(2+3)*(4+5)=45
　　(1*2+3)*(4+5)=45
　　……

输入格式

　　输入文件共有二行，第一行为两个有空格隔开的整数，表示N和K，其中（2<=N<=15, 0<=K<=N-1）。第二行为 N个用空格隔开的数字（每个数字在0到9之间）。

输出格式

　　输出文件仅一行包含一个整数，表示要求的最大的结果

样例输入

5 2
1 2 3 4 5

样例输出

120

样例说明

　　(1+2+3)*4*5=120

分析：题目给的样例是一个单增数列，在分析时可能会陷入误区。这里我们分析一组非单增数列[3,4,1,2]。

当K = 0时，由于没有乘号，所以随着N的增加，所获得的最大值分别为[3,7,8,10]，即数列的累加和。

当K = 1时，N = 1时，最大值为0（K > N - 1）;N = 2时，仅有一个乘号，最大值为前两个数相乘之积12；N = 3时，存在（3 + 4）* 1与3 *（4 + 1）两种选择，选后者15；N = 4时，存在（3 + 4 + 1）* 2，（3 + 4）*（1 + 2），3 *（4 + 1 + 2）等选择，选（3 + 4）*（1 + 2）= 21。

从这里我们可以看出，所得的结果为某序列累积和 * 某序列累积和的形式。由于数字的相对位置不变，序列实际上是给定序列的子序列。

进一步分析。当K = 2时， N = 3， 我们获得的最大值为3 * 4 * 1 = 12；N = 4， 我们获得的最大值为3 * 4 *（1 + 2）= 36。

为了便于分析，我们将N, K时的最大值标记为dp[N][K]，将原始序列前i项的累积和标记为sum[i]。如此，我们可以将原始结果改写，如dp[4][1] = max(dp[3][0] * (sum[4] - sum[3]), dp[2][0] * (sum[4] - sum[2]), dp[1][0] * (sum[4] - sum[2]), ……)，dp[4][2] = max(dp[2][1] * (sum[4] - sum[2]), dp[3][1] * (sum[4] - sum[3]), ……)。

可以看出，每一个dp[N][K]项实际上是分为两部分相乘组成：dp[i][K - 1]与sum[N] - sum[i](i < N)。由此可以列出递推公式了。最后输出dp[N][K]即可。

代码：

#include<iostream>
#include<algorithm>
using namespace std;
long long dp[20][20] = { 0 };
long long a[20] = { 0 };
long long sum[20] = { 0 };
int main() {
	int N, K;
	cin >> N >> K;
	for (int i = 1; i <= N; i++) {
		cin >> a[i];
	}
	dp[1][0] = a[1];
	sum[1] = a[1];
	for (int i = 2; i <= N; i++) {
		dp[i][0] = dp[i - 1][0] + a[i];
		sum[i] = sum[i - 1] + a[i];
	}
	for (int i = 1; i <= K; i++) {
		for (int j = i + 1; j <= N; j++) {
			for (int k = i; k < j; k++) {
				dp[j][i] = max(dp[j][i], dp[k][i - 1] * (sum[j] - sum[k]));
			}
		}
	}
	cout << dp[N][K] << endl;
	return 0;
}