递推与递归

最新推荐文章于 2023-03-21 14:27:36 发布

小小硕、

最新推荐文章于 2023-03-21 14:27:36 发布

阅读量160

点赞数

分类专栏：算法与数据结构文章标签：算法 dfs 数据结构编程语言

本文链接：https://blog.csdn.net/weixin_41676930/article/details/107890536

版权

算法与数据结构专栏收录该内容

17 篇文章 0 订阅

订阅专栏

递推与递归

递归实现指数型枚举

从1~n这n个整数中随机选取任意多个，输出所有可能的选择方案。

#include <iostream>

using namespace std;

int n;

//u代表当前进行的递归计数，state代表哪些数被选与未选
void dfs(int u, int state){
	//达到n时输出
	if(u == n){
		for(int i =0; i < n; i++)
			if(state >> i & 1)
				cout << i + 1 << ' ';
		cout << endl;
		return;
	}
	//不选当前数字
	dfs(u + 1, state);
	//选择当前数字
	dfs(u + 1, state | 1 << u);
}

int main(){
	cin >> n;
	dfs(0, 0);
	return 0;
}

递归实现组合型枚举

从1~n这n个整数中随机选出m个，输出所有可能的选择方案。

#include <iostream>

using namespace std;

int n, m;

//u代表当前进行的递归计数，sum代表选取了多少个数，state代表哪些数被选与未选
void dfs(int u, int sum, int state){
 	//当选不够m个的时候返回，剪枝处理
	if(sum + n - u < m) return;
	//当选够m个的时候输出
	if(sum == m){
		for(int i=0; i<n; i++)
			if(state >> i & 1)
			    cout << i + 1 << ' ';
		cout << endl;
		return;
	}

	//当前数字被选
	dfs(u + 1, sum + 1, state | 1 << u);
	//当前数字未选
	dfs(u + 1, sum, state);
}
int main(){
	cin >> n >> m;
	dfs(0, 0, 0);
	return 0;
}

递归实现排列型枚举

把1~n这n个整数排成一行后随机打乱顺序，输出所有可能的次序。

#include <iostream>
#include <vector>

using namespace std;

int n;
vector<int> path;

//u代表当前进行的递归计数，state代表哪些数被选与未选
void dfs(int u, int state){
	//如果u等于n，则输出当前的排列
	if(u == n){
		for(auto x : path) cout << x << ' ';
		cout << endl;
		return;
	}
	
	//对于当前第u位，将未选的数字填入，然后递归
	for(int i=0; i<n; i++)
		if(!(state >> i & 1)){
			path.push_back(i + 1);
			dfs(u + 1, state | (1 << i));
			path.pop_back();
		}
}
		

int main(){
	cin >> n;
	dfs(0, 0);
	return 0;
}

费解的开关

你玩过拉灯游戏吗？25盏灯排成一个5x5的方形。每个灯都有一个开关，游戏者可以改变它的状态。每一步，游戏者可以改变某一个灯的状态。游戏者改变一个灯的状态会产生连锁反应；和这个灯上下左右相邻的灯也要相应地改变状态。
我们用数字“1”表示驿站开着的灯，用数字“0”表示关着的灯。下面这种状态
10111
01101
10111
10000
11011
在改变了最左上角的灯的状态后将变成：
01111
11101
10111
10000
11011
给定一些游戏的初始状态，编写程序判断游戏者是否可能在6步之内使所有的灯都变亮。

我们可以知道对于一些要按的灯，按灯顺序不会影响最终灯的状态。那么我们可以把这个问题逐行分解，对于第一行我们将可能的按法全部枚举，对于后续行我们的目标就是使得前一行的灯全部按亮。由此判断可不可以在6次内全部按亮。

#include <iostream>
#include <cstring>

using namespace std;

const int INF = 100000;

//g数组存放灯的状态，dx和dy用来表示邻近灯
char g[10][10];
int dx[5] = {0, -1, 0, 1, 0}, dy[5] = {0, 0, 1, 0, -1};

//turn函数会修改当前灯与周围灯的状态
void turn(int x, int y){
	for(int i =0; i<5; i++){
		int a = x + dx[i], b = y + dy[i];
		if(a >= 0 && a < 5 && b >=0 && b < 5){
			//g[a][b] = '1' - g[a][b] + '0';
			g[a][b] ^= 1;
		}
	}
}

int work(){
	//ans代表可能全亮的最少按灯次数
	int ans = INF;
	//遍历第一行可能的按法
	for(int k = 0; k<1<<5; k++){
		//res代表按灯次数
		int res = 0;
		char backup[10][10];
		memcpy(backup, g, sizeof g);
		for(int j=0; j<5; j++)
			if(k >> j & 1){
				res++;
				turn(0, j);
			}
		//根据当前行出现的灭灯，修改下一行对应位置的灯
		for(int i=0; i<4; i++)
			for(int j=0; j<5; j++)
				if(g[i][j] == '0'){
					res++;
					turn(i + 1, j);
				}
		//观察最后一行灯是否全亮，如果全亮将按灯次数与之前比较
		bool is_successful = true;
		for(int j=0; j<5; j++)
			if(g[4][j] == '0'){
				is_successful = false;
				break;
			}
		if(is_successful) ans = min(ans, res);
		memcpy(g, backup, sizeof g);
	}
	if(ans > 6) ans=-1;
	return ans;
}

int main(){
	int T;
	cin >> T;
	while(T--){
		for(int i=0; i<5; i++) cin >> g[i];
		cout << work() << endl;
	}
	return 0;
}

奇怪的汉诺塔

汉诺塔问题，条件如下：

这里有A、B、C和D四座塔。
这里有n个圆盘，n的数量是恒定的，且n<=12。
每个圆盘的尺寸都不相同。
所有圆盘在开始时都堆叠在塔A上，且圆盘尺寸从塔顶到塔底逐渐增大。
我们需要将所有的圆盘都从塔A转移到塔D上。
每次可以移动一个圆盘，当塔为空塔或者塔顶圆盘尺寸大于被移动圆盘时，可将圆盘移至这座塔上。
请你求出将所有圆盘从塔A移动到塔D，所需的最小移动次数是多少。

我们可以将其化为一个动态规划问题，对于三阶汉诺塔，我们可以将问题描述为D[n] = DD[n-1] x 2 + 1，即先将前n-1个圆盘移到第二个塔上，再将最后一个圆盘放到第三个塔上（仅一步操作），最后将第二个塔上的圆盘全部移动到第三个塔上。

而对于四阶汉诺塔，我们要寻找一个合适的圆盘i，将其上的圆盘先移动到一个塔上，所需移动次数设为F[i]。然后再将其下的圆盘移动到最后一个塔上，此时就是三阶汉诺塔问题，D[n-i]。然后再将前i个圆盘移动到最后塔上，即F[i]。这个合适的圆盘i就是使得移动次数最少的圆盘。

#include <iostream>
#include <cstring>

using namespace std;

int main(){
	int d[15], f[15];
	d[1] = 1;
	for(int i=2; i<=12; i++){
		d[i] = 1 + d[i-1] * 2;
	}
	memset(f, 0x3f, sizeof f);
	f[0] = 0;
	for(int i=1; i<=12; i++)
		for(int j=0; j<i; j++)
			f[i] = min(f[i], f[j] * 2 + d[i - j]);
	
	for(int i=1; i<=12; i++) cout << f[i] << endl;
	return 0;
}

约数之和

假设现在有两个自然数A和B，S是 $A^B$ 的所有约数之和。
请你求出S mod 9901的值是多少。

对于数A，我们可以将其分解成质数的形式，A= ${p_{1}}^{k_{1}}{p_{2}}^{k_{2}}···{p_{n}}^{k_{n}}$ ，其中 ${p_{n}}$ 是A的质数约数，我们可以修改 ${k_{n}}$ 的大小来获得不同的约数，对于所有的约数之和我们可以表示为：
$({p_{1}}^{0}+{p_{1}}^{1}+\cdot \cdot \cdot +{p_{1}}^{k_{1}})\times ({p_{2}}^{0}+{p_{2}}^{1}+\cdot \cdot \cdot +{p_{2}}^{k_{2}})\times \cdot \cdot \cdot \times ({p_{n}}^{0}+{p_{n}}^{1}+\cdot \cdot \cdot +{p_{n}}^{k_{n}})$
对于每一部分，我们还可以进一步化简，例如，当 $k_1$ 是奇数的时候，我们可以化简为
${p_{1}}^{0}+{p_{1}}^{1}+\cdot \cdot \cdot +{p_{1}}^{k_{1}}$
${p_{1}}^{0}+{p_{1}}^{1}+\cdot \cdot \cdot +{p_{1}}^{k_{1}/2}+{p_{1}}^{k_{1}/2+1}\times ({p_{1}}^{0}+{p_{1}}^{1}+\cdot \cdot \cdot +{p_{1}}^{k_{1}/2})$
其中/代表着整数除法
如果 $k_n$ 为偶数，那么就提出一个 $p_n$ 即可，这样利用递归我们可以加速求解
而对于 ${p_{1}}^{k_{1}/2+1}$ 我们可以利用快速幂进行求解（参考上一博客位运算）。如下是代码实现。

#include <iostream>

using namespace std;

const int mod = 9901;

int qmi(int a, int k){
	a %= mod;
	int res = 1;
	while(k){
		if(k & 1) res = res * a % mod;
		a = a * a % mod;
		k >>= 1;
	}
	return res;
}

int sum(int p, int k){
	if(k==0) return 1;
	//如果k是偶数就提出一个P，则k-1变为奇数
	if(k % 2 == 0) return (p % mod * sum(p, k - 1) + 1) % mod;
	//如果k是奇数
	return (1 + qmi(p, k/2 + 1)) * sum(p, k/2) % mod;
}

int main(){
	int A, B;
	cin >> A >> B;
	int res = 1;
	for(int i=2; i<=A; i++){
		int s=0;
		while(A % i ==0){
			s++;
			A /= i;
		}
		if(s) res = res * sum(i, s * B) % mod;
	}
	if(!A) res = 0;
	cout << res << endl;
	return 0;
}

分形之城

城市的规划在城市建设中是个大问题。
不幸的是，很多城市在开始建设的时候并没有很好的规划，城市规模扩大之后规划不合理的问题就开始显现。
而这座名为 Fractal 的城市设想了这样的一个规划方案，如下图所示：
当城区规模扩大之后，Fractal 的解决方案是把和原来城区结构一样的区域按照图中的方式建设在城市周围，提升城市的等级。
对于任意等级的城市，我们把正方形街区从左上角开始按照道路标号。
虽然这个方案很烂，Fractal 规划部门的人员还是想知道，如果城市发展到了等级 N，编号为 A 和 B 的两个街区的直线距离是多少。
街区的距离指的是街区的中心点之间的距离，每个街区都是边长为 10 米的正方形。

我们可以发现每一等级的城市都是由上一等级城市旋转平移得到的，所以对于该题，我们可以将n等级的城市进行递归，从1等级开始处理。
将城市划分成四个区域，左上、右上、左下、右下四个分区，根据所在分区决定上一等级城市该如何旋转平移。然后再将得到的当前等级城市下的坐标，传递给下一等级的城市，直至规定等级。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define PLL pair<ll,ll>
PLL calc(ll n,ll m)
{
	//边界结果
    if (n==0)
        return make_pair(0,0);
    //len代表当前等级下城市边长的一半（移动上一等级城市需要），cnt表示当前等级城市下街道数量的1/4（决定分区）
    ll len=1LL<<(n-1),cnt=1LL<<(2*n-2);
    //递归到最低级城市
    PLL pos=calc(n-1,m%cnt);
    ll x=pos.first,y=pos.second;
    //z表示当前等级城市下，m序号的街道所处的分区，分为左上、右上、左下、右下四个分区，从而决定如何旋转
    ll z=m/cnt;
    //根据分区位置旋转平移上一等级的街道，其中（x,y）代表上一等级城市下街道的位置
    if (z==0)
        return make_pair(y,x);
    if (z==1)
        return make_pair(x,y+len);
    if (z==2)
        return make_pair(x+len,y+len);
    return make_pair(2*len-1-y,len-1-x);
}

int main()
{
    //ios::sync_with_stdio(false);
    int t;
    cin>>t;
    while(t--)
    {
        ll n,a,b;
        //这里n代表当前城市等级，a、b代表两个街道的序号
        cin>>n>>a>>b;
        //简化边界处理，将序号从0开始
        PLL x=calc(n,a-1);
        PLL y=calc(n,b-1);
        ll dx=x.first-y.first,dy=x.second-y.second;
        double ans=(sqrt(dx*dx+dy*dy)*10);
        printf("%0.lf\n",ans);
    }
    return 0;
}

递归改递推

用递推来实现递归代码，需要借助STL中的栈，计算机本身在处理递归代码的时候也是使用栈来实现的。

在这里我们通过“递归实现组合型枚举”来举例说明，我们首先要把原递归代码划分位置，用来标记处理过程。通过定义结构体，作为栈的保存对象，其中要包含标记位置。主函数中我们循环取出栈首元素，根据所标记的位置来决定如何处理当前元素，直至栈空。

#include <iostream>
#include <stack>

using namespace std;

int n,m;

struct State{
	int pos, u, sum, state;
};

void dfs(int u, int sum, int state){
	//0
	if(sum + n _ u < m) return;
	if(sum == m){
		for(int i=0; i<n; i++)
			if(state >> i & 1)
				cout << i + 1 << ' ';
		cout << endl;
		return;
	}
	dfs(u + 1, sum + 1, state | 1 << u);
	//1
	dfs(u + 1, sum, state);
	//2
}

int main(){
	cin >> n >> m;
	//dfs(0, 0, 0)

	stack<State> stk;
	stk.push({0, 0, 0});

	while(stk.size()){
		auto t=stk.yop;
		stk.pop();

		if(t.pos == 0){
			if(t.sum + n - t.u < m) continue;
			if(t.sum == m){
				for(int i=0; i<n; i++)
					if(t.state >> i & 1)
						cout << i + 1 << ' ';
				cout << endl;
				continue;
			}

			t.pos = 1;
			stk.push(t);
			stk.push({0, t.u + 1, t.sum + 1, t.state | 1 << t.u});
		}
		else if(t.pos == 1){
			t.pos = 2;//可去掉
			stk.push(t);//可去掉
			stk.push({0, t.u + 1, t.sum, t.state});
		}
		else continue;//可去掉
	}
	return 0;
}

标记位置的方法只是个通用模板，我们可以将得到的递推继续优化如下：

#include <iostream>
#include <stack>

using namespace std;

int n,m;

struct State{
	int u, sum, state;
};

int main(){
	cin >> n >> m;
	//dfs(0, 0, 0)

	stack<State> stk;
	stk.push({0, 0, 0});

	while(stk.size()){
		auto t=stk.top();
		stk.pop();

		if(t.sum + n - t.u < m) continue;
		if(t.sum == m){
			for(int i=0; i<n; i++)
				if(t.state >> i & 1)
					cout << i + 1 << ' ';
			cout << endl;
			continue;
		}

        stk.push({t.u + 1, t.sum, t.state});
		stk.push({t.u + 1, t.sum + 1, t.state | 1 << t.u});
	}
	return 0;
}

小小硕、

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
递推与递归

递推与递归递归实现指数型枚举递归实现组合型枚举递归实现排列型枚举费解的开关奇怪的汉诺塔约数之和递归实现指数型枚举从1~n这n个整数中随机选取任意多个，输出所有可能的选择方案。#include <iostream>using namespace std;int n;//u代表当前进行的递归计数，state代表哪些数被选与未选void dfs(int u, int state){ //达到n时输出 if(u == n){ for(int i =0; i < n;
复制链接

扫一扫