最大m子段和问题算法进化历程

/*
  Name: 
  Copyright: 最大m子段和问题
  Author: 
  Date: 23-03-17 08:08
  Description:
【问题描述】----最大m子段和问题
给定由 n个整数（可能为负整数）组成的序列a1，a2，a3，……，an，以及一个正整数 m，要求确定序列 a1，a2，a3，……，an的 m个不相交子段，
使这m个子段的总和达到最大，求出最大和。

算法思路： 
经典的动态规划优化的问题。设f(i, j)表示前i个数划分成j段，且包括第i个数的最大m子段和，那么有dp方程：
　　　　f(i, j) = max { f(i - 1, j) + v[i], max {f(k, j - 1) + v[i]}(k = j - 1 ... i - 1) }
也就是说第i个数要么自己划到第j段，要么和前一个数一起划到第j段里面，转移是O(n)的，总复杂度O(n * n * m)。
　　
算法1：int MaxMSubSum(int i, int j);//自顶向下的备忘录算法 
设置一个备忘录数组b[M+1][N+1]，b[i][j]表示把总长度为j的序列分成i个子段后，这i个子段的总和（其中第i个子段包含元素A[j-1]）
利用原问题的递归关系，使用递归函数来求解。最后遍历b[M][j]，找出最优解。

算法2：int MaxMSubSum_2(int m, int n);//自底向上的动态规划算法  
从i=1开始，依次记录每一个b[i][j]，最后获得最大规模的b[M][N]。
和算法1一样，最后遍历b[M][j]，找出最优解。

算法3：int MaxMSubSum_3(int m, int n);//优化的动态规划算法 
是对算法2的优化，算法2中用到的备忘录数组b[M+1][N+1]占空间较大，实际上下一行数据是利用上一行的数据生成的，
与更早的数据没有关系，于是可以用两个一维数组 maxSum[N+1] 和 curSum[N+1]代替b[M+1][N+1]。

最后写了一个函数 void PrintSubQue(int m, int n); //查找第i段连续子序列的左右边界，并输出这些子序列，
该函数需要用到备忘录数组b[M+1][N+1]，故只能对算法1和算法2产生的结果有效。 
*/
#include<iostream>
#include<string>

using namespace std;

int MaxMSubSum(int i, int j);//自顶向下的备忘录算法 
int MaxMSubSum_2(int m, int n);//自底向上的动态规划算法  
int MaxMSubSum_3(int m, int n);//优化的动态规划算法  
void PrintSubQue(int m, int n); //查找第i段连续子序列的左右边界，并输出这些子序列

const int INF = -999999; //自定义的无穷小 
const int M = 3;
const int N = 7;
int A[N] = {3, -2, 1, -3, 5, 2, -4};
//int A[N] = { -2, 11, -4, 13};
int b[M+1][N+1];

int main(int argc, char **argv)
{
    for (int i=0; i<=M; i++)
    {
	 	for (int j=0; j<=N; j++)
	 		b[i][j] = INF;
	}
	
    MaxMSubSum(M, N);
   // MaxMSubSum_2(M, N);
    int max = b[M][1];
    for (int j=2; j<=N; j++)
    {
	 	if (b[M][j] > max)
	 	   max = b[M][j];
	}
    cout << max << endl;
    PrintSubQue(M, N);
    
    //max = MaxMSubSum_3(M, N);
//    cout << max << endl;
    
    system("pause");
    return 0;
}

int MaxMSubSum(int i, int j)//备忘录算法  
{  
    if (b[i][j] != INF)
       return b[i][j];
    
    if (i==0 || j==0)
    {
        b[i][j] = 0;
    }
    else
    {
	 	b[i][j] = MaxMSubSum(i, j-1) + A[j-1];
	 	for (int t=i-1; t<j; t++)
	 	{
		 	if (b[i][j] < MaxMSubSum(i-1, t) + A[j-1])
		 	   b[i][j] = MaxMSubSum(i-1, t) + A[j-1];
		}
	}
      
    return b[i][j];  
}  

int MaxMSubSum_2(int m, int n)//动态规划算法  
{  
    for (int i=0; i<=m; i++)
    	b[i][0] = 0;
    for (int j=0; j<=n; j++)
	    b[0][j] = 0; 
		
	for (int i=1; i<=m; i++)
    {
	 	for (int j=i; j<=n; j++)
	 	{
		 	b[i][j] = b[i][j-1] + A[j-1];
		 	for (int t=i-1; t<j; t++)
		 	{
			 	if (b[i][j] < b[i-1][t]+A[j-1])
			 	   b[i][j] = b[i-1][t] + A[j-1];
			}
		}
	}
	 
    return b[m][n];  
}  

int MaxMSubSum_3(int m, int n)//优化的动态规划算法  
{  
    int maxSum[N+1] = {0}; //存储到maxSum[j]为止的最大值 
    int curSum[N+1] = {0}; //存储当前处理行包含A[j]的最大连续序列和 
		
	for (int i=1; i<=m; i++)
    {
	 	for (int j=i; j<=n; j++) 
	 	{
		 	curSum[j] = curSum[j-1] + A[j-1];
		 	if (maxSum[j-1] > curSum[j-1])
		 	{
		 	    curSum[j] = maxSum[j-1] + A[j-1];  
			}   
		} 
		//更新preM[j]，为处理下一行做准备 
		maxSum[i] = curSum[i];  
		for (int j=i+1; j<=n; j++) 
	 	{
		 	maxSum[j] = (maxSum[j-1] > curSum[j]) ? maxSum[j-1] : curSum[j]; 
		}
	//	cout << i << ": ";
//		for (int j=1; j<=n; j++) 
//		    cout << maxSum[j] << " ";
//        cout << endl;
	} 
		 
    return maxSum[n];  
}  

void PrintSubQue(int m, int n)//查找第i段连续子序列的左右边界，并输出这些子序列 
{
	int L[M+1] = {0};
	int R[M+1] = {0};
	int max;
	int left, right;
	
	for (int i=m,j=n; i>0; i--,j=left-1)
	{
		max = b[i][j]; 
		right = j;
		for (int k=j; k>=i; k--) //查找第i段连续子序列和的最大值和对应右边界
		{
			if (b[i][k] > max)
			{
				max = b[i][k];
				right = k;
			}
		} 
		left = right; //查找第i段连续子序列的左边界
		while (b[i][left-1] > b[i-1][left-1] && left > 1)
		{
			left--;
		} 
		
		L[i] = left;
		R[i] = right; 
	}
	
	for (int i=1; i<=m; i++) //输出m段子序列 
	{
	 	cout << i << " : " << b[i][R[i]] << "(";
	 	for (int j=L[i]; j<=R[i]; j++)
	 	{
		 	cout << A[j-1] << ", ";
		}
		cout << ")" << endl; 
	}
}