动态规划编程题总结

1、跳石板
小易来到了一条石板路前，每块石板上从1挨着编号为：1、2、3…
这条石板路要根据特殊的规则才能前进：对于小易当前所在的编号为K的 石板，小易单次只能往前跳K的一个约数(不含1和K)步，即跳到K+X(X为K的一个非1和本身的约数)的位置。 小易当前处在编号为N的石板，他想跳到编号恰好为M的石板去，小易想知道最少需要跳跃几次可以到达。
例如：
N = 4，M = 24：
4->6->8->12->18->24
于是小易最少需要跳跃5次，就可以从4号石板跳到24号石板
输入描述:

输入为一行，有两个整数N，M，以空格隔开。 (4 ≤ N ≤ 100000) (N ≤ M ≤ 100000)

输出描述:

输出小易最少需要跳跃的步数,如果不能到达输出-1

示例1

输入
4 24
输出
5

思路：动态规划
采用动态规划思想求解。创建一个vector容器steps，steps[i]表示到达i号石板所需的最小步数。初始化为steps容器为INT_MAX。从序号N的石板开始逐个遍历，若steps[i]为INT_MAX，表示该点不可到达，直接开始下次循环。若steps[i]不为INT_MAX，表示该点可以到达，下面求解编号i的约数，进行动态规划。动态规划的转移方程为：

steps[i+j] = min(steps[i]+1,steps[i+j])   //i为石板编号，j为i的约数

代码：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main()
{
	int N, M;
	while (cin >> N >> M)
	{
		vector<int> steps(M + 1, INT_MAX);
		steps[N] = 0;
		for (int i = N; i <= M; ++i)
		{
			if (steps[i] == INT_MAX)
				continue;
			for (int j = 2; j * j <= i; ++j)
			{
				if (i % j == 0)
				{
					if (i + j <= M)
						steps[i + j] = min(steps[i] + 1, steps[i + j]);
					if (i + i / j <= M)
						steps[i + i / j] = min(steps[i] + 1, steps[i + i / j]);
				}
			}
		}
		if (steps[M] == INT_MAX)
			steps[M] = -1;
		cout << steps[M] << endl;
	}
	return 0;
}

2、问题描述：在计算机中，通配符一种特殊语法，广泛应用于文件搜索、数据库、正则表达式等领域。现要求各位实现字符串通配符的算法。
要求：
实现如下2个通配符：
*：匹配0个或以上的字符（字符由英文字母和数字0-9组成，不区分大小写。下同）
？：匹配1个字符

输入：
通配符表达式；
一组字符串。

输出：
返回匹配的结果，正确输出true，错误输出false

输入描述:

先输入一个带有通配符的字符串，再输入一个需要匹配的字符串

输出描述:

返回匹配的结果，正确输出true，错误输出false

示例1

输入
te?t*.*
txt12.xls
输出
false

首先，我们想到暴力破解。如果从头到尾的破解，到第二个字符时，是否匹配成功取决于第一个字符是否匹配成功！ 所以我们想到应该要用到动态规划；

#include <iostream>
#include <string>
#include <vector>
using namespace std;

int match_string(string str1, string str2)
{
	int str1_len = str1.size();
	int str2_len = str2.size();
	//多加一行一列作为初始初值所用
	vector<vector<int> > dp(str1_len + 1, vector<int>(str2_len + 1, 0));
	dp[0][0] = 1;//边界条件，考虑第一个字符是*的情况
	for (int i = 1; i <= str1_len; ++i)
	{
		char ch1 = str1[i - 1];
		dp[i][0] = dp[i - 1][0] && (ch1 == '*');
		for (int j = 1; j <= str2_len; ++j)
		{
			char ch2 = str2[j - 1];
			if (ch1 == '*')
				dp[i][j] = dp[i - 1][j] || dp[i][j - 1];
			else
				dp[i][j] = dp[i - 1][j - 1] && (ch1 == '?' || ch2 == ch1);
		}
	}
	return dp[str1_len][str2_len];
}

int main()
{
	string str1, str2;
	while (cin >> str1 >> str2)
	{
		int ret = match_string(str1, str2);
		if (ret == 1)
			cout << true << endl;
		else
			cout << false << endl;
	}
	return 0;
}

关键是做一个如下矩阵进行分析：
输入：
a*b
abc

3、计算字符串的距离
Levenshtein 距离，又称编辑距离，指的是两个字符串之间，由一个转换成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。编辑距离的算法是首先由俄国科学家Levenshtein提出的，故又叫Levenshtein Distance。
Ex：
字符串A:abcdefg
字符串B: abcdef
通过增加或是删掉字符”g”的方式达到目的。这两种方案都需要一次操作。把这个操作所需要的次数定义为两个字符串的距离。
要求：
给定任意两个字符串，写出一个算法计算它们的编辑距离。
输入描述:

输入两个字符串

输出描述：

得到计算结果
示例1

输入
abcdefg
abcdef
输出
1

#include <iostream>
#include <string>
#include <vector>
using namespace std;

int Min(int a, int b, int c)
{
	return (a<b ? a : b)<c ? (a<b ? a : b) : c;
}

int calStringDistance(string charA, string charB)
{
	int An = charA.size(), Bn = charB.size();
	vector<vector<int> > dp(Bn + 1, vector<int>(An + 1, 0));
	dp[0][0] = 0;
	for (int i = 1; i <= An; ++i)
		dp[0][i] = i;
	for (int i = 1; i <= Bn; ++i)
		dp[i][0] = i;
	for (int i = 1; i <= Bn; ++i)
	{
		for (int j = 1; j <= An; ++j)
		{
			if (charB[i-1] == charA[j-1])
				dp[i][j] = dp[i - 1][j - 1];
			else
				dp[i][j] = Min(dp[i - 1][j - 1], dp[i][j - 1], dp[i - 1][j]) + 1;
		}
	}
	return dp[Bn][An];
}
int main()
{
	string charA, charB;
	while (cin >> charA >> charB)
	{
		cout << calStringDistance(charA, charB) << endl;
	}
	return 0;
}

4、求正数数组的最小不可组成和

class Solution {
public:
	int getFirstUnFormedNum(vector<int> arr, int len)
    {
        int min = arr[0], max = 0;
        for (int i = 0; i < len; ++i)
        {
            max += arr[i];
            min = arr[i] < min ? arr[i] : min;
        }
        //dp[i][j]表示arr[0..i]自由选择，能否累加出j
        //也就是背包容量为j，能不能恰好把背包装满
        vector<vector<bool> > dp(len, vector<bool>(max+1, false));
        //初始化第一行，除了dp[0][0]和dp[0][arr[0]]为true其他都是false
        dp[0][0] = true;
        dp[0][arr[0]] = true;
        //初始化第一列
        for (int i = 1; i < len; ++i)
        {
            dp[i][0] = true;
        }
        for (int i = 1; i < len; ++i)
        {
            for (int j = 1; j <= max; ++j)
            {
                if (j - arr[i] >= 0)//如果背包可以放下arr[i]
                    dp[i][j] = dp[i-1][j-arr[i]] || dp[i-1][j];//有和没有两种情况
                else
                    dp[i][j] = dp[i-1][j];
            }
        }
        for (int i = min+1; i < max; ++i)
        {
            if (!dp[len-1][i])
                return i;
        }
        return max + 1;
    }
};

空间复杂的优化

class Solution {
public:
	int getFirstUnFormedNum(vector<int> arr, int len)
    {
        int min = arr[0], max = 0;
        for (int i = 0; i < len; ++i)
        {
            max += arr[i];
            min = arr[i] < min ? arr[i] : min;
        }
        vector<bool> dp(max+1, false);
        dp[0] = true;
        dp[arr[0]] = true;
        for (int i = 1; i < len; ++i)
        {
            for (int j = max; j > 0; --j)
            {
                if (j - arr[i] >= 0)//如果背包可以放下arr[i]
                    dp[j] = dp[j-arr[i]] || dp[j];//有和没有两种情况
                else
                    dp[j] = dp[j];
            }
        }
        for (int i = min+1; i < max; ++i)
        {
            if (!dp[i])
                return i;
        }
        return max + 1;
    }
};