Poj 3356 ACGT（LCS 或 带备忘的递归）

题意：把一个字符串通过增、删、改三种操作变成另外一个字符串，求最少的操作数。

分析：

• 可以用LCS求出最大公共子序列，再把两个串中更长的那一串中不是公共子序列的部分删除。

• 分析可知两个字符串的距离肯定不会超过它们的长度之和，因为我们可以通过删除操作把两个串化为空串。如果两个字符串的第一个元素相同，则求A[2...ALen]和B[2...BLen]即可，如果不相同，则逐一分析增、删、改对下一步的影响：

1. 删除A串的第一个字符，然后计算A[2...ALen]和B[1...BLen]即可。
2. 删除B串的第一个字符，然后计算A[1...ALen]和B[2...BLen]即可。
3. 修改A串的第一个字符，然后计算A[2...ALen]和B[2...BLen]即可。
4. 修改B串的第一个字符，然后计算A[2...ALen]和B[2...BLen]即可。
5. 增加A串的第一个字符到B串，然后计算A[2...ALen]和B[1...BLen]即可。
6. 增加B串的第一个字符到A串，然后计算A[1...ALen]和B[2...BLen]即可。

总之，一步操作以后，会出现三种情况，A[2...ALen]和B[1...BLen]，A[1...ALen]和B[2...BLen]，A[2...ALen]和B[2...BLen]，这样可以用递归求解了。但是递归求解时有些数据会被重复计算，所以使用一个二维数组来记录已经计算过的情况。

其实，这两个解法的本质是相同的，不过分析的角度不一样。递归可以改成非递归的形式，会和LCS的dp解法大同小异。

LCS:

package LCS;

import java.util.Scanner;

public class Poj_ACGT {
	static int[][] dp=new int[1001][1001];
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		while(sc.hasNext()){
			for(int i=0;i<1001;i++){
				for(int j=0;j<1001;j++){
					dp[i][j]=0;
				}
			}
			int sLen=sc.nextInt();
			String s=sc.next();
			int tLen=sc.nextInt();
			String t=sc.next();
			
			for(int i=1;i<=sLen;i++){
				for(int j=1;j<=tLen;j++){
					if(s.charAt(i-1)==t.charAt(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]);
				}
			}
			System.out.println(Math.max(sLen, tLen)-dp[sLen][tLen]);
		}
	}
}

带备忘的递归：

package Recursive;

import java.util.Scanner;


/**
 * Memory:9136K Time:219MS
 */
public class Poj_AGTC {
	static int[][] dp=new int[1001][1001];
	public static int count(String s,int sB,int sE,String t,int tB,int tE){
		if(sB > sE){
			if(tB>tE){
				return 0;
			}else{
				return tE-tB+1;
			}
		}
		if(tB>tE){
			if(sB > sE){
				return 0;
			}else{
				return sE-sB+1;
			}
		}
		if(s.charAt(sB) == t.charAt(tB)){
			if(dp[sB+1][tB+1] == 0){
				dp[sB+1][tB+1]=count(s,sB+1,sE,t,tB+1,tE);
			}
			return dp[sB+1][tB+1];
		}else{
			if(dp[sB][tB+1] == 0){
				dp[sB][tB+1]=count(s,sB,sE,t,tB+1,tE);
			}
			if(dp[sB+1][tB] == 0){
				dp[sB+1][tB]=count(s,sB+1,sE,t,tB,tE);
			}
			if(dp[sB+1][tB+1] == 0){
				dp[sB+1][tB+1]=count(s,sB+1,sE,t,tB+1,tE);
			}
			int min=Math.min(dp[sB][tB+1], dp[sB+1][tB]);
			min=Math.min(min, dp[sB+1][tB+1]);
			return min+1;
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		while(sc.hasNext()){
			for(int i=0;i<1001;i++){
				for(int j=0;j<1001;j++){
					dp[i][j]=0;
				}
			}
			int sLen=sc.nextInt();
			String s=sc.next();
			int tLen=sc.nextInt();
			String t=sc.next();
			System.out.println(count(s,0,sLen-1,t,0,tLen-1));
		}
	}
}

版权声明：本文为博主原创文章，未经博主允许不得转载。

转载于:https://www.cnblogs.com/AndyDai/p/4734102.html