【算法导论】最大子数组问题（递归+迭代）

最大子数组问题。首先考虑习题4-15，要求迭代实现，线性复杂度，首先直接上代码：

import java.lang.reflect.Array;
import java.util.Arrays;

public class MSubArray {
    public static void main(String[] args){
        int[] A={12,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22,15,-488,7};
        int[] dp=new int[17];
        dp[0]=0;
        boolean flag=false;
        int sum=0,i=1,s=0,e=0;
        for(int j=1;j<17;j++){
            if(A[j-1]>0)
                flag=true;
            if(A[i-1]<0)
                i=j;
            sum+=A[j-1];
            if(sum>dp[j-1])
                {s=i;
                e=j;
                }
            else if(sum<0)
                {i=j;
                sum=0;
                }
            dp[j]=Math.max(dp[j-1], sum);
        }
        if(!flag)
        {
            Arrays.sort(A);
            System.out.println(A[A.length-1]);
        }
    }
}

（人比较懒，直接写成了main，数组也用了现成的）

思路如下：
采用动态规划，dp[j]表示A（1…j）的最大子数组和，则根据题中提示可得出直观的式子：
dp[j]=max(dp[j-1],sum(A[i…j]));

其中sum为A[i…j]的和，显然求出i（买入点，即最大sum的最左下标）是关键。假设数组A不全是负数（若是则直接返回最大值）。首先i和j都初始化为1（表示第一个数，对应的数组下标为j-1），每次j移动一步，因此求sum时只要加上A[j]即可。现在考虑sum为负数的情况，由于我们要求最大值，则出现负数说明A[j]之前的所有值应当全部丢弃！也就是i=j。这里用股票的实例来理解也很好，sum为负则说明出现了新的最低点，我们要达到的就是最低点买入，肯定要把i挪过来。既然已经把之前的值全部丢弃了，此时应将sum值重新置0，重新计算子数组之和。

这里有一个细节，sum并非一定是最大的和，因为可能出现比较小的负值导致求和后sum仍旧大于0，因此可以把sum看作一个模糊的中间变量，即可能出现负值、中间值或最大值，其中我们只对负值和最大值感兴趣。dp数组中存的才是真正的最大值，sum加了一个小负数后一定比dp小，因此不会被选择。

经过上述过程的迭代，dp[A.length]就是最大子数组之和了。但我们还要求上下界（哪天买入，哪天卖出），首先可能很自然地觉得i就是下界，但分析迭代过程发现i指向的其实就是最低点，而不是我们想要的那个下界。刚刚找到了最大子数组后，i的值的确是这个下界，但加入数组最后一个值非常小（-1000）,sum值变负数，i就又被挪过去了，此时它就在一个无意义的位置。因此需要两个额外的变量s和e来记录起始下标，它们出现在sum改变了dp值时，此时s=i，e=j。这时再仔细想想，i有没有可能指向了一个负值？答案是有！sum为负时我们令i=j，而这时A[j]就是负值！但显然我们的最大子数组不可能以一个负数开头，因此加入了判断 if(A[i-1]<0) i=j; 把i挪到正数下标处，这时s=i才是真正的开始端。复杂度O（n）。

下面实现递归法。由于书上已经给出了思路和伪代码，用分治法实现，因此直接把java实现写出来了：

public class MSubArrayD {
    public static int[] findMaxCrossingSub(int[] A,int low,int mid,int high){
        int left=Integer.MIN_VALUE,right=Integer.MIN_VALUE;
        int sum=0,max_left=0,max_right=0;
        for(int i=mid;i>=low;i--){
            sum+=A[i];
            if(sum>left)
                {left=sum;
                max_left=i;
                }
        }
        sum=0;
        for(int j=mid+1;j<=high;j++){
            sum+=A[j];
            if(sum>right){
                right=sum;
                max_right=j;
            }
        }
        int[] result=new int[3];
        result[0]=max_left;
        result[1]=max_right;
        result[2]=left+right;
        return result;
    }

    public static int[] findMaxSub(int[] A,int low,int high){
        int[] result=new int[3];
        if(high==low)
            {
            result[0]=result[1]=low;
            result[2]=A[low];
            return result;
            }
        else{
            int mid=(low+high)/2;
            int[] left=findMaxSub(A,low,mid);
            int[] right=findMaxSub(A,mid+1,high);
            int[] cross=findMaxCrossingSub(A,low,mid,high);
            if(left[2]>=right[2] && left[2]>=cross[2])
                return left;
            if(right[2]>=left[2] && right[2]>=cross[2])
                return right;
            return cross;
        }
    }
    public static void main(String[] args){
        int[] A={12,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22,15,-488,7};

        System.out.println(findMaxSub(A,0,A.length-1)[0]+" "+findMaxSub(A,0,A.length-1)[1]+" "+findMaxSub(A,0,A.length-1)[2]);
    }

}

一天一个算法吃透就好了。。要求不算高。。加油。。