smp 1131 数字乘积【 动归or递归】

数字乘积
Description
让数组S存放数字串，如S[]={3,2,1,5,1,2,5}现要求插入k(=3)个乘号,使乘积最大。
Input
输入有若干行，每行一个数字串（不超过10位）和插入乘号的个数k。
Ouput
对应输出最大的乘积。
Sample Input
3215125 3
123 1
Sample Output
163710
36

方法1：动态规划

以第一组数据“3215125 3”为例分析：

第一步先把所有能够当做因子的数提取出来，放到数组a[i][j]。

行\列	0	1	2	3	4	5	6
0	3	32	321	3215	32151	321512	3215125
1		2	21	215	2151	21512	215125
2			1	15	151	1512	15125
3				5	51	512	5125
4					1	12	125
5						2	25
6							5

然后建立dp数组，因为要插入3个乘号，即意味着4个数相乘，所以第0行填入第1个数的所有可能

i\j	0	1	2	3	4	5	6
0	3	32	321	3215	32151	321512	3215125
1
2
3

接下来第1行模拟第1个数和第2个数相乘:
d[1][2]有1种可能，3 * 2=6；
d[1][2]有2种可能，3* 21=63,32* 1=6；
d[1][3]有3种可能，3* 215=645,32* 15=480,321* 5=1605;
·····
筛选每种可能的最大值；
以d[1][3]为例，可以发现,每种可能的第一个因子，可以表示为d[0][0],d[0][1],d[0][2]
第二个因子可以表示为a[1][3],a[2][3],a[3][3];
即d[1][3]=max{d[0][0]*a[1][3],d[0][1]*a[2][3]，d[0][2]*a[3][3]}；

把第一相乘的结果到表格里：

i\j	0	1	2	3	4	5	6
0	3	32	321	3215	32151	321512	3215125
1		6	63	1605	16371	1645125	1645125
2
3

现在模拟第二次相乘：
d[2][2]有1种可能，6* 1=6；
d[2][2]有2种可能，6* 15=90，63* 5=315；
d[3][3]有3种可能，6* 151=906，63* 51=3213，1605*1=1605；
·····
同样筛选出每种可能的最大值；

i\j	0	1	2	3	4	5	6
0	3	32	321	3215	32151	321512	3215125
1	0	6	63	1605	16371	1645125	1645125
2	0	0	6	315	3213	32742	821760
3

现在模拟第三次相乘：
d[3][3]有1种可能，6* 5=30；
d[3][4]有2种可能，6* 51=306，315* 1=315；
······
得：d[3][3]=d[2][2]*a[3][3];
d[3][4]=max{d[2][3]*a[3][4],d[]}

i\j	0	1	2	3	4	5	6
0	3	32	321	3215	32151	321512	3215125
1	0	6	63	1605	16371	1645125	1645125
2	0	0	6	315	3213	32742	821760
3	0	0	0	30	315	6426	163710

代码

#include<iostream>
#include<string>
#include<sstream>
#include<algorithm>
#include<cstring>
using namespace std;
int work(int i,int j,string s)
{
	s=s.substr(i,j);
	
	 stringstream ss;
  	 ss<<s;
 
  	  int ans;
  	  ss>>ans;
  	  
	return ans;
}
int main()
{
	string s;
	int m,k,a[20][20],dp[20][20];
	int id;
	
	while(cin>>s>>k)
	{
		memset(a,0,sizeof(a));
		memset(dp,0,sizeof(dp));
		
		int n=s.size();
		for(int i=0;i<s.size();i++)
		{
			id=1;
			for(int j=i;j<s.size();j++)
			{
				a[i][j]=work(i,id,s);
				id++;
			}
		}
		
		
		for(int j=0;j<=n;j++)
		{
			dp[0][j]=a[0][j];
		}
		
		for(int i=1;i<=k;i++)
		{
			for(int j=i;j<=n;j++)
			{
				for(int t=0;t<=j;t++)
				{
					dp[i][j]=max(dp[i][j],dp[i-1][t]*a[t+1][j]);
				}
			}
		}
	}
	
		cout<<dp[k][n-1]<<endl;	
	}
}

或者

#include<iostream>
#include<string>
#include<cmath>
#include<algorithm>
using namespace std;
int dp[100][100];    //前 i 位数包含 j 个乘号所能达到的最大乘积
int a[100],sum;
int total(int t,int b)
{
	int i;
	sum=0;
	for(i=t;i<=b;i++)
	{
		sum=sum*10+a[i];
	}
	return sum;
}
int max(int t,int b)
{
	if(t>b)
	{
		return t;
	}
	return b;
}
int main()
{
	int k,n,i,j,d;
	string s;
	while(cin>>s>>k)
	{
		n=s.size();
		memset(a,0,sizeof(a));
		memset(dp,0,sizeof(dp));
		for(i=1;i<=n;i++)
		{
			a[i]=s[i-1]-'0';    //将字符串转换为整型数组
		}
		for(i=1;i<=n;i++)
		{
			dp[i][0]=total(1,i);
		}
		for(i=2;i<=n;i++)   //枚举分割为前i位数字，因为从下标1开始，所以从下标为2（即第二个数字）开始分割
		{
			for(j=1;j<=k;j++)    //枚举有几个乘号,从1到3枚举，表示前i位中含有j个乘号
			{
				for(d=j;d<i;d++)    //在第几位放乘号，从j到i-1进行一次枚举，表示前i位中含有j个乘号，且最后一个乘号的位置在 d 处。那么当最后一个乘号在 d 处时最大值为前 d 位中含有 j - 1 个乘号的最大值乘上 d 处之后的数字
				{
					dp[i][j]=max(dp[i][j],dp[d][j-1]*total(d+1,i));
				}
			}
		}
		cout<<dp[n][k]<<endl;
	}
	return 0;
}

方法2：递归

#include<iostream>
#include<cstdlib>
#include<cstring>
#include<cmath>
using namespace std;
int num[11][11];
int fun(int sta,int end,int k)
{
	int i,max=0,sum;
	if(k==0)
		return num[sta][end];
	else
	{
		for(i=0;i<=end-k;i++)
		{
			sum=num[sta][i]*fun(i+1,end,k-1);
			if(sum>max)
				max=sum;
		}
	}
	return max;
}
int main()
{
	char str[11];
	int k,i,j;
	while(cin>>str>>k)
	{
		memset(num,0,sizeof(num));
		int n=strlen(str)-1;
		int m=atoi(str);
		int s=pow(10,n);
		num[0][n]=m;
		for(i=1;i<=n;i++)
		{
			num[i][n]=num[i-1][n]%s;
			s/=10;
		}
		for(j=n-1;j>=0;j--)
			for(i=0;i<=n;i++)
				num[i][j]=num[i][j+1]/10;
		cout<<fun(0,n,k)<<endl;
	}
	return 0;
}