最大子列和問題（分治法和在線處理）

    時間複雜度太大，該算法不可取。

    

    該時間複雜度爲O(N)，一般遇到爲次複雜度的可以考慮改進算法，使其複雜度爲O(logN)，將會有大的改善。

分治法在每一層遞歸上都有三個步驟：

分解：將原問題分解爲若干個規模較小，相互獨立，與原問題形式相同的子問題；

解決：若子問題規模較小而容易被解決則直接解，否則遞歸地解各個子問題；

合併：將各個子問題的解合併爲原問題的解。

針對此問題，分析方法如下：

1、先一分爲二：左邊爲4，-3，5，-2；右邊爲：-1，2，6，-2

2、對左邊再一分爲二：左邊爲4，-3；右邊爲5，-2。計算左邊子序列大於0的值分別爲4和1，取4；計算右邊子序列大於0的值分別爲5和3，取5

3、對左邊（4，-3，5，-2）再進行合：連續子序列跨越分界線計算的大於0的值爲4-3+5=6最大，再與4和5相比較，得出6爲最大值。

4、對右邊再一分爲二：左邊爲-1，2；右邊爲6，-2。計算左邊子序列大於0的值分別爲2和1，取2；計算右邊子序列大於0的值分別爲6和4，取6

5、對右邊（-1，2，6，-2）再進行合：連續子序列跨越分界線計算的大於0的值爲2+6=8最大，再與2和6比較，得出8爲最大值。

6、對整個序列（4，-3，5，-2，-1，2，6，-2）進行合：連續子序列跨越分界線計算的大於0的值爲4-3+5-2-1+2+6=11最大，再與6和8比較，得出11最大。

7、整個序列採用先分再合逐步遞歸的方法得出最終結果爲11

時間複雜度爲上圖已經給出的O(NlogN)，針對本題，分治法依然不是最理想的算法。

在線處理的算法時間複雜度僅爲O(N)，是最好的算法。

上圖是以上四種算法運行時間進行比較，明顯可以看出第四種算法最爲高效。

上述各程序代碼如下：

1. #include <stdio.h>
2. #include <time.h>
3. //算法1
4. int MaxSubseqSum1(int A[], int N, int * s, int* e)
5. {
6. int ThisSum, MaxSum = 0;
7. int i, j, k;
8. for (i = 0; i < N; i++) /* i是子列左端位置 */
9. { 
10. for (j = i; j < N; j++) /* j是子列右端位置 */
11. {
12. ThisSum = 0; /* ThisSum是從A[i]到A[j]的子列和 */
13. for (k = i; k <= j; k++) 
14. {
15. ThisSum += A[k];
16. }
17. if (ThisSum > MaxSum) /* 如果剛得到的這個子列和更大 */
18. {
19. MaxSum = ThisSum; /* 則更新結果 */
20. *e = j;
21. *s = i;
22. }
23. } /* j循環結束 */
24. } /* i循環結束 */
25. return MaxSum;
26. }
27. //算法2
28. int MaxSubseqSum2(int A[], int N,int * s, int* e)
29. {
30. int ThisSum, MaxSum = 0;
31. int i, j;
32. *s = 0;
33. *e = N;
34. for (i = 0; i < N; i++) /* i是子列左端位置 */
35. { 
36. ThisSum = 0; /* ThisSum是從A[i]到A[j]的子列和 */
37. for (j = i; j < N; j++) /* j是子列右端位置 */
38. { 
39. ThisSum += A[j];        /*對於相同的i，不同的j，只要在j-1次循環的基礎上累加1項即可*/
40. if (ThisSum > MaxSum)   /* 如果剛得到的這個子列和更大 */
41. {
42. MaxSum = ThisSum;   /* 則更新結果 */
43. *e = j;
44. *s = i;
45. }
46. } /* j循環結束 */
47. } /* i循環結束 */
48. return MaxSum;
49. }
50. //算法3
51. int MaxSubseqSum3(int A[], int left, int right, int *s, int *e)
52. {
53. int i = 0, j = 0, sum = 0;
54. int s1 = 0, s2 = 0, lefts = 0, rights = 0;
55. int center, leftsum, rightsum;
56. if (left == right)
57. {
58. if (A[left]>0)
59. sum = A[left];
60. else
61. sum = 0;
62. *s = left; *e = right;
63. }
64. else
65. {
66. center = (left + right) / 2;               //劃分
67. leftsum = MaxSubseqSum3(A, left, center, s, e);       //對應情況1，遞歸求解
68. rightsum = MaxSubseqSum3(A, center + 1, right, s, e);      //對應情況2，遞歸求解
69. //求解s1
70. for (i = center; i >= left; i--)
71. {
72. lefts +=A[i];
73. if (lefts > s1) 
74. {
75. *s = i;
76. *e = center/2*2;   //不清楚爲啥是這樣的
77. s1 = lefts;
78. }
79. }
80. //再求解s2
81. for (j = center + 1; j <= right; j++)
82. {
83. rights = rights + A[j];
84. if (rights > s2) 
85. {
86. s2 = rights; 
87. *e = j;
88. *s = (center+1)/2*2; //依然不清楚
89. }
90. }
91. sum = s1 + s2;                //計算情況3的最大子段和
92. if (sum<leftsum)
93. sum = leftsum;
94. if (sum<rightsum)
95. sum = rightsum;
96. }
97. return sum;
98. }
99. 
    
100. 
     
101. int MaxSubseqSum4(int A[], int N, int * s, int* e)
102. {
103. int ThisSum, MaxSum;
104. int i;
105. int ss = 0;
106. ThisSum = MaxSum = 0;
107. for (i = 0; i < N; i++) 
108. {
109. ThisSum += A[i]; /* 向右累加 */
110. if (ThisSum > MaxSum)
111. {
112. MaxSum = ThisSum; /* 發現更大和則更新當前結果 */
113. *s = ss;
114. *e = i;
115. }
116. else if (ThisSum < 0) /* 如果當前子列和爲負 */
117. {
118. ThisSum = 0; /* 則不可能使後面的部分和增大，拋棄之 */
119. ss = i+1;
120. }
121. }
122. return MaxSum;
123. }
124. int main() {
125. int a[] = { -10 ,1, 2, 3, 4, - 5, - 23, 3, 7, - 21 };
126. int result,s,e,i;
127. clock_t start, ended;
128. double duration;
129. const int COUNT = 100000;
131. start = clock();
132. for ( i = 0; i< COUNT; i++)
133. result = MaxSubseqSum1(a, sizeof(a) / sizeof(a[0]), &s, &e);
134. ended = clock();
135. duration = (double)(ended - start) / CLK_TCK;
136. printf("ticks1    = %lf\n",(double)(ended - start));
137. printf("duration1 = %lf\n", duration);
138. printf("start1=%d,ended1=%d result1 = %d\n", s,e,result);
140. start = clock();
141. for ( i = 0; i< COUNT; i++)
142. result = MaxSubseqSum2(a, sizeof(a) / sizeof(a[0]), &s, &e);
143. ended = clock();
144. duration = (double)(ended - start) / CLK_TCK;
145. printf("ticks2    = %lf\n", (double)(ended - start));
146. printf("duration2 = %lf\n", duration);
147. printf("start2=%d,ended2=%d result2 = %d\n", s, e, result);
149. start = clock();
150. for ( i = 0; i< COUNT; i++)
151. result = MaxSubseqSum3(a, 0, sizeof(a) / sizeof(a[0]), &s, &e);
152. ended = clock();
153. duration = (double)(ended - start) / CLK_TCK;
154. printf("ticks3    = %lf\n", (double)(ended - start));
155. printf("duration3 = %lf\n", duration);
156. printf("start3=%d,ended3=%d result3 = %d\n", s, e, result);
157. 
     
158. start = clock();
159. for ( i = 0; i< COUNT; i++)
160. result = MaxSubseqSum4(a, sizeof(a) / sizeof(a[0]), &s, &e);
161. ended = clock();
162. duration = (double)(ended - start) / CLK_TCK;
163. printf("ticks4    = %lf\n", (double)(ended - start));
164. printf("duration4 = %lf\n", duration);
165. printf("start4=%d,ended4=%d result4 = %d\n", s, e, result);
166. return 0;
167. }

程序運行結果如下（在VS2010環境下）：

可以看出算法1最差，算法4在線處理最好。

下圖所示是在VC++6.0下的運行結果：

其中算法3因爲採用遞歸算法，空間複雜度太大，運行結果出現了錯誤。