序列比对——needleman wunsch算法及结果呈现

已于 2024-01-02 14:40:24 修改
阅读量1.2k 收藏 9
点赞数 18
文章标签： 算法
于 2024-01-02 14:21:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qwesdqweds/article/details/135337601
版权

基本原理

两条序列每个元素比对无非三种情况：1序列对空，2序列对空，两序列配对。该算法从序列最左端开始，依次按照这三种情况打分，每下一个元素的配对情况都是按照上一个元素的最优解往下的。直到将打分矩阵铺满，打分矩阵右下角的得分情况即说明两序列配对总得分的最优解。再通过路线的回溯得到比对的几种情况。

M[i][j] = max(M[i-1][j]+gap,M[i][j-1]+gap,M[i-1][j-1]+point)

gap:未配对罚分；point：配对得分（包括错配和正确配对）

示例：

将catgt和acgctg按照上面的规则打分

gap=-1 wrong point=-1 point=2

gapcatgt
gap0-1-2-3-4-5
a-1-110-1-1
c-2100-1-2
g-300-121
c-4-1-1-111
t-5-2-2103
g-6-3-3032

将每个得分的来源用箭头表示，发现有三条线路是首尾连通的且分值最大

↘表示配对成功，↓的箭头的位置所在左边的碱基对空，→与前者相对

得分矩阵

BLOSUM62矩阵是经过大量实验验证出来正确性的得分矩阵，相比于PAM矩阵的预测得分来说更符合真实情况。

"BLOSUM62": {
    "AA": "4", "AC": "0", "AD": "-2", "AE": "-1", "AF": "-2", "AG": "0", "AH": "-2", "AI": "-1", "AK": "-1", "AL": "-1", "AM": "-1", "AN": "-2", "AP": "-1", "AQ": "-1", "AR": "-1", "AS": "1", "AT": "0", "AV": "0", "AW": "-3", "AY": "-2", "CA": "0", "CC": "9", "CD": "-3", "CE": "-4", "CF": "-2", "CG": "-3", "CH": "-3", "CI": "-1", "CK": "-3", "CL": "-1", "CM": "-1", "CN": "-3", "CP": "-3", "CQ": "-3", "CR": "-3", "CS": "-1", "CT": "-1", "CV": "-1", "CW": "-2", "CY": "-2", "DA": "-2", "DC": "-3", "DD": "6", "DE": "2", "DF": "-3", "DG": "-1", "DH": "-1", "DI": "-3", "DK": "-1", "DL": "-4", "DM": "-3", "DN": "1", "DP": "-1", "DQ": "0", "DR": "-2", "DS": "0", "DT": "-1", "DV": "-3", "DW": "-4", "DY": "-3", "EA": "-1", "EC": "-4", "ED": "2", "EE": "5", "EF": "-3", "EG": "-2", "EH": "0", "EI": "-3", "EK": "1", "EL": "-3", "EM": "-2", "EN": "0", "EP": "-1", "EQ": "2", "ER": "0", "ES": "0", "ET": "-1", "EV": "-2", "EW": "-3", "EY": "-2", "FA": "-2", "FC": "-2", "FD": "-3", "FE": "-3", "FF": "6", "FG": "-3", "FH": "-1", "FI": "0", "FK": "-3", "FL": "0", "FM": "0", "FN": "-3", "FP": "-4", "FQ": "-3", "FR": "-3", "FS": "-2", "FT": "-2", "FV": "-1", "FW": "1", "FY": "3", "GA": "0", "GC": "-3", "GD": "-1", "GE": "-2", "GF": "-3", "GG": "6", "GH": "-2", "GI": "-4", "GK": "-2", "GL": "-4", "GM": "-3", "GN": "0", "GP": "-2", "GQ": "-2", "GR": "-2", "GS": "0", "GT": "-2", "GV": "-3", "GW": "-2", "GY": "-3", "HA": "-2", "HC": "-3", "HD": "-1", "HE": "0", "HF": "-1", "HG": "-2", "HH": "8", "HI": "-3", "HK": "-1", "HL": "-3", "HM": "-2", "HN": "1", "HP": "-2", "HQ": "0", "HR": "0", "HS": "-1", "HT": "-2", "HV": "-3", "HW": "-2", "HY": "2", "IA": "-1", "IC": "-1", "ID": "-3", "IE": "-3", "IF": "0", "IG": "-4", "IH": "-3", "II": "4", "IK": "-3", "IL": "2", "IM": "1", "IN": "-3", "IP": "-3", "IQ": "-3", "IR": "-3", "IS": "-2", "IT": "-1", "IV": "3", "IW": "-3", "IY": "-1", "KA": "-1", "KC": "-3", "KD": "-1", "KE": "1", "KF": "-3", "KG": "-2", "KH": "-1", "KI": "-3", "KK": "5", "KL": "-2", "KM": "-1", "KN": "0", "KP": "-1", "KQ": "1", "KR": "2", "KS": "0", "KT": "-1", "KV": "-2", "KW": "-3", "KY": "-2", "LA": "-1", "LC": "-1", "LD": "-4", "LE": "-3", "LF": "0", "LG": "-4", "LH": "-3", "LI": "2", "LK": "-2", "LL": "4", "LM": "2", "LN": "-3", "LP": "-3", "LQ": "-2", "LR": "-2", "LS": "-2", "LT": "-1", "LV": "1", "LW": "-2", "LY": "-1", "MA": "-1", "MC": "-1", "MD": "-3", "ME": "-2", "MF": "0", "MG": "-3", "MH": "-2", "MI": "1", "MK": "-1", "ML": "2", "MM": "5", "MN": "-2", "MP": "-2", "MQ": "0", "MR": "-1", "MS": "-1", "MT": "-1", "MV": "1", "MW": "-1", "MY": "-1", "NA": "-2", "NC": "-3", "ND": "1", "NE": "0", "NF": "-3", "NG": "0", "NH": "1", "NI": "-3", "NK": "0", "NL": "-3", "NM": "-2", "NN": "6", "NP": "-2", "NQ": "0", "NR": "0", "NS": "1", "NT": "0", "NV": "-3", "NW": "-4", "NY": "-2", "PA": "-1", "PC": "-3", "PD": "-1", "PE": "-1", "PF": "-4", "PG": "-2", "PH": "-2", "PI": "-3", "PK": "-1", "PL": "-3", "PM": "-2", "PN": "-2", "PP": "7", "PQ": "-1", "PR": "-2", "PS": "-1", "PT": "-1", "PV": "-2", "PW": "-4", "PY": "-3", "QA": "-1", "QC": "-3", "QD": "0", "QE": "2", "QF": "-3", "QG": "-2", "QH": "0", "QI": "-3", "QK": "1", "QL": "-2", "QM": "0", "QN": "0", "QP": "-1", "QQ": "5", "QR": "1", "QS": "0", "QT": "-1", "QV": "-2", "QW": "-2", "QY": "-1", "RA": "-1", "RC": "-3", "RD": "-2", "RE": "0", "RF": "-3", "RG": "-2", "RH": "0", "RI": "-3", "RK": "2", "RL": "-2", "RM": "-1", "RN": "0", "RP": "-2", "RQ": "1", "RR": "5", "RS": "-1", "RT": "-1", "RV": "-3", "RW": "-3", "RY": "-2", "SA": "1", "SC": "-1", "SD": "0", "SE": "0", "SF": "-2", "SG": "0", "SH": "-1", "SI": "-2", "SK": "0", "SL": "-2", "SM": "-1", "SN": "1", "SP": "-1", "SQ": "0", "SR": "-1", "SS": "4", "ST": "1", "SV": "-2", "SW": "-3", "SY": "-2", "TA": "0", "TC": "-1", "TD": "-1", "TE": "-1", "TF": "-2", "TG": "-2", "TH": "-2", "TI": "-1", "TK": "-1", "TL": "-1", "TM": "-1", "TN": "0", "TP": "-1", "TQ": "-1", "TR": "-1", "TS": "1", "TT": "5", "TV": "0", "TW": "-2", "TY": "-2", "VA": "0", "VC": "-1", "VD": "-3", "VE": "-2", "VF": "-1", "VG": "-3", "VH": "-3", "VI": "3", "VK": "-2", "VL": "1", "VM": "1", "VN": "-3", "VP": "-2", "VQ": "-2", "VR": "-3", "VS": "-2", "VT": "0", "VV": "4", "VW": "-3", "VY": "-1", "WA": "-3", "WC": "-2", "WD": "-4", "WE": "-3", "WF": "1", "WG": "-2", "WH": "-2", "WI": "-3", "WK": "-3", "WL": "-2", "WM": "-1", "WN": "-4", "WP": "-4", "WQ": "-2", "WR": "-3", "WS": "-3", "WT": "-2", "WV": "-3", "WW": "11", "WY": "2", "YA": "-2", "YC": "-2", "YD": "-3", "YE": "-2", "YF": "3", "YG": "-3", "YH": "2", "YI": "-1", "YK": "-2", "YL": "-1", "YM": "-1", "YN": "-2", "YP": "-3", "YQ": "-1", "YR": "-2", "YS": "-2", "YT": "-2", "YV": "-1", "YW": "2", "YY": "7"
  },
"ATCG": {
  "AA": 2, "AT": -1, "AC": -1, "AG": -1,
  "TA": -1, "TT": 2, "TC": -1, "TG": -1,
  "CA": -1, "CT": -1, "CC": 2, "CG": -1,
  "GA": -1, "GT": -1, "GC": -1, "GG": 2
}

代码思路

路径生成

在得分矩阵每一个分值生成时，判断其分值的来源，考虑存在多个来源的情况，生成一个表示去向的矩阵，由xyz分别表示下，右，右下，无路可走就用空集表示，由于最左上角一定可以往右或往下，方便起见，在初始的方位矩阵左上角手动加上y和x。将方位储存在road里

gap = -2
seq1 = '-'+seq1
seq2 = '-'+seq2    #由于在打分时要对序列“前一个”不存在的碱基比对，因此加上“-”
martix = [[(i*gap)+(j*gap) for i in range(len(seq1))]for j in range(len(seq2))]#生成打分矩阵的第一行和第一列，其余部分由于后面会被修正，所以可以不用管
road = [[[] for i in seq1] for j in seq2]
len1 = len(seq1)
len2 = len(seq2)

for i in range(1,len2):
    for j in range(1,len1):
        score_from_left = martix[i][j - 1] + gap
        score_from_diag = martix[i - 1][j - 1] + int(a[f'{seq1[j]}{seq2[i]}'])
        score_from_up = martix[i - 1][j] + gap
        maxim=max(martix[i][j-1]+gap,martix[i-1][j-1]+int(a[f'{seq1[j]}{seq2[i]}']),martix[i-1][j]+gap)

        #判断分值来源
        if maxim == score_from_left:
            road[i][j-1].append('y')
        if maxim == score_from_diag:
            road[i-1][j-1].append('z')
        if maxim == score_from_up:
            road[i-1][j].append('x')

        #生成打分矩阵
        martix[i][j]=max(martix[i][j-1]+gap,martix[i-1][j-1]+int(a[f'{seq1[j]}{seq2[i]}']),martix[i-1][j]+gap)

#手动给左上角加上右和下方向
road[0][0].append('x')
road[0][0].append('y')

深度优先算法寻找所有比对可能性

关于深度优先算法，简而言之就是走迷宫从入口开始一直贴着右边墙壁或者左边墙壁走，在上面有箭头的图自己走走试试看

def find_path(martix):
    paths = []
    def depth_first(r, l, current_path):
        
        #如果到达右下角，把路径记录下来，return即出栈
        if r == len(martix) - 1 and l == len(martix[1]) - 1:
            paths.append(current_path)
            return

        #识别到相关方位，即朝着此方位前进
        for i in martix[r][l]:
            if i == 'y' and l < len(martix[1]) - 1:
                depth_first(r, l + 1, current_path + ['y'])#这一句包括了堆栈操作
            elif i == 'x' and r < len(martix) - 1:
                depth_first(r + 1, l, current_path + ['x'])
            elif i == 'z' and l < len(martix[1]) - 1 and r < len(martix) - 1:
                depth_first(r + 1, l + 1, current_path + ['z'])

    depth_first(0, 0, [])
    return paths

输出的结果是若干条线路，从左上角出发，按照xyz到右下角的线路

按照线路输出比对结果

这段代码比较简单，不多赘述

a = len(find_path(road))
r1 = {i:'' for i in range(a) }
r2 = {i:'' for i in range(a) }
for i in range(len(find_path(road))):
    x = 0
    y = 0
    for j in find_path(road)[i]:
        if j == 'x':
            r1[i] = r1[i]+'-'
            r2[i] = r2[i]+seq2[y+1]
            y+=1
        elif j == 'y':
            r2[i] = r2[i]+'-'
            r1[i] = r1[i]+seq1[x+1]
            x+=1
        elif j == 'z':
            r1[i] = r1[i]+seq1[x+1]
            r2[i] = r2[i]+seq2[y+1]
            x += 1
            y += 1

总代码如下

import json
def blastp(seq1,seq2):
    def find_path(martix):
        paths = []
        def depth_first(r, l, current_path):
            if r == len(martix) - 1 and l == len(martix[1]) - 1:
                paths.append(current_path)
                return
            for i in martix[r][l]:
                if i == 'y' and l < len(martix[1]) - 1:
                    depth_first(r, l + 1, current_path + ['y'])
                elif i == 'x' and r < len(martix) - 1:
                    depth_first(r + 1, l, current_path + ['x'])
                elif i == 'z' and l < len(martix[1]) - 1 and r < len(martix) - 1:
                    depth_first(r + 1, l + 1, current_path + ['z'])
        depth_first(0, 0, [])
        return paths

    with open('/juzhen.json', 'r') as BLOSUM:
        a = json.load(BLOSUM)['BLOSUM62']         #根据需要更改

    gap = -2           #根据需要更改
    seq1 = '-'+seq1
    seq2 = '-'+seq2
    martix = [[(i*gap)+(j*gap) for i in range(len(seq1))]for j in range(len(seq2))]
    len1 = len(seq1)
    len2 = len(seq2)
    road = [[[] for i in seq1] for j in seq2]
    road[0][0].append('x')
    for i in range(1,len2):
        for j in range(1,len1):
            score_from_left = martix[i][j - 1] + gap
            score_from_diag = martix[i - 1][j - 1] + int(a[f'{seq1[j]}{seq2[i]}'])
            score_from_up = martix[i - 1][j] + gap
            maxim=max(martix[i][j-1]+gap,martix[i-1][j-1]+int(a[f'{seq1[j]}{seq2[i]}']),martix[i-1][j]+gap)
            if maxim == score_from_left:
                road[i][j-1].append('y')
            if maxim == score_from_diag:
                road[i-1][j-1].append('z')
            if maxim == score_from_up:
                road[i-1][j].append('x')
            martix[i][j]=max(martix[i][j-1]+gap,martix[i-1][j-1]+int(a[f'{seq1[j]}{seq2[i]}']),martix[i-1][j]+gap)
    road[0][0].append('y')

    a = len(find_path(road))
    r1 = {i:'' for i in range(a) }
    r2 = {i:'' for i in range(a) }
    for i in range(len(find_path(road))):
        x = 0
        y = 0
        for j in find_path(road)[i]:
            if j == 'x':
                r1[i] = r1[i]+'-'
                r2[i] = r2[i]+seq2[y+1]
                y+=1
            elif j == 'y':
                r2[i] = r2[i]+'-'
                r1[i] = r1[i]+seq1[x+1]
                x+=1
            elif j == 'z':
                r1[i] = r1[i]+seq1[x+1]
                r2[i] = r2[i]+seq2[y+1]
                x += 1
                y += 1
    print(r1)
    print(r2)

seq1 = ''    #在这里输入蛋白质序列
seq2 = ''

print(blastp(seq1,seq2))

此算法精度极高，但是一般不用于较长的序列，因为时间复杂度较高，且会将所有结果都显示出来。当空位罚分<-2时运行速度较快

励志成为生信高手
关注
Needleman-Wunsch:Needleman-Wunsch算法的实现
05-20
R中的Needleman-Wunsch 这是一个R包，用于实现Needleman和Wunsch序列比对，并使用testthat单元测试框架进行了单元测试。 安装： 使用devtools ： devtools::install_github("hiraethus/Needleman-Wunsch") 用法示例...
【基因序列比对】Needleman-Wunsch算法
mountains_L的博客
09-15 6129
前言 最近加入了一个研究基因大数据的项目组，要学习基因相关知识QAQ，所以开始一个新系列梳理知识和激励自己学习。 本系列参考了https://zhuanlan.zhihu.com/p/54142276 Needleman-Wunsch算法 Needleman-Wunsch算法是基于动态规划的算法，记不清楚的可以看下我之前的动态规划的文章，简单总结就是将一个问题分解为很多相互联系并且逐渐扩大的小问题，依次解决使问题规模逐渐扩大，最终获得问题的解。 DNA有三种情况可能导致两个序列不同： SNP单核酸多态性，
序列比对之Needleman-wunsch算法的python实现
Faker_Skt_K1的博客
07-17 2411
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdow
生物信息学（1）——双序列比对之Needleman-Wunsch(NW)算法详解及C++实现
热门推荐
baidu_41860619的博客
06-20 2万+
1. 什么是序列比对 所谓的序列比对，就是两个或者多个序列按照碱基排列进行比较，从而反映片段之间的相似性和阐明序列的同源性。这里主要是将未知功能的序列与已知序列进行比对，从而确定序列分析。序列比对的基本思想是，基于生物学中序列决定结构，结构决定功能的普遍规律，将核酸序列和蛋白质一级结构上的序列都看成由基本字符组成的字符串，检测序列之间的相似性，发现生物序列中的功能、结构和进化的信息 2. 引入序列比对的原因 对于两种相似的序列，DNA复制一共有三种情况可能导致两个序列不同: (1)SNP(单核苷酸多态性)，
【序列匹配算法】Needleman Wunsch算法 v2.0
qq_54501547的博客
11-15 3251
Needleman Wunsch算法 v2.0 可以返回所有匹配结果而不只是一条 基于非递归的图搜索思想
【R语言双序列比对】全局比对Needleman-Wunsch算法&局部比对Smith-Waterman算法原理及代码实现
qq_65680034的博客
11-24 2159
全局比对和局部比对的显著区别是局部比对的得分矩阵中的分值均≥0，即在考虑打分方式时，局部比对要多考虑一种。在初始化得分矩阵的第一行和第一列时，两者有不同。对于全局比对，需要依次加上gap罚分值，而对于局部比对，则只需要都初始化为0。全局比对和局部比对的核心思想是依次寻求重复子问题的最优子结构，通过序列比对，可以发现序列之间的相似性，也可以判别序列之间的同源性，推断序列之间的进化关系，辨别序列之间的差别，寻找遗传变异。
（六）R语言生物序列比对——Needleman-Wunsch全局比对算法
EricFrenzy的博客
08-15 4410
目录实现原理与代码全部代码结束语 实现原理与代码 生物序列全局比对的主要目的是发现两个序列之间的相似度，从而估测二者的进化联系或相似功能。Needleman-Wunsch全局比对算法用到了动态规划(Dynamic Programming)的原理。它的主要工作流程见下图： 在介绍具体算法前，我们先要定义一个得分矩阵。得分矩阵的目的是告诉程序某两个碱基配对的得分： match <- 2 mismatch <- -1 gap <- -2 scoreMat <- matrix(misMa
动态编程之序列比对：Needleman-Wunsch 算法和Smith-Waterman算法
进阶的码农小白
03-29 1万+
1. 加分规则S（a,b) = 10 (a=b）S（a,b) = -3（a!=b）S（a,b) = -5（a='_' or b='_')通常DNA和RNA，Protein都有打分矩阵，Protein常用打分矩阵BLOSUM622. 动态规划算法：全局比对算法Needleman-Wunsch思路：从第一个到最后一个，一个个比，一条序列比个遍，然后得出最优解example：局部比对Smith-Wate...
异构集群系统上的分布式并行Needleman-Wunsch算法
04-26
首先，以最优匹配结果为基础的needleman-wunsch算法被认为是解决序列比对问题的基本算法。 尽管如此，由于序列数据库容量指数的结果逐年增加，并且时间和空间复杂度的算法较高，所以O（m * n）。 面对这些问题，研究...
【多序列比对】应用动态规划、A*算法、遗传算法分别解决MSA问题
02-25
动态规划是解决多序列比对的经典方法，以Smith-Waterman和Needleman-Wunsch算法为代表。这些算法通过构建一个二维矩阵，矩阵的每个元素代表两序列对应位置的匹配得分。通过递推关系填充矩阵，并寻找最优路径，得到...
双序列全局比对算法与双序列局部比对算法
07-05
使用Perl编程语言实现了双序列全局比对Needleman Wunsch算法，以及双序列局部比对Smith Waterman算法。该资源也可在github上下载：https://github.com/GouXiangJian/two_seq_alignment
序列比对-Needleman-Wunsch Smith-Waterman algorthm(java)
03-04
序列比对-Needleman-Wunsch Smith-Waterman 算法（java） 序列比对是基因学的一个主要主题，它涉及到比较 DNA 序列并尝试找出两个序列的公共部分。如果两个 DNA 序列有类似的公共子序列，那么这些两个序列很可能是...
Needleman-Wunsch全局序列比对算法
qq_51287641的博客
06-22 3434
Needleman-Wunsch全局序列比对算法
序列比对算法-计算生物学
SoundSlow的博客
10-08 1万+
1.序列比对指将两个或多个序列排列在一起，标明其相似之处。序列中可以插入间隔（通常用短横线“-”表示）。对应的相同或相似的符号（在核酸中是A, T(或U), C, G，在蛋白质中是氨基酸残基的单字母表示）排列在同一列上。这一方法常用于研究由共同祖先进化而来的序列，特别是如蛋白质序列或DNA序列等生物序列。进行相似度分析。 2.分类 全局比对：将两个序列中的所有字符都进行依次比对，由于各方面的缺陷，
文本比较算法Ⅱ——Needleman/Wunsch算法
weixin_33830216的博客
06-03 467
　　在“文本比较算法Ⅰ——LD算法”中介绍了基于编辑距离的文本比较算法——LD算法。 　　本文介绍基于最长公共子串的文本比较算法——Needleman/Wunsch算法。 　　还是以实例说明：字符串A=kitten，字符串B=sitting 　　那他们的最长公共子串为ittn（注：最长公共子串不需要连续出现，但一定是出现的顺序一致），最长公共子串长度为4。 　　 　　定义： 　　LCS...
20220530-动态规划算法及Needleman-Wunsch算法
weixin_44719529的博客
06-03 1755
文章目录前言一、动态规划原理1、定义2、特点1）针对机器学习算法而言：不需要大量数据和足够的特征值2）相对于BFS和DFS、贪心算法而言：3）3、切钢材3、代码实现增加装饰器----加快递归速度：二、编辑距离1、定义及原理2、代码实现三、Needleman-Wunsch 算法1、定义2、原理1）得分矩阵--score_matrix2）回溯矩阵3、完整代码实现四、 喝水不忘挖井人（感谢各位大佬给予学习思路） 前言 本文主要是通过讲动态规划的原理，（最简单的是切钢材），应用于NLP中，常见的是编辑距离，在生物
Needleman–Wunsch algorithm
ytfy339784578的专栏
05-28 902
尼德曼-翁施算法 这是一种对两个序列的相似性进行对比的算法(比如基因序列对比、蛋白质序列对比) 偶尔看到一个硬件spec上有写对smith-waterman算法的优化，然后好奇学习了一下，结果就看到了它的爷爷needleman-wunsch算法。简单记录一下 1. 对于两个序列首先形成如下带空行、空列矩阵，头一个空格置0 GCATGCG GATTACA G C A T G C G 0 -1 -2 -3 -4
实现序列全局对比（Needleman-Wunsch ）（perl）
qq_45091883的博客
05-29 2221
这篇博客我写了简单和中等难度两个比对方法 1.简单的动态规划，得出基因的最短编辑距离 简介在注释中，代码如下： #!/usr/bin/perl -w use strict; use autodie; #这个程序就是一个简单的动态规划，它只能算出最短的编辑距离，理论上与Needleman-Wunsch 算法相似 #不同的是，这个dp矩阵存的是最短编辑距离，而Needleman-Wunsch 算法的dp矩阵存的是得分情况 #这题的思想是，dp矩阵第一行与第一列都是代表某一条序列对上一条空序列，所以距离逐渐加一
904. 水果成篮
最新发布
YQ20210216的博客
09-27 350
转化，找出一个最长的子数组长度，子数组中不超过两种类型的水果，要记录水果类型和水果数量，所以要使用unord_map，key来记录水果中类，valuse记录水果数量，当right开始增加的时候，将水果种类加入到哈希表中，当水果中类超过两种时，控制left使得水果种类回到两种。你想要尽可能多地收集水果。你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组。，返回你可以收集的水果的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值