OJ---公共字符串

题目描述

计算两个字符串的最大公共子串的长度，字符不区分大小写

输入描述

输出描述

输入两个字符串

输入例子

asdfas werasdfaswer

输出例子

6

 这类问题一般都是考察  /*动态规划*/

//本题目不区分大小写，所以第一步先利用string.toLowerCase();(统一变成小写或者大写在进行判断)

方法一：用一个字符串的char去遍历，找的话sum++；并标记该char在两个字符串中分别的位置（k,z），结束改循环break；直接进行两个字符串下一个char的判断，要是不匹配，sum=0;重新计数，最后取最大值即可。

import java.util.*;

public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
while(sc.hasNext()){
String s1=sc.next();
String s2=sc.next();
System.out.print(match(s1,s2));
}
sc.close();
}
public static int match(String ss1,String ss2){
	String s1=ss1.toLowerCase();
	String s2=ss2.toLowerCase();
char[] ch1=s1.toCharArray();
char[] ch2=s2.toCharArray();
    int sum=0;
    int curr=0;

if(ch1.length<=0||ch2.length<=0){
	return 0;
}
int k=-1;
int z=-1;
for(int i=k+1;i<ch1.length;i++){
	//int k=0;
	for(int j=z+1;j<ch2.length;j++){
		if(ch1[i]==ch2[j]){
			k=i;
			z=j;
			curr++;
			sum=sum>curr?sum:curr;

			break;
			
		}	else{
			curr=0;
			sum=sum>curr?sum:curr;

		}
		sum=sum>curr?sum:curr;

	}	
	
}
return sum;
}
}

方法二：动态规划（二维数组）

  /**     * 动态规划算法     * <pre>     * 事实上，最长公共子序列问题也有最优子结构性质。     * 记:     * Xi=﹤x1，⋯，xi﹥即X序列的前i个字符 (1≤i≤m)（前缀）     * 假定Z=﹤z1，⋯，zk﹥∈LCS(X , Y)。     *     * 若xm=yn（最后一个字符相同），则不难用反证法证明：该字符必是X与Y的任一最长公共子序列Z（设长度为k）的最后一个字符，     * 即有zk = xm = yn 且显然有Zk-1∈LCS(Xm-1 , Yn-1)即Z的前缀Zk-1是Xm-1与Yn-1的最长公共子序列。此时，问题化归成     * 求Xm-1与Yn-1的LCS（LCS(X , Y)的长度等于LCS(Xm-1 , Yn-1)的长度加1）。     *     * 若xm≠yn，则亦不难用反证法证明：要么Z∈LCS(Xm-1, Y)，要么Z∈LCS(X , Yn-1)。由于zk≠xm与zk≠yn其中至少有一个必     * 成立，若zk≠xm则有Z∈LCS(Xm-1 , Y)，类似的，若zk≠yn 则有Z∈LCS(X , Yn-1)。此时，问题化归成求Xm-1与Y的LCS及     * X与Yn-1的LCS。LCS(X , Y)的长度为：max{LCS(Xm-1 , Y)的长度, LCS(X , Yn-1)的长度}。     *     * 由于上述当xm≠yn的情况中，求LCS(Xm-1 , Y)的长度与LCS(X , Yn-1)的长度，这两个问题不是相互独立的：两者都需要求     * LCS(Xm-1，Yn-1)的长度。另外两个序列的LCS中包含了两个序列的前缀的LCS，故问题具有最优子结构性质考虑用动态规划法。     * 也就是说，解决这个LCS问题，你要求三个方面的东西：     *      1、LCS（Xm-1，Yn-1）+1；     *      2、LCS（Xm-1，Y），LCS（X，Yn-1）；     *      3、max{LCS（Xm-1，Y），LCS（X，Yn-1）}。     * 所以解决这个问题的动态转移方程即：     *      if xm==yn  LCS(Xm,Yn)= LCS（Xm-1，Yn-1）+1;     *      if xm!=yn LCS(Xm,Yn)=  max{LCS（Xm-1，Yn),LCS（Xm，Yn-1)};     * </pre>     *     * @param a     * @param b     * @return     */
    private static int maxSubsequenceLength(String a, String b) {

        int aLen = a.length() + 1;
        int bLen = b.length() + 1;

        // 初始值默认为0
        int[][] f = new int[aLen][bLen];


        for (int i = 1; i < aLen; i++) {
            for (int j = 1; j < bLen; j++) {
                if (a.charAt(i - 1) == b.charAt(j - 1)) {
                    f[i][j] = f[i - 1][j - 1] + 1;
                } else {
                    f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);
                }
            }
        }

        return f[aLen - 1][bLen - 1];
    }
}

Java:

import java.util.*;
//asdfas werasdfaswer
public class test{
	public static void main(String[] args){
		Scanner sc=new Scanner (System.in);
		while(sc.hasNext()){
			String s1=sc.next();
			String s2=sc.next();
			System.out.println(match(s1,s2));
			
		}sc.close();
	}
	private static int match(String s1,String s2){
		
		int[][] arr=new int[s1.length()+1][s2.length()+1];
		int start,length;
		for(int i=0;i<s1.length();i++){
			for(int j=0;j<s2.length();j++){
			if(s1.charAt(i)==s2.charAt(j)){
				arr[i+1][j+1]=arr[i][j]+1;
			}else{
				arr[i+1][j+1]=Math.max(arr[i][j+1], arr[i+1][j]);
			}
		}}
		
		return arr[s1.length()][s2.length()];
	}
}