Max Sum Plus Plus HDU - 1024

Now I think you have got an AC in Ignatius.L's "Max Sum" problem. To be a brave ACMer, we always challenge ourselves to more difficult problems. Now you are faced with a more difficult problem. 

Given a consecutive number sequence S ₁, S ₂, S ₃, S ₄ ... S _x, ... S _n (1 ≤ x ≤ n ≤ 1,000,000, -32768 ≤ S _x ≤ 32767). We define a function sum(i, j) = S _i + ... + S _j (1 ≤ i ≤ j ≤ n). 

Now given an integer m (m > 0), your task is to find m pairs of i and j which make sum(i ₁, j ₁) + sum(i ₂, j ₂) + sum(i ₃, j ₃) + ... + sum(i _m, j _m) maximal (i _x ≤ i_y ≤ j _x or i _x ≤ j _y ≤ j _x is not allowed). 

But I`m lazy, I don't want to write a special-judge module, so you don't have to output m pairs of i and j, just output the maximal summation of sum(i _x, j _x)(1 ≤ x ≤ m) instead. ^_^ 

InputEach test case will begin with two integers m and n, followed by n integers S ₁, S₂, S ₃ ... S _n. 
Process to the end of file. 
OutputOutput the maximal summation described above in one line. 
Sample Input

1 3 1 2 3
2 6 -1 4 -2 3 -2 3

Sample Output

6
8


        
  

Hint

Huge input, scanf and dynamic programming is recommended.

#include<iostream>  
#include<cstdio>  
using namespace std;  
const int MAX=1000001;  
int dp[2][MAX];  
int w[MAX];  
int sum[MAX];//不做不知道，一做嚇一跳，原來在主函數裏開個sum[MAX]，是不行的，因爲MAX是在太大！  
  
/*這是我的老師貼出的提示！現在才理解到內涵！ 
 
VC定義數組時請注意大小!定義時,局部數組大小<=1MB,全局數組<=2GB,定義時如果超過這個限制將會出現如"segment error"之類的錯誤.以下的程序可以幫助你證明這一點. 
 
以下程序數組如果再大點，運行出錯，說明局部變量分配內存<=1MB 
#include<stdio.h> 
int main() 
{ 
int a[1024*1024/4-4000]; 
int i; 
for(i=0;i<1024*1024/4-4000;i++) 
{ 
a[i]=i; 
printf("%d\n",a[i]); 
} 
return 0; 
}  
 
以下程序數組如果再大點，運行出錯，說明全局變量分配內存<=2GB 
#include<stdio.h> 
int a[1024*1024*470]; 
int main() 
{ 
long int i; 
for(i=0;i<1024*1024*470;i++) 
{ 
a[i]=i; 
printf("%d\n",a[i]); 
} 
return 0; 
} 
 
 
內存的三種分配方式：靜態存儲區分配，棧上分配，堆上分配。 全局數組是在靜態存儲區分配,而局部數組是在棧上分配,所以大小受到的限制不一樣. 
*/  
  
int cmax(int a,int b)//求最大值  
{  
    return a>b?a:b;  
}  
  
int main()  
{  
    int i,k;  
    int m,n;  
      
    while(scanf("%d%d",&m,&n)>0)  
    {  
        sum[0]=0;  
        for(i=1;i<=n;i++)  
        {  
            cin>>k;  
            sum[i]=sum[i-1]+k;//sum[i]裏存的是前i個元素的和  
            dp[0][i]=0;//從前i個元素中取0段，最大值爲0  
        }  
//我們假設a[i]中存放該序列第i個值，w[i][k]表示前k個數分爲i段，第k個數必須選這種情況下取得的最大值  
//b[i][k]表示在前k個數中取i段這種情況下取得的最大值  
  
//w[i][k]：前k個數分爲i段，第k個數必須選；1：第k個數單獨爲1段；2：第k個數與前面的數連一塊。w[i][k]=max(b[i-1][k-1],w[i][k-1])+a[k];  
//b[i][k]：前k個數分爲i段，第k個數可選可不選；1：選第k個數，2：不選第k個數。b[i][k]=max(b[i][k-1],w[i][k])  
//w[i][k]=max(b[i-1][k-1],w[i][k-1])+a[k];  
//b[i][k]=max(b[i][k-1],w[i][k])；  
//w[i][k],b[i][i]容易求得，所以由b[i-1][k-1]->w[i][k]->b[i][k],只要知道b[0][k]，全部都能成功運行！  
  
//當從k個元素中取j段，可以分爲兩種情況，即第k個元素可以取，也可以不取，取，那麼a[k]要麼是單獨爲一段b[i-1][k-1]+a[k];  
//要麼是第k個數與前面的數連一塊，即w[i][k-1]+a[k]，故w[i][k]=max(b[i-1][k-1],w[i][k-1])+a[k];  
  
//要麼不取 即b[i][k]=b[i][k-1];  
//綜合起來，b[i][k]=max(b[i][k-1],w[i][k])；  
       int t=1;  
       for(i=1;i<=m;i++)//i表示在取i段,自然i<=m;  
       {  
             
           for(k=i;k<=n;k++)//爲什麼k從i開始？dp[i][k](k<i)是沒有意義的！  
           {  
               if(i==k)  
               dp[t][k]=w[k]=sum[k];//從k個數中取k段的最大值是前k個數的和  
               else  
               {  
                   w[k]=cmax(dp[1-t][k-1],w[k-1])+sum[k]-sum[k-1];//w[k]表示k個元素取i段，a[k]必須取時的最大值  
        //w[i][k]=max(b[i-1][k-1],w[i][k-1])+a[k];  
                   dp[t][k]=cmax(dp[t][k-1],w[k]);//dp[t][k]表示在a[k]可取可不取這兩種情況下取得的最大值  
                   //自然，dp[t][k]記錄的就是在前k個元素中取i段時取得的最大值！  
               }  
           }  
           t=1-t;//t在1,0之間交替變換  
  //爲什麼要交替呢？這是爲了節省空間  
  //仔細觀察遞歸式  
  //w[i][k]=max(b[i-1][k-1],w[i][k-1])+a[k];  
  //b[i][k]=max(b[i][k-1],w[i][k])；  
  //我們發現，對於取i段，w[i][j]只與b[i-1][k-1]和w[i][k-1]有關，與之前的那一些項沒有關係  
  //因此我們數組可以開小一點，用更新來覆蓋掉前面的值！  
       }  
       cout<<dp[m%2][n]<<endl;//奇次輪還是偶次輪  
  
    }  
    system("pause");  
    return 0;  
}  

本題的大致意思爲給定一個數組，求其分成m個不相交子段和最大值的問題。
設Num爲給定數組，n爲數組中的元素總數，Status[i][j]表示前i個數在選取第i個數的前提下分成j段的最大值，其中1<=j<=i<=n && j<=m，狀態轉移方程爲：
Status[i][j]=Max(Status[i-1][j]+Num[i]，Max(Status[0][j-1]~Status[i-1][j-1])+Num[i])
乍看一下這個方程挺嚇人的，因爲題中n的限定範圍爲1~1,000,000而m得限定範圍沒有給出，m只要稍微大一點就會爆內存。但仔細分析後就會發現Status[i][j]的求解只和Status[*][j]與Status[*][j-1]有關所以本題只需要兩個一維數組即可搞定狀態轉移。
在進行更進一步的分析還會發現其實Max(Status[0][j-1]~Status[i-1][j-1])根本不需要單獨求取。在求取now_Status（保存本次狀態的數組）的過程中即可對pre_Status（保存前一次狀態的數組）進行同步更新。
 
 
狀態dp[i][j]
有前j個數，組成i組的和的最大值。
決策： 第j個數，是在第包含在第i組裏面，還是自己獨立成組。
方程 dp[i][j]=Max(dp[i][j-1]+a[j] , max( dp[i-1][k] ) + a[j] ) 0<k<j
空間複雜度，m未知，n<=1000000，  繼續滾動數組。
時間複雜度 n^3. n<=1000000.  顯然會超時，繼續優化。
max( dp[i-1][k] ) 就是上一組 0....j-1 的最大值。我們可以在每次計算dp[i][j]的時候記錄下前j個
的最大值 用數組保存下來  下次計算的時候可以用，這樣時間複雜度爲 n^2.
複製代碼
/*
狀態dp[i][j]有前j個數，組成i組的和的最大值。決策： 
第j個數，是在第包含在第i組裏面，還是自己獨立成組。
方程 dp[i][j]=Max(dp[i][j-1]+a[j] , max( dp[i-1][k] ) + a[j] ) 0<k<j
空間複雜度，m未知，n<=1000000，  繼續滾動數組。 
時間複雜度 n^3. n<=1000000.  顯然會超時，繼續優化。
max( dp[i-1][k] ) 就是上一組 0....j-1 的最大值。
我們可以在每次計算dp[i][j]的時候記錄下前j個的最大值 
用數組保存下來  下次計算的時候可以用，這樣時間複雜度爲 n^2.
*/

#include<stdio.h>
#include<algorithm>
#include<iostream>
using namespace std;
#define MAXN 1000000
#define INF 0x7fffffff
int dp[MAXN+10];
int mmax[MAXN+10];
int a[MAXN+10];
int main()
{
    int n,m;
    int i,j,mmmax;
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        for(i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            mmax[i]=0;
            dp[i]=0;
        }
        dp[0]=0;
        mmax[0]=0;    
        for(i=1;i<=m;i++)
        {
                mmmax=-INF;
                for(j=i;j<=n;j++)
                {
                    dp[j]=max(dp[j-1]+a[j],mmax[j-1]+a[j]);
                    mmax[j-1]=mmmax;
                    mmmax=max(mmmax,dp[j]);
                }    
        }  
        printf("%d\n",mmmax);  
          
    } 
    return 0;   
}