最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

法一：判断法。

class Solution {
    public int maxSubArray(int[] nums) {
        int i=0;int j=0;
        int max=nums[0];int sum=0;int sum2=0; int sta=0; i
//若开头是一个或者一串内容为0或者负数的东西，选择其中最大的即可。
        for(i=0;i<nums.length;i++ )
            if(nums[i]<=0){
                if(nums[i]>max)
            max=nums[i];
            }else{
                break;
            }
 //遇到第一个正数，开始核心代码。
            for(int z=i;z<nums.length;z++){
//整个数组中负数后第一个正数，与后面的某几个值相加成和，最大和仅仅可能出现在这种情况下。所以从每个负数后第一个正数开始，求和。
            if(nums[z]>0){
//求和过程：一直是正数时，状态值sta为0，一直累加求和sum就是了，直到遇到负数，进入判断模式，此时状态值1。判断模式下开始求判断和sum2，判断和sum2是判断模式下看值累加是否为正数，一旦sum2成为正数，则sum2的值加入sum中。若一直到数组结束sum2都为负数，则就不要把sum2加进去了。
            for(j=z;j<nums.length;j++){
                if(sta==0){
                if(nums[j]>0){
                   sum+=nums[j];
                }
                if(nums[j]<0){
                   // i=j-1;
                   // max=sum;
                    sum2+=nums[j];
                    sta=1;
                    continue;
                }
                }
               
                if(sta==1){
                        sum2+=nums[j];
                        if(sum2>0){
                            sta=0;
                            sum+=sum2;
                             sum2=0;
                            
                        }
                    
                }
            }
//每次以每个头正数开始的累加结束，都会判断是否更新max。
            if(max<sum)max=sum;
            sum=0;sum2=0;sta=0;
            }
        }
    
        return max;
    }
}

法二：经典动态规划

数组dp保存每个位置i对应的自己与之前元素的累加和。但如果自己与之前元素的累加和要比直接写自己来得小的话，干嘛不直接写自己，于是抛弃之前的累赘累加和，直接将自己写入dp[i]。接着更新max。

class Solution {
    public int maxSubArray(int[] nums) {
        int[] dp=new int[nums.length];
        dp[0]=nums[0];
        int max=nums[0];
       for(int i=1;i<nums.length;i++){
    dp[i]=Math.max(dp[i-1]+nums[i],nums[i]);
    max=Math.max(max,dp[i]);
       }
       return max;
    }}