Maximum Subarray leetcode java

タイトル:
Find the contiguous subarray within an array (containing at least one number) which has the largest sum.
For example, given the array [−2,1,−3,4,−1,2,1,−5,4] , the contiguous subarray [4,−1,2,1] has the largest sum = 6 .
 
More practice:
If you have figured out the O(n) solution, try coding another solution using the divide and conquer approach, which is more subtle
 
 
問題:
この問題は連続的な配列値を求め,加算と最大を要求する.
考えてみてください.もし私たちがこの配列を最初から遍歴したら.配列内の要素の1つについては、2つの選択肢しかありません.
 1. 前の配列と加算するか(他の人とグループ)
 2. 自分で配列を立てるか(自分でグループを開くか)
だからこの要素をどのように選択すべきかは、彼がどのグループに貢献できるかによって決まります.もし他の人と一組になったら、総加和を大きくすることができて、やはり他の人と一組になったほうがいいです.もし自分が1組始めて、自分の値が前の加算値よりも大きいならば、やはり自分で1組だけ開いたほうがいいです.
したがって、1つのsum配列を用いて、各ラウンドのsumの最大値を記録し、sum[i]は現在の要素が前の配列と1つのグループを加算するか、それとも自分で1つのグループを立てるかを示し、グローバル最大値の即位答えを維持する.
 
コードは以下の通りです.
 1     
public 
int maxSubArray(
int[] A) {
 2         
int[] sum = 
new 
int[A.length];
 3         
 4         
int max = A[0];
 5         sum[0] = A[0];
 6  
 7         
for (
int i = 1; i < A.length; i++) {
 8             sum[i] = Math.max(A[i], sum[i - 1] + A[i]);
 9             max = Math.max(max, sum[i]);
10         }
11  
12         
return max;
13     }
 
 
同時に、この問題は経典の問題で、1977ブラウンの教授が提出したことを発見した.
http://en.wikipedia.org/wiki/Maximum_subarray_problem
 
そして,この問題には2つの古典的解法があり,1つはKadaneアルゴリズム,アルゴリズム複雑度O(n);もう1つは,アルゴリズムの複雑さがO(nlogn)である分治法である.
1.Kadaneアルゴリズム
コードは次のとおりです.
 1     
public 
int maxSubArray(
int[] A) {
 2         
int max_ending_here = 0;
 3         
int max_so_far = Integer.MIN_VALUE;
 4         
 5         
for(
int i = 0; i < A.length; i++){  
 6             
if(max_ending_here < 0) 
 7                  max_ending_here = 0;  
 8             max_ending_here += A[i];  
 9             max_so_far = Math.max(max_so_far, max_ending_here);   
10         }  
11         
return max_so_far; 
12     }
 
 2. 分治法:
コードは次のとおりです.
 1     
public 
int maxSubArray(
int[] A) {
 2          
return divide(A, 0, A.length-1); 
 3     }
 4     
 5   
public 
int divide(
int A[], 
int low, 
int high){  
 6         
if(low == high)
 7             
return A[low];  
 8         
if(low == high-1)  
 9             
return Math.max(A[low]+A[high], Math.max(A[low], A[high]));
10             
11         
int mid = (low+high)/2;  
12         
int lmax = divide(A, low, mid-1);  
13         
int rmax = divide(A, mid+1, high); 
14         
15         
int mmax = A[mid];  
16         
int tmp = mmax;  
17         
for(
int i = mid-1; i >=low; i--){  
18             tmp += A[i];  
19             
if(tmp > mmax)
20                 mmax = tmp;  
21         }  
22         tmp = mmax;  
23         
for(
int i = mid+1; i <= high; i++){  
24             tmp += A[i];  
25             
if(tmp > mmax)
26                 mmax = tmp;  
27         }  
28         
return Math.max(mmax, Math.max(lmax, rmax));  
29           
30     } 
 
 Reference:
 http://en.wikipedia.org/wiki/Maximum_subarray_problem
 http://www.cnblogs.com/statical/articles/3054483.html
 http://blog.csdn.net/xshengh/article/details/12708291