递归对应题目练习

递归对应题目练习

分标题就是链接，Ctrl+鼠标左键跳转

注意流程图的绘制，肥常重要︿(￣︶￣)︿

基本

跳台阶

注意所有这类台阶问题 n(0)=1,n(1)=1

小青蛙可以跳一个台阶，也可以跳两个台阶

第一种跳法：第一次跳了一个台阶，那么还剩下n-1个台阶还没跳，剩下的n-1个台阶的跳法有f(n-1)种。

第二种跳法：第一次跳了两个台阶，那么还剩下n-2个台阶还没，剩下的n-2个台阶的跳法有f(n-2)种。

所有跳法之和：f(n) = f(n-1) + f(n-2)

每次跳1~3阶：f(n) = f(n-1) + f(n-2)+f(n-3)

---

7-7 求算式前n项的和

题目：7-7 求算式前n项的和

这道题很简单，对比一下差别

//我自己的写法
double num(int n, double shang, double xia)
{
    if (n == 0) return N;
    N += shang / xia;
    num(n - 1, xia, shang + xia);
}
//标准递归写法
double num(int n, double shang, double xia)
{
    if (n == 0) return 0.0;
    double result = shang / xia + num(n - 1, xia, shang + xia);
    return result;
}

---

汉诺塔

注意：要先理解好最基础的最简单的步骤

用最基础的步骤写出递归回归的基本函数

基础版

题目：7-8 汉诺塔游戏

1. 只移动一个盘子则调用 hanoii 输出
2. 否则 n-1个盘子 先移动从A到B，再移动 第n个盘子 从A到C（此时调用hanoii), 再移动n-1个盘子 从B到C

#include <bits/stdc++.h>
using namespace std;
int cnt;

void hanoii(char a,char c) //只移动一个盘子就调用这个函数
{
	cout<<a<<" To "<<c<<endl;
	cnt++;
}

void hanoi(int n,char a,char b,char c)
{
	if(n==1) hanoii(a,c);
	else
	{
		hanoi(n-1,a,c,b);
		hanoii(a,c);
		hanoi(n-1,b,a,c);
	}
}

int main()
{
	int n;
	cin>>n;
	char a='A',b='B',c='C';
	hanoi(n,a,b,c);
	cout<<cnt;
	return 0; 
}

---

进阶版

7-8 汉诺塔游戏（扩展） - 2024.03.11：实战二 递归及应用 － 2、拓展项目 (pintia.cn)

递归：
只剩下一个盘子时，判断盘子是在 临近柱子上or隔柱上
记得n++以及总统计数加1或2，才能继续调用递归
重复调用递归：
只移动1个盘子则只能移动到临近柱子上
n-1个盘子则可以隔着柱子移动（递归到最里层还是1个盘子的情况）

#include <bits/stdc++.h>
using namespace std;
int v；
void hanoi(int n,char a,char b,char c)//n个盘子从a经过b移动到c 
{
	if(n==1)
	{
		if(abs(a-c)==1)
		{
			n++;
			cout<<a<<" To "<<c<<endl;
			v++;
		}
		if(abs(a-c)==2)
		{
			n++;
			cout<<a<<" To "<<b<<endl;
			v++;
			n++;
			cout<<b<<" To "<<c<<endl;
			v++;
		}
	}
	else
	{   //大盘不能在小盘上面
		hanoi(n-1,a,b,c);
		hanoi(1,a,c,b);
		hanoi(n-1,c,b,a);
		hanoi(1,b,a,c);
		hanoi(n-1,a,b,c); 
	}
}

int main()
{
	int n;
	cin>>n;
	char a='A',b='B',c='C';
	hanoi(n,a,b,c);
	cout<<v;
	return 0;
}

---

进阶

n个数的最大公约数（辗转相除法）

7-4 求N个数的最大公因数 - 2024.03.11：实战二 递归及应用 － 2、拓展项目 (pintia.cn)

辗转相除法——求最大公约数(易懂详解)-CSDN博客

思想：

1. 辗转相除法的函数
2. 拿数组存n个数，递归从最后一个数找和前面的数的最大公约数
3. 一直递归到最前面两个数，返回前两个数的最大公约数，然后往后

例如 {2,4,8,16}
第一次递归调用 Ndevide(a, length-1)，参数为 [2, 4, 8] 和 3。
再次进入 else 分支，再次进行递归调用 Ndevide(a, length-1)，参数为 [2, 4] 和 2。
继续进入 else 分支，再次进行递归调用 Ndevide(a, length-1)，参数为 [2] 和 1。
满足 length == 1 的条件，函数直接返回 a[0]，即 2。
回到上一层递归，第一次递归调用的返回值为 2。
接下来，除数为 a[length-1]，即 a[2]，即 8。被除数为递归调用的结果 2。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll a[210];

ll devide(ll n,ll m)
{
	if(m==0) return n;
	else return devide(m,n%m);
}

ll Ndevide(ll a[],ll length)
{
	if(length==1) return a[0];
	else return devide(a[length-1],Ndevide(a,length-1));
}

int main()
{
	int n;
	cin>>n;
	for(int i=0;i<n;i++) cin>>a[i];
	ll map=Ndevide(a,n);
	cout<<map;
	return 0;
}

---

7-5 回文数个数

题目： 7-5 回文数个数

思想：

用指针移动来做，把1~n的数字转化为字符串，传给判断函数

递归每次判断 str[p1]==str[p2]?，

相等则移动两个指针，直至 p1>=p2则说明这个数是回文数

#include <bits/stdc++.h>
using namespace std;

const int N =1000010;
typedef long long ll;

bool is(string str,int p1,int p2)
{
	if(p1>=p2) return true;
	return str[p1]==str[p2]&&is(str,p1+1,p2-1);
}

ll cnt(ll n)
{
	ll cout=0;
	for(long long i=1;i<=n;i++)
	{
		string st=to_string(i);
		if(is(st,0,st.length()-1)) cout++;
	}
	return cout;
}

int main()
{
	ll n;
	cin>>n;
	ll t=cnt(n);
	cout<<t;
	return 0;
 } 

---

7-6 分解质因子

题目：7-6 分解质因子

思想：

1. 先写质数判断函数
2. 递归函数：
   1. 利用2~n循环，找质因子，找到了就输出
   2. 更新 n=n/i调用递归接着找，注意找到了一个质因子就要及时 break

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

bool sushu(ll n)
{
	if(n<2) return false;
	for(ll i=2;i<=sqrt(n);i++)
		if(n%i==0) return false;
	return true;
}

void is(ll n)
{
	if(n==1) return;  
		for(ll i=2;i<=n;i++)
		{
			if(sushu(i)&&(n%i==0))
			{
				cout<<i<<" ";
				is(n/i);
				break; 
                //注意break重要性，找到了质因子就直接结束本次循环，调用下一次递归 
			}
		}	
}

int main()
{
	ll n;
	cin>>n;
	if(sushu(n))
	{
		cout<<n<<" ";
		return 0;
	} 
	is(n);
	return 0;
} 

---

7-7 十进制转换为R进制

题目：7-7 十进制转换为R进制

写法一：

思想：

1. 注意10~16是A~F , 把1~16对应的进制数拿字符数组存着
2. 注意最后还需要将字符串倒置输出

#include <bits/stdc++.h>

using namespace std;

string result;

void d(int n,int R)
{
	char dights[]="0123456789ABCDEF";
	if(n==0) return; //当被除数为0说明进制转换结束
    
	int number=n%R;
	result+=dights[number]; //将余数对应进制数放到字符串中
	d(n/R,R);
}

int main()
{
	int n,R;
	cin>>n>>R;
	d(n,R);
	reverse(result.begin(),result.end()); //注意倒置
	cout<<result;
	return 0;
}

写法二：

这种写法不需要倒置，因为递归从上到下执行，再从下到上存储

string d(int n, int R) {
    char digits[] = "0123456789ABCDEF";
    
    if (n == 0)
        return "";
    
    int number = n % R;
    string result = d(n / R, R); //从上到下执行
    result += digits[number]; //从下到上存储
    
    return result;
}

---

7-9 波兰表达式

题目：7-9 波兰表达式

假设输入 * - 5 2.5 2.2

注意运算顺序是 (5-2.5)*2.2=5.50000

因为有浮点数，所以不能直接存为字符数组

思想：

1. 每一次递归读取一个输入，用字符数组存
2. 用 switch 分情况进入语句
3. 如果是 + - * / 就返回对应递归等式
4. 如果是数字就字符串转换为浮点数，返回数字

#include <iostream>
using namespace std;
double exp()
{
    char s[20];
    cin >> s; 
    switch(s[0])
    {
        case '+' : return exp() + exp();
        case '-' : return exp() - exp();
        case '*' : return exp() * exp();
        case '/' : return exp() / exp();
        default  : return stod(s); 
        //如果是数字则用字符串读取，然后转化为对应数字
    }
}
 
int main()
{
    printf("%.5lf", exp());//读入一个波兰表达式(中间用空格隔开)，并计算其值
    return 0;
}

---