重拾算法->最大子数组的动归解法

public class Solution {
    
    public int maxSubArray(int[] array){
        return dpImpl(array);
    }

    private int dpImpl(int[] array){
        Result[] results=new Result[array.length+1];
        results[0]=new Result(array[0],0);
        for(int i=1;i=0){
                    results[i]=new Result(results[i-1].maxsum+temp,i);
                }else{
                    results[i]=results[i-1];
                }
            }

        }
        return results[array.length-1].maxsum;
    }
    
    //因java不支持多返回值,使用类Result代替
    static class Result{
        int maxsum;
        int endIdx;

        public Result(int maxsum, int endIdx) {
            this.maxsum = maxsum;
            this.endIdx = endIdx;
        }
    }



    private int oneLoop(int[] array){
        int idx=getNonNegativeIndex(array,0);
        if(idx==-1){
            return max(array,0);
        }
        int max=array[idx],curMax=max;
        for(int i=idx+1;imax){
                max=curMax;
            }
            if(curMax<0){
                curMax=0;
            }
        }
        return max;
    }


    private int max(int[] array,int begin){
        int max=array[begin];
        for(int i=begin;imaxSum){
                    maxSum=sum;
                }
            }
        }
        return maxSum;
    }

    private int sum(int[] array,int begin,int end){
        int sum=0;
        for(int i=begin;i<=end;i++){
            sum+=array[i];
        }
        return sum;
    }

    private int getNonNegativeIndex(int[] array,int begin){
        for(int i=begin;i=0){
                return i;
            }
        }
        return -1;
    }
}