最长公共子序列，最长公共子串，最长单调子序列等问题入门

最新推荐文章于 2023-02-13 13:38:36 发布
转载 最新推荐文章于 2023-02-13 13:38:36 发布 · 425 阅读 · 0
本文详细阐述了子串和子序列的概念区别，探讨了最长公共子序列问题及其动态规划解决方案，介绍了最大子序列和的问题及算法实现，并讨论了最长公共子串的两种求解方法。


首先来说子串和字符串的区别：

子串!=子序列

例如：一个字符串   awbcdewgh

他的子串：  awbc.   awbcd   awbcde   ....很多个子串  但是都是连续在一起  

他的子序列： abc  .  abcd    abcde  ...  很多个子序列  但是子序列中的字符在字符串中不一定是连在一起的， 但是  子序列一定是单调的， （即字符之间ASCII单调递增或单调递减）

最大子序列

最大子序列是要找出由数组成的一维数组中和最大的连续子序列。比如{5,-3,4,2}的最大子序列就是 {5,-3,4,2}，它的和是8,达到最大；而 {5,-6,4,2}的最大子序列是{4,2}，它的和是6。你已经看出来了，找最大子序列的方法很简单，只要前i项的和还没有小于0那么子序列就一直向后扩展，否则丢弃之前的子序列开始新的子序列，同时我们要记下各个子序列的和，最后找到和最大的子序列。

int maxSubSum(const vector<int> & arr,int &begin,int &end){
    int maxSum=0;
    int currSum=0;
    int newbegin=0;
    for(int i=0;i<arr.size();++i){
        currSum+=arr[i];
        if(currSum>maxSum){
            maxSum=currSum;
            begin=newbegin;
            end=i;
        }
        if(currSum<0){
            currSum=0;
            newbegin=i+1;
        }
    }
    return maxSum;
}



两字符序列的最长公共字符子序列

问题描述：字符序列的子序列是指从给定字符序列中随意地（不一定连续）去掉若干个字符（可能一个也不去掉）后所形成的字符

序列。令给定的字符序列X=“x0，x1，…，xm-1”，序列Y=“y0，y1，…，yk-1”是X的子序列，存在X的一个严格递增下标序列<i

0，i1，…，ik-1>，使得对所有的j=0，1，…，k-1，有xij=yj。例如，X=“ABCBDAB”，Y=“BCDB”是X的一个子序列。

考虑最长公共子序列问题如何分解成子问题，设A=“a0，a1，…，am-1”，B=“b0，b1，…，bm-1”，并Z=“z0，z1，…，zk-

1”为它们的最长公共子序列。不难证明有以下性质：

（1） 如果am-1=bn-1，则zk-1=am-1=bn-1，且“z0，z1，…，zk-2”是“a0，a1，…，am-2”和“b0，b1，…，bn-2”的一个最

长公共子序列；

（2） 如果am-1!=bn-1，则若zk-1!=am-1，蕴涵“z0，z1，…，zk-1”是“a0，a1，…，am-2”和“b0，b1，…，bn-1”的一个最

长公共子序列；

（3） 如果am-1!=bn-1，则若zk-1!=bn-1，蕴涵“z0，z1，…，zk-1”是“a0，a1，…，am-1”和“b0，b1，…，bn-2”的一个最

长公共子序列。

这样，在找A和B的公共子序列时，如有am-1=bn-1，则进一步解决一个子问题，找“a0，a1，…，am-2”和“b0，b1，…，bm-2”的

一个最长公共子序列；如果am-1!=bn-1，则要解决两个子问题，找出“a0，a1，…，am-2”和“b0，b1，…，bn-1”的一个最长公

共子序列和找出“a0，a1，…，am-1”和“b0，b1，…，bn-2”的一个最长公共子序列，再取两者中较长者作为A和B的最长公共子

序列。

求解：

引进一个二维数组c[][]，用c[i][j]记录X[i]与Y[j] 的LCS 的长度，b[i][j]记录c[i][j]是通过哪一个子问题的值求得的，以决定

搜索的方向。

我们是自底向上进行递推计算，那么在计算c[i,j]之前，c[i-1][j-1]，c[i-1][j]与c[i][j-1]均已计算出来。此时我们根据X[i] =

 Y[j]还是X[i] != Y[j]，就可以计算出c[i][j]。

问题的递归式写成：



分析：
由于每次调用至少向上或向左（或向上向左同时）移动一步，故最多调用(m + n)次就会遇到i = 0或j = 0的情况，此时开始返回。返回时与递归调用时方向相反，步数相同，故算法时间复杂度为Θ(m + n)。

#include <stdio.h>  
#include <string.h>  
#define MAXLEN 100  
  
void LCSLength(char *x, char *y, int m, int n, int c[][MAXLEN], int b[][MAXLEN])  
{  
    int i, j;  
      
    for(i = 0; i <= m; i++)  
        c[i][0] = 0;  
    for(j = 0; j <= n; j++)  
        c[0][j] = 0;  
    for(i = 1; i<= m; i++)  
    {  
        for(j = 1; j <= n; j++)  
        {  
            if(x[i-1] == y[j-1])  //上面第一步（1） 
            {  
                c[i][j] = c[i-1][j-1] + 1;  
                b[i][j] = 0;  
            }  
            else if(c[i-1][j] >= c[i][j-1])  //（2） 
            {  
                c[i][j] = c[i-1][j];  
                b[i][j] = 1;  
            }  
            else  //（3） 
            {  
                c[i][j] = c[i][j-1];  
                b[i][j] = -1;  
            }  
        }  
    }  
}  
  
void PrintLCS(int b[][MAXLEN], char *x, int i, int j)  //可以输出子序列
{  
    if(i == 0 || j == 0)  
        return;  
    if(b[i][j] == 0)  
    {  
        PrintLCS(b, x, i-1, j-1);  
        printf("%c ", x[i-1]);  
    }  
    else if(b[i][j] == 1)  
        PrintLCS(b, x, i-1, j);  
    else  
        PrintLCS(b, x, i, j-1);  
}  
  
int main(int argc, char **argv)  
{  
    char x[MAXLEN] = {"ABCBDAB"};  
    char y[MAXLEN] = {"BDCABA"};  
    int b[MAXLEN][MAXLEN];  
    int c[MAXLEN][MAXLEN];  
    int m, n;  
      
    m = strlen(x);  
    n = strlen(y);  
      
    LCSLength(x, y, m, n, c, b);  
    PrintLCS(b, x, m, n);  
      
    return 0;  
}

求最大长度的核心代码：

 for(i = 0; i <= m; i++)    
        c[i][0] = 0;    
    for(j = 0; j <= n; j++)    
        c[0][j] = 0;    
    for(i = 1; i<= m; i++)       
        for(j = 1; j <= n; j++)    
        {    
            if(x[i-1] == y[j-1])  //上面第一步（1）      
                c[i][j] = c[i-1][j-1] + 1;      
              
            else (c[i-1][j] >= c[i][j-1])  //（2）      
                c[i][j] = max(c[i-1][j] >= c[i][j-1]) ;    
    }  
	printf("%d\n",c[m][n]);  





#include <cstdio>  
#include <cstring>  
const int maxn=10001;  
char s[maxn];  
int dp[maxn],Max;  
void LICS()  
{  
    int len;  
    memset(dp,0,sizeof(dp));  
    len=strlen(s);  
    for(int i=0;i<len;i++)  
    {  
        dp[i]=1;//给定一个数组求的时候，初始值就是1，一个数组的最大序列肯定会有一个字符；  
        for(int j=0;j<i;j++)  
        {  
            if(s[i]>s[j] && dp[i]<1+dp[j])// 递推公式，如果这个位置比前面的字符都大，就加入到递增序列中来  
                dp[i]=1+dp[j];  
        }  
    }  
    Max=0;  
    for(int i=0;i<len;i++)//求出最大值  
        if(Max<dp[i])  
          Max=dp[i];  
}  
int main()  
{  
    int t;  
    scanf("%d",&t);  
    while(t--)  
    {  
        scanf("%s",s);  
        LICS();  
        printf("%d\n",Max);  
    }  
    return 0;  
}



最长公共子串：

方法一：

     Longest Common Substring和Longest Common Subsequence是有区别的

     X = <a, b, c, f, b, c>

     Y = <a, b, f, c, a, b>

     X和Y的Longest Common Sequence为<a, b, c, b>，长度为4

     X和Y的Longest Common Substring为 <a, b>长度为2

    其实Substring问题是Subsequence问题的特殊情况，也是要找两个递增的下标序列

    <i1, i2, ...ik> 和 <j1, j2, ..., jk>使

     xi1 == yj1

    xi2 == yj2

    ......

    xik == yjk

    与Subsequence问题不同的是，Substring问题不光要求下标序列是递增的，还要求每次

   递增的增量为1， 即两个下标序列为：

   <i, i+1, i+2, ..., i+k-1> 和 <j, j+1, j+2, ..., j+k-1>

    类比Subquence问题的动态规划解法，Substring也可以用动态规划解决，令

    c[i][j]表示Xi和Yi的最大Substring的长度，比如

   X = <y, e, d, f>

   Y = <y, e, k, f>

   c[1][1] = 1

   c[2][2] = 2

   c[3][3] = 0

   c[4][4] = 1

   动态转移方程为：

   如果xi == yj， 则 c[i][j] = c[i-1][j-1]+1

   如果xi ! = yj,  那么c[i][j] = 0

   最后求Longest Common Substring的长度等于

   max{  c[i][j],  1<=i<=n， 1<=j<=m}

/**  
找出两个字符串的最长公共连续子串的长度 
** author :liuzhiwei   
** data   :2011-08-16 
**/   
#include "stdio.h"  
#include "string.h"  
#include "stdlib.h"  
  
int longest_common_substring(char *str1, char *str2)  
{  
    int i,j,k,len1,len2,max,x,y;  
    len1 = strlen(str1);  
    len2 = strlen(str2);  
    int **c = new int*[len1+1];  
    for(i = 0; i < len1+1; i++)  
        c[i] = new int[len2+1];  
    for(i = 0; i < len1+1; i++)  
        c[i][0]=0;        //第0列都初始化为0  
    for(j = 0; j < len2+1; j++)  
        c[0][j]=0;        //第0行都初始化为0   
    max = -1;  
    for(i = 1 ; i < len1+1 ; i++)  
    {  
        for(j = 1; j < len2+1; j++)  
        {  
            if(str1[i-1]==str2[j-1])     //只需要跟左上方的c[i-1][j-1]比较就可以了  
                c[i][j]=c[i-1][j-1]+1;  
            else                         //不连续的时候还要跟左边的c[i][j-1]、上边的c[i-1][j]值比较，这里不需要  
                c[i][j]=0;  
            if(c[i][j]>max)  
            {  
                max=c[i][j];  
                x=i;  
                y=j;  
            }  
        }  
    }  
  
    //输出公共子串  
    char s[1000];  
    k=max;  
    i=x-1,j=y-1;  
    s[k--]='\0';  
    while(i>=0 && j>=0)  
    {  
        if(str1[i]==str2[j])  
        {  
            s[k--]=str1[i];  
            i--;  
            j--;  
        }  
        else       //只要有一个不相等，就说明相等的公共字符断了，不连续了  
            break;  
    }  
    printf("最长公共子串为：");  
    puts(s);  
    for(i = 0; i < len1+1; i++)         //释放动态申请的二维数组  
        delete[] c[i];  
    delete[] c;  
    return max;  
}  
int main(void)  
{  
    char str1[1000],str2[1000];  
    printf("请输入第一个字符串：");  
    gets(str1);  
    printf("请输入第二个字符串：");  
    gets(str2);  
    int len = longest_common_substring(str1, str2);  
    printf("最长公共连续子串的长度为：%d\n",len);  
    system("pause");  
    return 0;  
}


方法二：

      将字符串s1和s2分别写在两把直尺上面(我依然用s1，s2来表示这两把直尺)，然后将s1固定，s2的头部和s1的尾部对齐，然后逐渐移动直尺s2，比较重叠部分的字符串中的公共子串的长度，直到直尺s2移动到s1的头部。在这个过程中求得的最大长度就是s1、s2最大子串的长度。

     下图是求解过程的图示（下图有点错误，应该是将s2从右往左移动），蓝色部分表示重叠的字符串，红色的部分表示重叠部分相同的子串

      其中s1="shaohui"，s2="ahui"，最后求得的结果为3


/**  
找出两个字符串的最长公共连续子串的长度 
** author :liuzhiwei   
** data   :2011-08-16 
**/   
#include "stdio.h"  
#include "string.h"  
#include "stdlib.h"  
  
int longest_common_substring(char *str1, char *str2)  
{  
    int i,len1,len2,len,s1_start,s2_start,idx,curmax,max;  
    len1 = strlen(str1);  
    len2 = strlen(str2);  
    len = len1 + len2;  
    max = 0;  
    for(i = 0 ; i < len ; i++)  
    {  
        s1_start = s2_start = 0;  
        if(i < len1)  
            s1_start = len1 - i;    //每次开始匹配的起始位置  
        else  
            s2_start = i - len1;  
        curmax = 0;  
        for(idx = 0 ; ( s1_start + idx < len1 ) && ( s2_start + idx < len2 ); idx++ )  
        {  
            if(str1[s1_start+idx]==str2[s2_start+idx])  
                curmax++;  
            else     //只要有一个不相等，就说明相等的公共字符断了，不连续了，要保存curmax与max中的最大值，并将curmax重置为0  
            {  
                max = curmax > max ? curmax : max;  
                curmax = 0;  
            }  
        }  
        max = curmax > max ? curmax : max;  
    }  
    return max;  
}  
int main(void)  
{  
    char str1[1000],str2[1000];  
    printf("请输入第一个字符串：");  
    gets(str1);  
    printf("请输入第二个字符串：");  
    gets(str2);  
    int len = longest_common_substring(str1, str2);  
    printf("最长公共连续子串的长度为：%d\n",len);  
    system("pause");  
    return 0;  
}
稍微改动一下，便可以输出公共子串了，就是要保存一下连续公共子串最后一个字符在其中一个字符串中的下标位置：

/**  
找出两个字符串的最长公共连续子串的长度 
** author :liuzhiwei   
** data   :2011-08-16 
**/   
#include "stdio.h"  
#include "string.h"  
#include "stdlib.h"  
  
int longest_common_substring(char *str1, char *str2)  
{  
    int i,k,len1,len2,len,s1_start,s2_start,idx,curmax,max;  
    len1 = strlen(str1);  
    len2 = strlen(str2);  
    len = len1 + len2;  
    max = 0;  
    for(i = 0 ; i < len ; i++)  
    {  
        s1_start = s2_start = 0;  
        if(i < len1)  
            s1_start = len1 - i;    //每次开始匹配的起始位置  
        else  
            s2_start = i - len1;  
        curmax = 0;  
        for(idx = 0 ; ( s1_start + idx < len1 ) && ( s2_start + idx < len2 ); idx++ )  
        {  
            if(str1[s1_start+idx]==str2[s2_start+idx])  
                curmax++;  
            else     //只要有一个不相等，就说明相等的公共字符断了，不连续了，要保存curmax与max中的最大值，并将curmax重置为0  
            {  
                //max = curmax > max ? curmax : max;  
                if(curmax > max)  
                {  
                    max = curmax;  
                    k = s1_start+idx-1;      //保存连续子串长度增加时连续子串最后一个字符在str1字符串中的下标位置，便于输出公共连续子串  
                }  
                curmax = 0;  
            }  
        }  
        //max = curmax > max ? curmax : max;  
        if(curmax > max)  
        {  
            max = curmax;  
            k = s1_start+idx-1;  
        }  
    }  
  
    //输出公共子串  
    char s[1000];  
    for(i=0;i<max;i++)  
        s[i]=str1[k-max+1+i];     //公共字串在str1中的下标起始位置为k-max+1，结束位置为k  
    s[i]='\0';  
    printf("最长公共子串为：");  
    puts(s);  
    return max;  
}  
int main(void)  
{  
    char str1[1000],str2[1000];  
    printf("请输入第一个字符串：");  
    gets(str1);  
    printf("请输入第二个字符串：");  
    gets(str2);  
    int len = longest_common_substring(str1, str2);  
    printf("最长公共连续子串的长度为：%d\n",len);  
    system("pause");  
    return 0;  
}








动态规划基础篇之最长公共子序列问题
热门推荐
别止的博客
08-08 8万+
一些概念： （1）子序列： 一个序列A ＝ a1,a2,……an,中任意删除若干项，剩余的序列叫做A的一个子序列。也可以认为是从序列A按原顺序保留任意若干项得到的序列。 例如： 对序列 1,3,5,4,2,6,8,7来说，序列3,4,8,7 是它的一个子序列。 对于一个长度为n的序列，它一共有2^n 个子序列，有(2^n – 1)个非空子序列。 请注意
利用动态规划找出最长公共单调递增子序列
z84616995z的专栏
08-01 3582
动态规划法求最长递增子序列的两种方法，一个是n²，一个是nlgn时间的。
最长公共子序列LCS和 最长单调子序列 及其二分优化
m0_60777643的博客
04-07 2591
最长公共子序列LCS和最长上升子序列LIS都是动态规划的经典例题，再度回顾这两个例题，已经有了更深一些的理解和优化方式。这里系统整理一下 。 一.最长单调子序列 1.最长上升子序列 最朴素的dp思路，就是对一个序列a[i]，设一个dp数组, 其中dp[i]的含义为以a[i]结尾的最长上升子序列的长度。 那么我们考虑当前的a[i]与与a[i]之前的元素的关系， 如果当前的a[i]与a[i]之前的a[j]满足递增关系，那么dp[i]的状态可以由dp[j]得到，对每个先前状态取最值即为当前状态的最.
单调递增最长子序列（LIS）&&最长公共子序列（LCS）
huatian5的博客
07-23 1052
动态规划的经典问题，这里的讲解网上有很多非常好的，而我却还没有能力写出完整详细的理解，就附图两张吧，这两个图貌似很火，出处找不到了。 LIS LCS 动态规划的三种形式： 1.记忆递归型 2.“我为人人”递推型 3.“人人为我”递推型 递推并不是动态规划的本质，如何拆分才是核心。拆分成若干子问题. 这里看到知乎上讲解特别好的 动态规划中递推式的求解
P1439 【模板】最长公共子序列 （最长上升子序列+单调栈）
碳酸钙的01妖精的博客
06-23 852
P1439 【模板】最长公共子序列 （最长上升子序列优化）题目描述给出1-n的两个排列P1和P2，求它们的最长公共子序列。输入输出格式输入格式：第一行是一个数n，接下来两行，每行为n个数，为自然数1-n的一个排列。输出格式：一个数，即最长公共子序列的长度输入输出样例输入样例#1： 复制5 3 2 1 4 51 2 3 4 5输出样例#1： 复制3说明【数据规模】对于50%的数据，n≤1000对于1...
求一个数列的最长非递增（递减）子序列
zxxapple的专栏
03-09 1265
  问题描述： 给出一个数列，找出其中最长的单调递减（或递增）子序列。比如数列 4，2，6，3，1，5  最长递增子数列为2,3,5               相似的问题：1求最大和的子序列                               2最大公共子串                               3最大公共子序列             注意：串与...
最长单调子序列问题
sushauai的博客
11-28 944
概念 序列的子序列，可以由从这个序列中去掉0个或多个元素而得来。所以子序列 可以是由其父序列中不连续的元素组成，但相对顺序不能改变。公共子序列指 的是,假如序列Z既是X的子序列，又是序列Y的子序列，那么称Z为X和Y的公共子序 列。两个序列最长的公共子序列就被称之为最长公共子序列。最长公共子序列， 又被称之为最长公共子串，译自英文名Longgest Common Subsequence，可以缩
C# 最长公共子序列
luozuolincool的专栏
10-15 2078
本程序实现了字符串的最长公共子序列的方法：str[i,j]数组中保存str1,str2长度分别为0-i，0-j之间的最长公共子序列，s[i,j]数组中保存str1,str2长度分别为0-i，0-j之间的最长公共子序列的长度； s[i,j]=0,i=0或者j=0 s[i,j]=s[i - 1, j - 1] + 1;str1[i]=str2[j] s[i,j]=max{s[i - 1, j ],s[i , j-1 ] };str1[i]!=str2[j]
LIS&LCS总结(最长上升子序列与最长公共子序列)
weixin_30491641的博客
07-31 106
\(LIS\) 首先区分一组概念 子序列：一个序列的子集，可以是连续也可以是不连续的。 子串：一个序列的子集，必须是连续的。 最长上升子序列的意思就不多说了 \(1.\)朴素做法\(O(n^2)\) 用\(dp[i]\)表示以\(i\)为结尾的最长子序列的长度 在遍历的同时让\(j\)从\(1到i-1\)遍历，如果\(a[i]>a[j]\)那么\(dp[i]=max(dp[i],...
python求解公共子序列_LeetCode | 动态规划算法（DP）求解最大最长系列问题（python版，最全解析）...
weixin_39613433的博客
11-27 218
动态规划解法由于不用考虑中间结果的暂存，不用输出所有可能情况的集合，只需要求解问题的个数。所以dp很适合求解最大、最长系列问题。最长递增子序列（LIS）leetcode300 LongestIncreaseSubsequenceGiven an unsorted array of integers, find the length of longest increasing subsequence...
codevs2185 最长公共上升子序列(LCIS,dp)
闲人请进
08-18 196
最长公共上升子序列 题目描述 Description 熊大妈的奶牛在小沐沐的熏陶下开始研究信息题目。小沐沐先让奶牛研究了最长上升子序列，再让他们研究了最长公共子序列，现在又让他们要研究最长公共上升子序列了。 小沐沐说，对于两个串A，B，如果它们都包含一段位置不一定连续的数字，且数字是严格递增的，那么称这一段数字是两个串的公共上升子串，而所有的公共上升子串中最长的就是最长公共上升子串了。 奶...
【LCS,LIS】最长公共子序列、单调递增最长子序列
weixin_30834019的博客
04-25 90
单调递增最长子序列 时间限制：3000ms | 内存限制：65535KB 难度：4 描述求一个字符串的最长递增子序列的长度如：dabdbf最长递增子序列就是abdf，长度为4 输入第一行一个整数0<n<20,表示有n个字符串要处理随后的n行，每行有一个字符串，该字符串的长度不会超过10000输出输出字符串的最长递增子序列的长度样例输入 3 aaa...
最长公共字序列（LCS）(转载)(个人感觉外国的算法翻译到国内后，有误！求指点！！！)
YouthDance
11-05 1013
最长公共子序列问题： 给定2个字符串，求其最长公共子串。如abcde和dbada的最长公共字串为bd。 动态规划：dp[i][j]表示A串前i个和B串前j个的最长公共子串的长度。 则 若A[i] == B[j] , dp[i][j] = dp[i-1][j-1] + 1; 否则 dp[i][j] = max(dp[i-1][j],dp[i][j-1]); 时间复杂度O(N*M)。 d
动态规划问题
zlging309的专栏
09-16 510
最大子序列 v.163.com/movie/.../M6UTT5U0I_M6V2U1HL4.html 最大子段和 最长公共子序列 最长递增子序列 最长公共子串 最长公共单调子序列 最大子阵和
单调递增子序列(Longest-Monotonically-Sequence)
Under The Sky
02-07 3090
单调子序列包含有单调递增子序列和递减子序列，不失一般性，这里只讨论单调递增子序列。首先，从定义上明确我们的问题。给定序列a1, a2, …, an，如果存在满足下列条件的子序列ai1i2im, (其中i1即称为一个原序列的长度为m的单调递增子序列，那么，现在的问题是我们要找出一个序列的最长的单调递增子序列。 直观上来说，一个序列Sn，它有2n个子序列，枚举所有的子序列，找出
算法设计与分析（第4版）
qq_35414977的博客
12-11 1262
算法：解决问题的方法或过程程序：算法用某种程序设计语言的具体实现。
LeetCode算法---题型总纲之基础算法
SOLar7SysteM的博客
03-17 585
LeetCode算法—题型总纲之基础算法 基础算法 标题枚举 线性枚举 多维枚举 前缀和 双指针 尺取法（滑动窗口） 链表快慢指针 分而治之 二分查找 点分治 树分治 标题排序 排序算法 比较排序入门 冒泡排序 简单插入排序 简单选择排序 比较排序进阶 归并排序 希尔排序 快速排序 非比较排序 桶排序 计数排序 基数排序 排序API使用 多关键字排序 字典序 结构体排序 标题贪心 区间选择问题 分配问题 贪心背包 区间问题 最小生成树 Prim
2023年求职日记：华为成都OD岗
haimianjie2012的专栏
02-13 3514
这两周的面试过程中，动态库问了两次，先临三维一面和泊松软件2面。需要总结一篇动态库的文章，文章名可以叫《动态库，你真的弄懂了吗》。设计模式总结，比昂芯一面和泊松软件2面都问，“你了解设计模式吗？每一次我都回答，用过单例模式、工厂模式、观察者模式。QT总结，因为现在比较匹配的岗位是C++客户端开发，QT问的也比较多。前面三条只是最重要的三条，面试过程还问了许多问题，在下次集中面试之前，都要一一总结成文。泊松软件二面，被问得超级惨，是重点总结对象。
LeetCode 所有题型总纲
qq_39458487的博客
04-07 554
LeetCode 所有题型总纲 数学基础 简单数学 乘法 除法 幂 对数 阶乘 日期 组合数学 排列组合 排列数 组合数 杨辉三角 错排公式 卡特兰数 组合计数 递推 鸽巢原理 容斥原理 线性代数 高斯消元 矩阵乘法 高等数学 汉明距离 曼哈顿距离 欧几里得距离 辛普森积分 解析几何 距离 汉
最长单调子序列(C语言)--动态规划
一个巨大的博客
05-09 3348
最长单调子序列 题目描述 给出一个由n个数组成的序列x[1…n]，找出它的最长单调上升子序列。 即求最大的m和a1,a2……,am，使得a1<a2<……<am且x[a1]<x[a2]<……<x[am] 解题思路 动态规划的状态表示描述为： m[i]，1≤i≤n，表示以x[i]结尾的最长上升子序列的长度，则问题的解为 max{m[i],1≤i≤n } 假设当前已求...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值