求解最长递增子串可分为两种情况，即子串连续或非连续。

例如，对于整数串{1,3,5,1,-1,4,5,3,1,8,3,4,6,2,4,6,7,8,6,4}

其连续递增子串为{2,4,6,7,8}，非连续递增子串为{{-1},{1},{2,4,6,7,8}}

连续递增子串的求解思路：

采用动态规划思想，令

lengthOfSubList[k]表示子串{list[0]...list[k]}中最长的连续递增子串长度

lengthOfSubListIncludeK[k]表示子串{list[0]...list[k]}中以list[k]结尾的最长连续递增子串长度

indexOfLastElement[k]表示子串{list[0]...list[k]}中最长的连续递增子串的最后一个元素的位置

则

lengthOfSubListIncludeK[k] =

          lengthOfSubListIncludeK[k-1]+1，list[k]>=list[k-1]

          1,                              list[k]<list[k-1]

lengthOfSubList[k] = max(lengthOfSubListIncludeK[k],lengthOfSubList[k-1])

indexOfLastElement[k] =

        k,                      lengthOfSubListIncludeK[k]>lengthOfSubList[k-1]

        indexOfLastElement[k-1],lengthOfSubListIncludeK[k]<=lengthOfSubList[k-1]

代码：

 
  
  1. #include <stdlib.h> 
  2. #include <stdio.h> 
  3.  
  4. void MaxIncrementSubList(int list[],int length) 
  5. { 
  6.     //lengthOfSubList[k]表示子串{list[0]...list[k]}中最长的连续递增子串长度 
  7.     //lengthOfSubListIncludeK[k]表示子串{list[0]...list[k]}中以list[k]结尾的最长连续递增子串长度 
  8.     int* lengthOfSubList = (int*)malloc(sizeof(int)*length); 
  9.     int* lengthOfSubListIncludeK = (int*)malloc(sizeof(int)*length); 
  10.     int* indexOfLastElement = (int*)malloc(sizeof(int)*length); 
  11.     int i; 
  12.     //初始化 
  13.     for (i=0;i<length;i++) 
  14.     { 
  15.         lengthOfSubList[i] = 1; 
  16.         lengthOfSubListIncludeK[i] = 1;  
  17.         indexOfLastElement[i] = i;   
  18.     } 
  19.     //按照动态规划思想，计算lengthOfSubList[k]和lengthOfSubListIncludeK[k] 
  20.     for (i=1;i<length;i++) 
  21.     { 
  22.         if (list[i]>=list[i-1]) lengthOfSubListIncludeK[i] = lengthOfSubListIncludeK[i-1]+1; 
  23.         else lengthOfSubListIncludeK[i] = 1; 
  24.         if (lengthOfSubListIncludeK[i]>lengthOfSubList[i-1]) 
  25.         { 
  26.             lengthOfSubList[i] = lengthOfSubListIncludeK[i]; 
  27.             indexOfLastElement[i] = i; 
  28.         } 
  29.         else 
  30.         { 
  31.             lengthOfSubList[i] = lengthOfSubList[i-1]; 
  32.             indexOfLastElement[i] = indexOfLastElement[i-1]; 
  33.         } 
  34.     } 
  35.     //逆序输出最长连续递增子串 
  36.     printf("longest sub list is:\n"); 
  37.     int idx = indexOfLastElement[length-1]; 
  38.     while (list[idx]>=list[idx-1]) 
  39.     { 
  40.         printf("[%d]=%d ",idx,list[idx]); 
  41.         idx--; 
  42.     } 
  43.     printf("[%d]=%d ",idx,list[idx]); 
  44. } 
  45.  
  46. int main() 
  47. { 
  48.     int list[20] = {1,3,5,1,-1,4,5,3,1,8,3,4,6,2,4,6,7,8,6,4}; 
  49.     MaxIncrementSubList(list,20); 
  50.     int a; 
  51.     scanf("%d",&a); 
  52.     return 0; 
  53. } 
 
  
 
 
  
 
  
非连续递增子串的求解思路：
 
  
采用动态规划思想，令
 
  
lengthOfSubList[k]表示子串{list[0]...list[k]}中最长的非连续递增子串长度
 
  
lengthOfSubListIncludeK[k]表示子串{list[0]...list[k]}中以list[k]结尾的最长非连续递增子串长度
 
  
indexOfLastElement[k]表示子串{list[0]...list[k]}中最长的非连续递增子串的最后一个元素的位置
 
  
则
 
  
lengthOfSubListIncludeK[k] = max(lengthOfSubListIncludeK[i]+1, list[k]>=list[i], i=0..k-1)
 
  
lengthOfSubList[k] = max(lengthOfSubListIncludeK[k],lengthOfSubList[k-1])
 
  
indexOfLastElement[k] = 
 
  
        k,                      lengthOfSubListIncludeK[k]>lengthOfSubList[k-1]
 
  
        indexOfLastElement[k-1],lengthOfSubListIncludeK[k]<=lengthOfSubList[k-1]
 
  
代码：
 
  
 
  
  1. #include <stdlib.h> 
  2. #include <stdio.h> 
  3.  
  4. void MaxIncrementSubList(int list[],int length) 
  5. { 
  6.     //lengthOfSubList[k]表示子串{list[0]...list[k]}中最长的非连续递增子串长度  
  7.     //lengthOfSubListIncludeK[k]表示子串{list[0]...list[k]}中以list[k]结尾的最长非连续递增子串长度  
  8.     int* lengthOfSubList = (int*)malloc(sizeof(int)*length); 
  9.     int* lengthOfSubListIncludeK = (int*)malloc(sizeof(int)*length); 
  10.     int* indexOfLastElement = (int*)malloc(sizeof(int)*length); 
  11.     int i,j,max; 
  12.     //初始化 
  13.     for (i=0;i<length;i++) 
  14.     { 
  15.         lengthOfSubList[i] = 1; 
  16.         lengthOfSubListIncludeK[i] = 1;  
  17.         indexOfLastElement[i] = i;   
  18.     } 
  19.     //按照动态规划思想，计算lengthOfSubList[k]和lengthOfSubListIncludeK[k] 
  20.     for (i=1;i<length;i++) 
  21.     { 
  22.         max = lengthOfSubListIncludeK[i]; 
  23.         for (j=0;j<i;j++) 
  24.         { 
  25.             if (list[i]>list[j]) 
  26.             { 
  27.                 lengthOfSubListIncludeK[i] = lengthOfSubListIncludeK[j]+1; 
  28.                 if (max<lengthOfSubListIncludeK[i]) max = lengthOfSubListIncludeK[i]; 
  29.             } 
  30.         } 
  31.         lengthOfSubListIncludeK[i] = max; 
  32.         if (lengthOfSubListIncludeK[i]>lengthOfSubList[i-1]) 
  33.         { 
  34.             lengthOfSubList[i] = lengthOfSubListIncludeK[i]; 
  35.             indexOfLastElement[i] = i; 
  36.         } 
  37.         else 
  38.         { 
  39.             lengthOfSubList[i] = lengthOfSubList[i-1]; 
  40.             indexOfLastElement[i] = indexOfLastElement[i-1]; 
  41.         } 
  42.     } 
  43.     //逆序输出最长非连续递增子串  
  44.     printf("longest sub list is:\n"); 
  45.     int idx = indexOfLastElement[length-1]; 
  46.     int tmp = list[idx]; 
  47.     for (i=idx;i>=0;i--) 
  48.     { 
  49.         if (list[i]<=tmp) 
  50.         { 
  51.             printf("[%d]=%d ",i,list[i]); 
  52.             tmp = list[i]; 
  53.         } 
  54.     } 
  55. } 
  56.  
  57. int main() 
  58. { 
  59.     int list[20] = {1,3,5,1,-1,4,5,3,1,8,3,4,6,2,4,6,7,8,6,4}; 
  60.     MaxIncrementSubList(list,20); 
  61.     int a; 
  62.     scanf("%d",&a); 
  63.     return 0; 
  64. }