笔试算法题（35）：最长递增子序列 & 判定一个字符串是否可由另一个字符串旋转得到

出题：求数组中最长递增子序列的长度（递增子序列的元素可以不相连）；

分析：

• 解法1：应用DP之前需要确定当前问题是否具有无后效性，也就是每个状态都是对之前状态的一个总结，之后的状态仅会受到前一个状态的影响；对于递增子序列 而言，可以首先确定前面k个元素的最长子序列，然后计算增加一个元素之后的最长子序列。由于每个位置i都会与0-i的每个位置之前的LIS进行比较，并选 择保持递增的一个序列，所以总能找到LIS，但是时间复杂度为O(N^2)，空间复杂度为O(N)；
• 此解法的性能的瓶颈在于对于位置为i+1的元素，都会遍历0到i内的每一个元素，比较元素本身，以及其位置上的record值；但问题的核心是找到一个最长的LIS，并且其序列中最后一个元素的值比array[i+1]小就可以；

解题：

 int version1(int *array, int length) {
         /**
          * record记录每个元素位置之前的LIS数
          * */
         int *record=new int[length];
         for(int i=;i<length;i++) {
                 /**
                  * 将当前元素的LIS初始化为1
                  * */
                 record[i]=;
                 for(int j=;j<i;j++) {
                         /**
                          * 遍历元素i之前的所有元素j，判断j与i是否组成递增序列
                          * 如果是，则比较对应的record[j]是否比record[i]大1
                          * 如果是，则更新record[i]的值为record[j]+1
                          * 这样的策略则总能保证，record[i]的值是0到i区间最大
                          * 的LIS
                          * */
                         if(array[i]>array[j] && record[j]+>record[i]) {
                                 record[i]=record[j]+;
                         }
                 }
         }

         /**
          * 从record中找出最大的LIS
          * */
         int max=record[];
         for(int i=;i<length;i++) {
                 if(max<record[i])
                         max=record[i];
         }

         return max;
 }

 int main() {
         int array[]={,-,,-,,-,,-,-};
         printf("%d\n",version1(array, ));
         return ;
 }

出题：给定两个字符串S1和S2,要求判定S2是否可以通过S1做循环移位(rotate)得到的新字符串包含。（S1=AABCD和S2=CDAA，就是包含；S1=ABCD和S2=ACBD，不包含）；

分析：

• S2是移位之后的字符串，则S2的第一个字符对应到S1中的字符位置之前的字符肯定已经被rotate到后面；可以首先从S1中查找S2，如果某个字符不 相同，则跳到下一个可能的查找位置；如果S1到达末尾，则rotate前面的字符，继续对比；如果S2到达末尾，则说明包含；如果rotate之后对比的 字符不同，则不包含。此方法时间复杂度为O(MN)；
• 另外一个解法为将S1转变为SS1=AABCDAABCD，这样子在SS1上寻找S2，时间复杂度仍旧为O(MN)，其实与上述方法策略相同；

解题：

 /**
  * 翻转字符串，注意length为字符串长度，
  * 而不是字符索引
  * */
 void Reverse(char *s, int length) {
         char temp;
         for(int i=;i<length/;i++) {
                 temp=s[i];
                 s[i]=s[length-i-];
                 s[length-i-]=temp;
         }
 }
 /**
  * 下面的方法实现以s2为分界的旋转，比如
  * 字符串abcdef，s1指向a，s2指向d
  * 则经过方法处理之后为defabc
  * */
 void HalfReverse(char *s1, char *s2) {
         char *t=s1;
         char length=, halflength=;
         while(*t!='\0') {
                 if(*t==*s2)
                         halflength=length;
                 length++;
                 t++;
         }
         Reverse(s1,halflength);
         Reverse(s2,length-halflength);
         Reverse(s1,length);
 };
 /**
  * 将s1作为循环主体，每一个字符作为比较的开始字符；
  * s2平行在s1上移动比较
  * s1仅可以进行一次旋转
  * */
 bool RotateContain(char *s1, char *s2, bool isRotate) {
         char *s1t=s1, *s2t=s2;

         while(*s1t) {
                 char *s1tt=s1t;
                 char *s2tt=s2t;

                 while(*s1tt!='\0' && *s2tt!='\0') {
                         if(*s1tt!=*s2tt)
                                 break;
                         s1tt++;s2tt++;
                 }
                 /**
                  * 当s2到达末尾，表示成功匹配，返回true
                  * */
                 if(*s2tt=='\0')
                         return true;
                 /**
                  * 当s1到达末尾，有两种情况
                  * 如果isRotate为false，则可以进行一次旋转
                  * 如果isRotate为true，说明已经进行了一次旋转
                  * */
                 if(*s1tt=='\0') {
                         if(isRotate)
                                 return false;
                         else {
                                 isRotate=true;
                                 HalfReverse(s1, s1t);
                                 return RotateContain(s1,s2,isRotate);
                         }
                 }
                 s1t++;
         }
         return false;
 }

 int main() {

         char s1[]="abcdefg";
         char s2[]="defgabc";
         bool isRotate=false;
         if(RotateContain(s1,s2,isRotate))
                 printf("true");
         else
                 printf("false");
         return ;
 }