题目:
给出两个字串A,B。将A字串转化为B字串,转化一共有两种方式:删除连续的n个字符,一次操作费用为2。增加连续的n个字符(增加的字符是什么由你决定),一次操作费用为n+2。求把A变为B最小费用。
输入:
第一行输入一个正整数T(1 <= T <= 10),表示有T组测试数据。
对于每组测试数据:
两行字符串A, B(字符串长度不超过2000,字符仅包含小写字母)
输出:
对于每组测试数据,输出一行一个整数,表示最小费用。
样例输入:
2
dsafsadfadf
fdfd
aaaaaaaa
bbbbbbbb
样例输出:
7
12
答案提示:
“dsafsadfadf” 变成 “fdfd” 最少的代价的一种方法是:
1. “dsafsadfadf” -> “f” 删除连续的10个,代价2
2. “f” -> “fdfd” 增加连续的3个(”dfd”),代价为3 + 2 = 5
总共的最小代价为2 + 5 = 7,其他方法的代价都不小于7
“aaaaaaaa” 变成 “bbbbbbbb” 最小代价的一种方法是:
1. “aaaaaaaa” 全部删除,代价2
2. 增加8个连续的’b’,代价10
总共的最小代价为2 + 10 = 12
注意,有些最优的方案可能要做多次的删除和增加操作,不限于两次。
这是一个比较典型的动态规划的题目:
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int a=sc.nextInt();
String[] buff=new String[a*2];
int i=0;
sc.nextLine(); //为了清除到 nextInt截取之后的空格
//sc.next()方法是以换行或者空格符为分界线接收下一个String类型变量
while(true)
{
buff[i]=sc.nextLine();
System.out.println("调试: "+buff[i]);
i+=1;
if(a*2==i) break;
}
for(int j=0;j<a;j++)
{
System.out.println(GetMinExpenses(buff[j*2],buff[j*2+1]));
}
}
public static int DEL = -1;
public static int ORIGAL = 0;
public static int ADD = 1;
public static int getAddCount(int f, int type) {
int minCost;
if (type == ADD) {
minCost = f + 1;
} else {
minCost = f + 3;
}
return minCost;
}
public static int getDelCount(int f, int type) {
int minCost = 0;
if (type == DEL) {
minCost = f + 0;
} else {
minCost = f + 2;
}
return minCost;
}
public static int getMin(int a, int b) {
return a < b ? a : b;
}
public static int GetMinExpenses(String aString, String bString) {
int[][] f = new int[aString.length() + 1][bString.length() + 1];//f[i][j] 从a[i] -> b[j]的最小代价
f[0][0] = 0;
int operator[][] = new int[aString.length() + 1][bString.length() + 1];//用于记录操作
for (int i = 1; i < aString.length() + 1; i++) {
f[i][0] = 2;
operator[i][0] = DEL;
}
for (int i = 1; i < bString.length() + 1; i++) {
f[0][i] = 2 + i;
operator[0][i] = ADD;
}
int type = ORIGAL;
for (int i = 1; i < aString.length() + 1; i++) {
// System.out.println();
for (int j = 1; j < bString.length() + 1; j++) {
// System.out.print(minCost + "_" + operator[i][j] + " ");
int tempType;
int cost = 0;
if (aString.charAt(i - 1) != bString.charAt(j - 1))
{
cost = 5;
}
int minCost;
int delCount = getDelCount(f[i - 1][j], operator[i - 1][j]);
/*
*
* // getDelCount(f,type)
if (type == DEL) {
minCost = f + 0;
} else {
minCost = f + 2;
}
// 看她 前面的 是不是 DEL,如果是,那个再把这个字母代价 删到 ,需要增加的代价就为 0
*/
int addCount = getAddCount(f[i][j - 1], operator[i][j - 1]);
/*
* //getAddCount(f,type)
if (type == ADD) {
minCost = f + 1;
} else {
minCost = f + 3;
}
*/
if (delCount >= addCount)
{
operator[i][j] = ADD;
minCost = addCount;
}
else
{
operator[i][j] = DEL;
minCost = delCount;
}
if (minCost > f[i - 1][j - 1] + cost)
{
operator[i][j] = ORIGAL;
minCost = f[i - 1][j - 1] + cost;
}
f[i][j] = minCost;
}
// System.out.println("");
}
return f[aString.length()][bString.length()];
}
}
在做动态规划的题目的时候,需要明白自己需要建几张二维表,以及二维表的实际物理意义。将原文题,递归到子问题。这样可以写出递归方程。
数据结构 和 递归方程便是程序的两个重要部分。
如代码所示: f[i][j]表示 从a[i] -> b[j]的最小代价,以 “dsafsadfadf” 变成 “fdfd” 为例:
f的数组的内容如下:
j\i | f | d | f | d | ||
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | |||
0 | 0 | 0 | 3 | 4 | 5 | 6 |
1 | d | 2 | 5 | 3 | 6 | 6 |
2 | s | 2 | ||||
3 | a | 2 | ||||
4 | f | 2 | ||||
5 | s | 2 | ||||
6 | a | 2 | ||||
7 | d | 2 | ||||
8 | f | 2 | ||||
9 | a | 2 | ||||
10 | d | 2 | ||||
11 | f | 2 |
operate数组内容如下:
j\i | f | d | f | d | ||
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | |||
0 | 0 | ADD | ADD | ADD | ADD | |
1 | d | DEL | ADD | ORIGAL | ADD | |
2 | s | DEL | ||||
3 | a | DEL | ||||
4 | f | DEL | ||||
5 | s | DEL | ||||
6 | a | DEL | ||||
7 | d | DEL | ||||
8 | f | DEL | ||||
9 | a | DEL | ||||
10 | d | DEL | ||||
11 | f | DEL |
cost=5 为一个常量,含义是由A 到B 如果两个字符不等。那么他所消耗的代价就为5。(删除一个代价为2,增加一个为5) 如果字符相等,那么他的代价就为0.
结合代码 以d到f 为例。有d 到f 有三种路径可以走。
初始条件: 由d 到0 ,消耗的代价为 2
由 0到 f ,消耗的代价为 3
考虑问题的递归性:
1.先删除d,那么需要进行add f 操作,得到 f : 代价为 2+3
2.先增加f,那么需要进行DEL d 操作,得到f: 代价为 3+2
在这两个操作的时候考虑到递推问题的上一个状态,她的前一状态是 DEL,还是ADD
3.第三种状态就是,不管子问题,就是直接删除一个,加一个,为5.
从左到右为 ADD状态,从上到下为DEL状态。ORIGAL,为对角线过来的数据,也就是说,不考虑这个字母的前一个状态。
递归方程如下:
最右下角的值,就是我们要求得最小代价。