POJ 2479 和 POJ 2593

这两道题就是一样的题。

题目大意：

给你a1, a2 ... aN， (|ai| <=1000, 1 <= i <= N)，按照以下公式求S。

-------------------------------------------------------------我是华丽的分割线--------------------------------------------------

主要是想来练习一下动态规划，于是就做了，这是最大连续序列和的变形。一开始是绞尽脑汁也没有想出来，所以在接受了提示了以后才豁然开朗。

先总结一下动态规划的解题的步骤吧：（参考《算法导论》）

1.最优解的结构，也就是看看有没有最优的子结构，且是不是存在重复的子问题。（实施动态规划的两个基础：最优子结构、重复子问题）难点在于你怎么去看这个解，使得这个解中存在最优的子结构。

2.一个递归方程，也叫状态转移方程。

2.5 既然有了递归方程，就可以写递归的代码了，但是由于重复的子问题，算法效率低下。动态规划的一个变形就是用该算法然后备份到达的状态，当再次到达的时候就可以直接使用结果了。则这个算法即自顶向下，又有通常的动态规划的效率（实际上可以理解为搜索+剪重复的枝）。当然这步骤不是必须的。

3.由递归方程改造成一个自底向上的算法，通常比上面一个方法好一个常数因子。

关于这题呢，解题的关键在于，将所给的序列关于a[i]分成左右两个部分，左边部分的最大连续序列和，加上右边部分的最大连续序列和，对于所有的a[i]，寻找最大的那个，就一定是解了。至于怎么求连续最大序列和，网上有动态规划的算法，这里不再赘述了。（可以参考：http://blog.csdn.net/ssjhust123/article/details/8032464）

不过还要提一下，由于第一次我MAX的初始值设置的太大了，所以，导致了WA。这里要提醒自己，初始值、哨兵值设定的时候应该十分仔细的考虑！！！！！！！！

插一句：关于怎么证明算法的正确性。（参考《离散数学及其应用》）

其实就要证明算法是充分的（一般来说都是充要的，很少碰到充分但是不必要的，比如有多个解的时候，但是只要有充分性这个算法就正确了）

三种途径：

只要算法运行，得到的一定是正确解。（直接证明）

只要是非正确解，那么算法一定不会得到他。（归谬证明）

反证法。

关于怎么证明算法是错误的。

三种途径：

构造一个算法可以得到的非正确解，即举反例。（构造性证明）

证明算法得到的解集合中必定会存在某个非正确解，但是具体是那个不知道。（存在性证明）

直接证明算法的某个步骤是错误的。（直接证明）

为什么要提这个，因为我很水……在确定这个算法的正确性的时候还走了很多弯路，有必要提醒一下自己。

下面贴代码：

POJ 2479

#include <stdio.h>
#include <stdlib.h>

int max;
int *a;
int *leftSum;
int *rightSum;
int len;

int findMaxSum(){
	int i;
	int temp;
	
	leftSum[0]=a[0];
	for (i=1;i<len;i++){
	  leftSum[i]=(leftSum[i-1]>=0)?(leftSum[i-1]+a[i]):a[i];
	}
	
	for (i=1;i<len;i++){
    if (leftSum[i]<leftSum[i-1]) leftSum[i]=leftSum[i-1];
  }
	
	rightSum[len-1]=a[len-1];
	for (i=len-2;i>=0;i--){
	  rightSum[i]=(rightSum[i+1]>=0)?(rightSum[i+1]+a[i]):a[i];
	}
	
	for (i=len-2;i>=0;i--){
    if (rightSum[i]<rightSum[i+1]) rightSum[i]=rightSum[i+1];
  }

	for (i=1;i<len;i++){
	  temp=leftSum[i-1]+rightSum[i];
	  max=temp>max?temp:max;
	}
	return 0;
}

int main(){
	int T;
  int i,j;
  
  scanf("%d ",&T);
  
  for (i=0;i<T;i++){
  	scanf("%d",&len);
  	
  	a=(int *)calloc(len,sizeof(int));
  	leftSum=(int *)calloc(len,sizeof(int));
  	rightSum=(int *)calloc(len,sizeof(int));
  	
  	for (j=0;j<len;j++){
  	  scanf("%d",&(a[j]));
  	}
  	max=-10001;  //max的初始值必须足够小，小于ai的下界
  	findMaxSum();
  	
  	printf("%d\n",max);
  	
  	free(a);
  	free(leftSum);
  	free(rightSum);

  }
  return 0;
}

POJ 2593

#include <stdio.h>
#include <stdlib.h>

int max;
int *a;
int *leftSum;
int *rightSum;
int len;

int findMaxSum(){
	int i;
	int temp;
	
	leftSum[0]=a[0];
	for (i=1;i<len;i++){
	  leftSum[i]=(leftSum[i-1]>=0)?(leftSum[i-1]+a[i]):a[i];
	}
	
	for (i=1;i<len;i++){
    if (leftSum[i]<leftSum[i-1]) leftSum[i]=leftSum[i-1];
  }
	
	rightSum[len-1]=a[len-1];
	for (i=len-2;i>=0;i--){
	  rightSum[i]=(rightSum[i+1]>=0)?(rightSum[i+1]+a[i]):a[i];
	}
	
	for (i=len-2;i>=0;i--){
    if (rightSum[i]<rightSum[i+1]) rightSum[i]=rightSum[i+1];
  }

	for (i=1;i<len;i++){
	  temp=leftSum[i-1]+rightSum[i];
	  max=temp>max?temp:max;
	}
	return 0;
}

int main(){
  int i,j;
  
  while(1){
  	scanf("%d",&len);
  	
  	if (len==0) return 0;
  	
  	a=(int *)calloc(len,sizeof(int));
  	leftSum=(int *)calloc(len,sizeof(int));
  	rightSum=(int *)calloc(len,sizeof(int));
  	
  	for (j=0;j<len;j++){
  	  scanf("%d",&(a[j]));
  	}
  	
  	if (len==1)  printf("%d\n",a[0]);
  	else {  	
  	  max=-10001;  //max的初始值必须足够小，小于ai的下界
  	  findMaxSum();
  	  
  	  printf("%d\n",max);
    }
  	free(a);
  	free(leftSum);
  	free(rightSum);

  }
  return 0;
}