算法之动态规划算法总结

设长度为N的数组为{a0,a1, a2, ...an-1),则假定以aj结尾的数组序列的最长递增子序列长度为L(j),则L(j)={ max(L(i))+1, i

例如给定的数组为{5,6,7,1,2,8},则L(0)=1, L(1)=2, L(2)=3, L(3)=1, L(4)=2, L(5)=4。所以该数组最长递增子序列长度为4,序列为{5,6,7,8}。算法代码如下:

1. #include   

2. using namespace std;  

3. #define len(a) (sizeof(a) / sizeof(a[0])) //数组长度  

4. int lis(int arr[], int len)  

5. {

6. int longest[len];  

7. for (int i=0; i

8. longest[i] = 1;

9.

10. for (int j=1; j

11. for (int i=0; i

12. if (arr[j]>arr[i] && longest[j]

13. longest[j] = longest[i] + 1;//计算以arr[j]结尾的序列的最长递增子序列长度  

14. }

15. }

16. }

17.

18. int max = 0;  

19. for (int j=0; j

20. cout <<"longest[" << j << "]=" << longest[j] << endl;  

21. if (longest[j] > max) max = longest[j];  //从longest[j]中找出最大值  

22. }

23. return max;  

24. }

1. int main()  

2. {

3. int arr[] = {1, 4, 5, 6, 2, 3, 8}; //测试数组  

4. int ret = lis(arr, len(arr));  

5.     cout << "max increment substring len=" << ret << endl;  

6.     return 0;  

7. }

算法思想总结:

例如给定的数组为{5,6,7,1,2,8},则L(0)=1, L(1)=2, L(2)=3, L(3)=1, L(4)=2, L(5)=4。所以该数组最长递增子序列长度为4,序列为{5,6,7,8}

什么意思呢?

对于这个数组{5,6,7,1,2,8},假设它的下标为i的时候,它的最长递增序列长度为length

s->对应元素组元素

L->对应最长递增序列

那么L(0) ->s{5}->L{5}->1

L(1) ->s{5,6}->L{5,6}->2

L(2) ->s{5,6,7}->L{5,6,7}->3

L(3) ->s{5,6,7,1}->L{1}->1

L(4) ->s{5,6,7,1,2}->L{1,2}->2

L(5) ->s{5,6,7,1,2,8}->L{5,6,7,8}->5

上面得L(5) = L{5,6,7,8} = {5,6,7} + 8 = L(2) + 1

所以L(5)可能是L(4) + 1或者L(3) + 1 或者L(2) + 1或者L(1) + 1或者L(0) + 1,前提a[5] > a[4]或者a[3]或者a[2]或者a[1]或者a[0]

所以这个例子只是一种情况,所以对于L(i),他可能是L(0)+1,L(1)+1…L(i-1)+1转移过来的但是很幸运的是动态规划算法把L(0),L(1),L(2)….L(i-1)都保存下来了(所以DP当问题复杂度解到第i步的时候,前面所有可能问题的解L(0),L(1),L(2),,,,L(i-1)都保存下来了,这也是它的关键,而DP本身就是求的所有子问题的解L(0),L(1),L(2),,,,L(n),然后找出所有解最大的那个),前面必须满足条件a[i] > a[j]

如果a[i] < a[j]则不管

注意:最后不一定是L(5)最大(你可以看下L(4) ->s{5,6,7,1,2}->L{1,2}->2,只有两个

),如果上面的条件不满足的话或者a[5]比较小的话,那就是L(2)最大,所以最终还会遍历一遍L数组,寻找最大的那个,任何一个下标对应的都可能最大

还有一点注意:上面的longest[j] a[j]并且加了一个a[j]后,它的个数比原来的longest[j]要大,就赋值,这个为什么能起作用,就是由于初始条件longest[j]全都被初始化为了1,所以这个很关键

总结:

所以DP当问题复杂度解到第i步的时候,前面所有可能问题的解L(0),L(1),L(2),,,,L(i-1)都保存下来了,这也是它的关键,而DP本身就是求的所有子问题的解L(0),L(1),L(2),,,,L(n),然后找出所有解最大的那个,针对这个例子找的是最大那个

你可能感兴趣的:(算法之动态规划算法总结)