递推与递归

递推

过河卒

过河卒
这道题用dfs和递推都可以。递推的时间复杂度更优一些。

这道题的递推式很容易。

f[i][j] = f[i-1][j] + f[i][j-1]

初始化的时候有点麻烦。
1.若马不在第一行或者第一列的时候，正常的处理
2.若马在第一行或者第一列的时候，马后面的所有地方都是无法走过去的，即路径数为0.

注：这种写法并不好

#include <iostream>

using namespace std;

const int N = 30;

long long f[N][N];
int a, b, c, d;
int dir[8][2] = {{2, 1},{1, 2},{-1, 2},{-2, 1},{2, -1},{1, -2},{-1, -2},{-2, -1}};

int main()
{
	cin >> a >> b >> c >> d;
	
	//处理马走一步的情况
	f[c][d] = -1;
	for(int i = 0; i < 8; i++)
	{
		int x = c + dir[i][0], y = d + dir[i][1];
		if(x >= 0 && x <= a && y >= 0 && y <= b) f[x][y] = -1;
	}
	
	//处理马在第一行或者第一列的情况
	//写的有点繁琐，其实有更好的方法
	int h = 0;
	for(int i = 0; i <= b; i++)
		if(f[0][i] == -1)
		{
			h = i;
			break;
		}
	for(int i = 0; i <= b; i++) 
	{
		if(h == 0) f[0][i] = 1;
		else if(i >= h) f[0][i] = -1;
		else f[0][i] = 1;
	}
	
	h = 0;
	for(int i = 0; i <= a; i++)
		if(f[i][0] == -1)
		{
			h = i;
			break;
		}
	for(int i = 0; i <= a; i++)
	{
		if(h == 0) f[i][0] = 1;
		else if(i >= h) f[i][0] = -1;
		else f[i][0] = 1;
	}
	
	for(int i = 1; i <= a; i++)
		for(int j = 1; j <= b; j++)
		{
			if(f[i][j] == -1) continue;
			if(f[i - 1][j] == -1 && f[i][j - 1] == -1) f[i][j] = 0;
			else if(f[i - 1][j] == -1 && f[i][j - 1] != -1) f[i][j] = f[i][j - 1];
			else if(f[i - 1][j] != -1 && f[i][j - 1] == -1) f[i][j] = f[i - 1][j];
			else f[i][j] = f[i - 1][j] + f[i][j - 1];
		}
	
	
	cout << f[a][b];
}

栈

栈
这道题是卡特兰数经典题目。
一个栈(无穷大)的进栈序列为1，2，3，…，n，有多少个不同的出栈序列?
答:

h[n]=h[n−1]∗(4∗n−2)/(n+1)

代码：

int h[N] = {1, 1};
for(int i = 2; i <= n; i++) f[i] = f[i - 1] * (4*i-2)/(i+1)

ac代码：

#include <iostream>

using namespace std;

const int N = 20;

long long h[N];

int main()
{
	int n;
	cin >> n;
	h[0] = h[1] = 1;
	for(int i = 2; i <= n; i++) h[i] = h[i - 1] * (4 * i - 2) / (i + 1);
	
	cout << h[n];
}

递归

数的计算

数的计算

考点：递归或者递推
先写递推，递推很多时候就是把案例模拟多几次，然后找规律，得到递推方程即可。

我们可以发现（确实有点难发现）
注：不只有这一个递推式，还有其他的规律的。

奇数时：f[n] = f[n - 1]
偶数时：f[n] = f[n - 1] + f[n / 2]

ac代码

#include <iostream>

using namespace std;

const int N = 1010;

int f[N];

int main()
{
	int n;
	cin >> n;
	f[0] = f[1] = 1;
	for(int i = 2; i <= n; i++)
	{
		if(i % 2 != 0) f[i] = f[i - 1];
		else f[i] = f[i - 1] + f[i / 2];
	}
	cout << f[n];
}

递归：
如果一开始有

[1] [2] [3] [1,2] [1,3]

那么往后面加一个6的方案数就是

[1,6] [2,6] [3,6] [1,2,6] [1,3,6] [6]

而一开始有的那些序列就是问题n = 1 + 问题n = 2 + 问题n = 3的三种规模加起来的总情况数量，在这基础上每一个序列后加上一个6(也就是总情况数+1）就可以得到问题n = 6的答案.

---

因此可以得到这样一个式子来得到答案
最终答案 = 减小规模后的情况总数 + 1；

int ans = 1;
for(int i = 1; i <= n / 2; i++) ans += solution(i);

递归的终点是问题规模为1的时候

if(n == 1) return 1;

代码，但是这样ac不了，因为重复计算次数太多。
比如sol（8）需要调用sol（2），sol（4）也要调用sol（2），可是sol（2)已经被计算过了.
因此需要把以前算过的值存下来。

#include <iostream>

using namespace std;

const int N = 1010;
int f[N];

int solution(int n)
{
	int ans = 1;
	if(n == 1) return 1;
	else
	{
		for(int i = 1; i <= n / 2; i++) ans += solution(i);
	}
	return ans;
}

int main()
{
	int n;
	cin >> n;
	int ans = solution(n);
	cout << ans;
}

拿个数组存一下就好了。
记忆化搜索ac代码

#include <iostream>
#include <cstring>
using namespace std;

const int N = 1010;
int f[N];//存sol(i)的值

int solution(int n)
{
	int ans = 1;
	if(f[n] != -1) return f[n];
	else
	{
		for(int i = 1; i <= n / 2; i++) ans += solution(i);
		f[n] = ans;
	}
	return ans;
}

int main()
{
	int n;
	cin >> n;
	memset(f, -1 ,sizeof(f));
	cout << solution(n);
}

function

function
这道题很明显就是考你记忆化搜索。
很简单，开个三维数组全部存起来就好。

注：因为题目说大于20的全部返回w(20,20,20)，所以数组开个25就够用了。

ac代码：

#include <iostream>
#include <cstring>
using namespace std;

const int N = 25;
long long f[N][N][N];

int w(int a, int b, int c)
{
	if(a <= 0 || b <= 0 || c <= 0) return 1;
	else if(a > 20 || b > 20 || c > 20) 
	{
		if(f[20][20][20] == -1) f[20][20][20] = w(20, 20, 20);
		return f[20][20][20];
	}
	else if(a < b && b < c) 
	{
		if(f[a][b][c - 1] == -1) f[a][b][c - 1] = w(a, b, c - 1);
		if(f[a][b - 1][c - 1] == -1) f[a][b - 1][c - 1] = w(a, b - 1, c - 1);
		if(f[a][b - 1][c] == -1) f[a][b - 1][c] = w(a, b - 1, c);
		return f[a][b][c - 1] + f[a][b - 1][c - 1] - f[a][b - 1][c];
	}
	else
	{
		if(f[a - 1][b][c] == -1) f[a - 1][b][c] = w(a-1,b,c);
		if(f[a - 1][b - 1][c] == -1) f[a - 1][b - 1][c] = w(a-1,b-1,c);
		if(f[a - 1][b][c - 1] == -1) f[a - 1][b][c - 1] = w(a-1,b,c-1);
		if(f[a - 1][b - 1][c - 1] == -1) f[a - 1][b - 1][c - 1] = w(a-1,b-1,c-1);
		return f[a - 1][b][c] + f[a - 1][b - 1][c] + f[a - 1][b][c - 1] - f[a - 1][b - 1][c - 1];
	}
}

int main()
{
	int a, b, c;
	cin >> a >> b >> c;
	memset(f, -1, sizeof(f));
	while(a != -1 || b != -1 || c != -1)
	{
		long long ans = w(a, b, c);
		printf("w(%d, %d, %d) = %lld\n", a, b, c, ans);
		cin >> a >> b >> c;
	}	
}

外星密码

这道题很好的考察了递归，可以作为经典例题。

外星密码

思路：
1.遇到’[‘前正常读取
2.遇到’[‘后读取数字，用一个新的字符串去递归地读取后面压缩后地字符串，然后和原来地字符串拼接起来。
3.遇到’]'结束递归，返回原字符串

注：
1.要一个一个字符读
2.递归不要深究，按上面的思路写就好

ac代码：

#include <iostream>

using namespace std;

string expand()
{
	string s, X;
	char ch;
	while(cin >> ch)
	{
		if(ch == '[')
		{
			int cnt = 0;
			cin >> cnt;
			X = expand();
			for(int i = 0; i < cnt; i++) s += X;
		}
		else if(ch == ']') return s;
		else s += ch;
	}
	return s;
}

int main()
{
	string s = expand();
	cout << s;
}