最长公共子序列,最长公共子串

 

最长公共子序列(可以断续)

0 0 0 0 0 0 0 0 
0 1 1 1 1 1 1 1 
0 1 2 2 2 2 2 2 
0 1 2 3 3 3 3 3 
0 1 2 3 4 4 4 4 
0 1 2 3 4 4 4 4 
0 1 2 3 4 4 5 5 
0 1 2 3 4 4 5 6 
package com.lzg.flume.intercepter;

import java.util.ArrayList;
import java.util.List;

public class LCS {
    public static List<String> getLCSstring(char[] str1, char[] str2) {
        int n = str1.length, m = str2.length;
        int[][] dp = new int[100][100];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (str1[i - 1] == str2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }

        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= m; j++) {
                System.out.print(dp[i][j] + " ");
            }
            System.out.println();
        }

        String res= "";
        for (int i = n, j = m; i >= 1 && j >= 1; ) {
            if (str1[i - 1] == str2[j - 1]) {
                String x = String.valueOf(str1[i - 1]);
//                res+=x;//不需要重新赋值
                res = res.concat(x); //连接之后必须是返回的新字符串,并赋给res索引,否则res一直不变化
                i--;
                j--;
            } else {
                if (dp[i][j - 1] >= dp[i - 1][j]) {
                    j--;
                } else {
                    i--;
                }
            }
        }
        System.out.println(new StringBuilder(res).reverse().toString());
        return null;
    }

    public static void main(String[] args) {
        String str1 = "qwuio123qw", str2 = "uio789qw";
        getLCSstring(str1.toCharArray(), str2.toCharArray());
    }

}

最长公共子串(必须连续)

方法1 按照上面代码的继承

0 0 0 0 0 0 0 0 
0 1 1 1 1 1 1 1 
0 1 2 2 2 2 2 2 
0 1 2 3 3 3 3 3 
0 1 2 3 4 4 4 4 
0 1 2 3 4 4 4 4 
0 1 2 3 4 4 5 5 
0 1 2 3 4 4 5 6 
package com.lzg.flume.intercepter;

import java.util.List;

public class LCS1 {
    public static List<String> getLCSstring(char[] str1, char[] str2) {
        int n = str1.length, m = str2.length;
        int[][] dp = new int[100][100];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (str1[i - 1] == str2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]);
                }
            }
        }

        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= m; j++) {
                System.out.print(dp[i][j] + " ");
            }
            System.out.println();
        }

        String res = "";
        int max = 0;
        String maxRes = "";
        for (int i = n, j = m; i >= 1 && j >= 1; ) {
            if (str1[i - 1] == str2[j - 1]) {
                String x = String.valueOf(str1[i - 1]);
                res += x;
                i--;
                j--;
            } else {
                res = "";
                if (dp[i][j - 1] >= dp[i - 1][j]) {
                    j--;
                } else {
                    i--;
                }
            }
            int num = res.length();
            if (num > max) {
                max = num;
                maxRes = res;
            }
        }
        System.out.println(new StringBuilder(maxRes).reverse().toString());
        return null;
    }

    public static void main(String[] args) {
        String str1 = "1234567tlkjhgqwuioa", str2 = "1234567ylkjhguioa";
        getLCSstring(str1.toCharArray(), str2.toCharArray());
    }

}

方法2
 

 

 

 

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
最长公共子序列(Longest Common Subsequence, LCS)和最长公共子串(Longest Common Substring)是两个常见的字符相关问题。 最长公共子序列是指给定两个字符,要求找到它们之间最公共子序列长度子序列是从原字符中删除若干个字符而得到的新字符,字符在新字符中的相对顺序与原字符中的保持一致。动态规划是求解LCS问题的常用方法。 以字符s1 = "ABCBDAB"和s2 = "BDCAB"为例,可以使用动态规划的方法求解最长公共子序列长度。首先创建一个二维数组dp,dp[i][j]表示s1的前i个字符和s2的前j个字符之间的最长公共子序列长度,那么有以下推导关系: 1. 当i=0或j=0时,dp[i][j]=0。 2. 当s1[i-1]=s2[j-1]时,dp[i][j] = dp[i-1][j-1] + 1。 3. 当s1[i-1]!=s2[j-1]时,dp[i][j] = max(dp[i-1][j], dp[i][j-1])。 最后,dp[len(s1)][len(s2)]即为最长公共子序列长度。 对于最长公共子串,要求找到两个字符中最公共连续子长度。连续子是指在原字符中连续出现的字符子序列。同样可以使用动态规划来解决该问题。 仍以上述两个字符s1和s2为例,创建一个二维数组dp,dp[i][j]表示以s1[i-1]和s2[j-1]为结尾的公共长度,那么有以下推导关系: 1. 当i=0或j=0时,dp[i][j]=0。 2. 当s1[i-1]=s2[j-1]时,dp[i][j] = dp[i-1][j-1] + 1。 3. 当s1[i-1]!=s2[j-1]时,dp[i][j] = 0。 最后,dp矩阵中的最大值即为最长公共子串长度。 以上就是求解最长公共子序列最长公共子串的常见方法。在实际应用中,我们可以根据具体的问题选择合适的方法,并结合动态规划来解决这些字符相关的问题。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值