算法基础——递归

最新推荐文章于 2024-08-02 18:20:17 发布
最新推荐文章于 2024-08-02 18:20:17 发布
阅读量113 收藏 2
点赞数 1
分类专栏： 算法入门笔记 文章标签： 算法 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hacker_ccc/article/details/124707348
版权

简介

  • 一个函数调用其自身，就是递归
  • 递归和普通函数调用一样——是通过栈实现的

作用：

  1. 替代多重循环（N皇后）
  2. 解决本来就是用递归形式定义的问题（逆波兰表达式、表达式计算）
  3. 将问题分解为规模更小的子问题进行求解（上台阶，汉诺塔，放苹果，算24，印章）

例题——求阶乘

int Factorial(int n){
    if(n==0){
        return 1;
    }
    return n*Factorial(n-1);
}

例题——汉诺塔问题

void Hanoi(int n,char a,char b, char c){
    if(n==1){
        cout<<a<<"->"<<c<<endl;
    }else{
        Hanoi(n-1,a,c,b);
        cout<<a<<"->"<<c<<endl;
        Hanoi(n-1,b,a,c);
    }
}

例题——N皇后问题

  • 展示用递归替代多重循环

输入N，找到N个皇后可放置的列数；

#include<iostream>
#include<cmath>
using namespace std;
int N,queenPos[100];
//N个皇后，queenPos用来放算好的皇后位置
void NQueen(int k){//假设0~k-1行皇后都放置好的前提下，摆放第K行及其往后的皇后
    int i;
    if(k==N){//N个皇后都摆好了，递归出口
        for(i=0;i<N;i++){
            cout<<queenPos[i]+1<<" ";
        }
        cout<<endl;
        return;
    }
    for(i=0;i<N;i++){//尝试第K个皇后的位置
        int j;//i是第K个皇后的可选择位置，j是前面第j行皇后，queenpos[j]是第j行皇后的列数；
        for(j=0;j<k;j++){//检查和已经摆好的k个皇后的位置比较，看是否冲突
            if(queenPos[j]==i||abs(queenPos[j]-i)==abs(k-j)){
                break;//冲突，测试下一个位置->abs(queenPos[j]-i)==abs(k-j)：
                //符合斜着杀到的条件：行的绝对差值和列的绝对差值相等
            }
        }//检测是否冲突的循环
        if(j==k){//说明当前第i列不冲突，第k行皇后可以放置在第i列
            queenPos[k]=i;
            NQueen(k+1);
        }
    }
}
int main(){
    cin>>N;
    NQueen(0);//从第0行皇后开始放
    return 0;
}

例题——逆波兰表达式

  • 用递归解决递归形式的问题

逆波兰表达式是把运算符前置的算术表达式；eg：* + 2 3 4

意思是：有一个*运算，表达式是 + 2 3 和 4

​ （+ 2 3）* 4

​ （+ 2 3 ）意思就是（2+3）

本题求解逆波兰表达式的值，其中运算符包括±*/

  • 一个数是一个逆波兰表达式，值为该数——在此处可以理解为递归出口
  • 运算符 逆波兰表达式 逆波兰表达式
  • 一个exp()就会读入一个字符，读到运算符就递归读入数值
  • atof(s)是将字符型的数值，变成double类型
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
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 atof(s);
        break;
    }
}
int main(){
    printf("%lf\n",exp());
    return 0;    
}

例题——表达式计算

输入为四则运算表达式，仅由**数字、+、-、‘×’、/，()**组成，没有空格，要求求其值

解题思想

  • 表达式由项组成：项+项；项-项
  • 项由因子组成：因子*因子；因子/因子
  • 因子有两种可能：
    • ( 表达式 )
    • 整数

理解思想：（2+3）*5+9/3

  • 这个最外层的表达式有两个项：
    • （2+3）*5
    • 9/3
  • 第一个项里面有两个因子：
    • （2+3）
      • 这个因子是表达式形式：
      • 又有两个项：2和3
    • 5
  • 第二个项有两个因子 9和3
  • 你中引用我，我中引用你；（我中有你，你中有我）
#include<iostream>
#include<cstring>
#include<cstdlib>
using namespace std;
int factor_value();//读入一个因子，并且返回其值
int term_value();//读入一个项，并且返回其值
int expression_value();//读入一个表达式，并返回其值
int main(){
    cout<<expression_value()<<endl;
    return 0;
}
int expression_value(){
    //求一个表达式
    int result=term_value();//求第一项的值
    bool more=true;
    while(more){//判断后面还有没有项
        char op=cin.peek();//看一个字符，不取走
        if(op=='+'||op=='-'){
            cin.get();//从输入中取走一个字符
            int value=term_value();
            if(op=='+') result+=value;
            else result-=value;
        }else more=false;
    }
    return result;
}
int term_value(){//求一个项的值
    int result=factor_value();//求第一个因子的值
    while(true){
        char op=cin.peek();
        if(op=='*'||op=='/'){
            cin.get();
            int value=factor_value();
            if(op=='*') result*=value;
            else result/=value;
        }else break;
    }
    return result;
}
int factor_value(){
    int result=0;
    char op=cin.peek();
    if(op=='('){
        cin.get();
        result=expression_value();
        cin.get();//去除左右括号
    }else{
        while(isdigit(op)){//判断是不是数字
            result=10*result+op-'0';
            cin.get();
            op=cin.peek();
        }
    }
    return result;
}

例题——上台阶

  • 用递归将问题分解为规模更小的子问题进行求解
  • n级台阶的走法=先走一级后，n-1级台阶的走法+先走二级后，n-2级台阶的走法
    • f(n)=f(n-1)+f(n-2);
  • 递归出口：
    • n<0 0
    • n=0 1
    • n=1 1
    • n=2 2
  • 一定要存在递归出口，防止无穷递归，栈爆开结束
int f(int n){
    if(n==1){
        return 1;
    }else if(n==2){
        return 2;
    }else{
        return f(n-1)+f(n-2);
    }
}

例题——放苹果

  • 把M个同样的苹果放在N个同样的盘子里，允许有的盘子空着不放；511和151是相同方法

/*
设i个苹果放在k个盘子里放法总数是f(i,k),则:
k>i时，f(i,k)=f(i,i);
k<=i时，总放法=有盘子为空的方法+没盘子为空的方法
k<=i时，f(i,k)=f(i,k-1)+f(i-k,k);f(i-k,k)时先把k个苹果，每个盘子放一个先，再计算i-k个苹果放在k个盘子的放法
*/

#include<iostream>
using namespace std;
int f(int m,int n){
    if(n>m) return f(m,m);
    if(m==0) return 1;
    if(n==0) return 0;
    return f(m,n-1)+f(m-n,n); 
}

递归化DP

#include<iostream>
#include<cstring>
using namespace std;
int main(){
    int m,n,num[100][100],time;
    cin>>time;
    while(time--){
        memset(num,0,sizeof(num));
        num[0][0]=1;
        cin>>m>>n;
        for(int i=0;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(i<j) num[i][j]=num[i][i];
                else num[i][j]=num[i][j-1]+num[i-j][j];
            }
        }
        cout<<num[m][n]<<endl;
    }
}

例题——算24

  • 给4个小于10的正整数，使用加减乘除四种运算以及括号把这四个数连接起来得到一个表达式，使表达式的值等于24
  • 能算出24则YES，反之NO

思路

  • n个数算24，必有两个数要先算。
  • 这两个数算的结果，和剩余n-2个数，就构成了n-1个数求24的问题

注意：浮点数比较是否相等，不能用==

#include<iostream>
#include<cmath>
using namespace std;
double a[5];//存放输入的四个数
#define EPS 1e-6
bool IsZero(double x) {return fabs(x)<=EPS;}//用于浮点数判断是否相等
bool count24(double a[],int n){
    if(n==1){
        if(IsZero(a[0]-24)) return true;
        else return false;
    }//递归出口
    double b[5];//存放中间结果
    for(int i=0;i<n-1;i++){
        for(int j=i+1;j<n;j++){//枚举两个数的组合
            int m=0;//还剩m个数，m=n-2;
            for(int k=0;k<n;k++){
                if(k!=i&&k!=j) b[m++]=a[k];
            }//把挑选后剩余的数字放入b数组里
            b[m]=a[i]+a[j];
            if(count24(b,m+1)) return true;
            b[m]=a[i]-a[j];
            if(count24(b,m+1)) return true;
            b[m]=a[j]-a[i];
            if(count24(b,m+1)) return true;
            b[m]=a[i]*a[j];
            if(count24(b,m+1)) return true;
            if(!IsZero(a[j])){
                b[m]=a[i]/a[j];
                if(count24(b,m+1)) return true;
            }
            if(!IsZero(a[i])){
                b[m]=a[j]/a[i];
                if(count24(b,m+1)) return true;
            }
        }
    }
    return false;
}
int main(){
    int time;
    cin>>time;
    while(time--){
    	for(int i=0;i<4;i++){
        	cin>>a[i];
    	}
    	if(count24(a,4)){
        	cout<<"YES"<<endl;
    	}else{
        	cout<<"NO"<<endl;
    	}
    }
}

蓝桥——印章问题

#include<iostream>
#include<cmath>
using namespace std;
int m,n;
double p;
double res(int i,int j){
    if(i<j) return 0;
    if(j==1) return pow(p,i-1);
    else return res(i-1,j)*j*p+res(i-1,j-1)*(n-j+1)*p;
}
int main(){
    cin>>n>>m;
    p=1.0/n;
    printf("%.4f",res(m,n));
}

递归化DP

#include<iostream>
#include<cmath>
using namespace std;
int main(){
    double num[30][30],p;
    int m,n;
    cin>>n>>m;
    p=1.0/n;
    num[1][1]=1;
    for(int i=1;i<=m;i++){
        for(int j=1;j<=n;j++){
            if(i<j) num[i][j]=0;
            if(j==1) num[i][j]=pow(p,i-1);
            else num[i][j]=num[i-1][j]*j*p+num[i-1][j-1]*(n-(j-1))*p;
        }
    }
    printf("%.4f",num[m][n]);
}
Caaaaaan
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Java开发 | 数据结构和算法之——递归算法
mt776333的博客
03-11 2010
著名的Pascal之父——Nicklaus Wirth（沃斯）让他获得图灵奖的一句话就是他提出的著名公式：“程序=数据结构+算法”，这个公式对计算机科学的影响类似于爱因斯坦的质能方程在物理界的影响。 因此可以看出来数据结构和算法在我们开发程序中有多么的重要了，下面我们来简单认识下数据结构和算法… 1. 数据结构和算法介绍 数据结构介绍 数据结构是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合。 通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率，对于程序来说选择一个好
算法图解——递归
01-07
递归 函数自己调用自己 在用递归的同时，也可以用while循环实现 递归只是让解决方案更加清晰，并没有性能上的优势，有时候甚至循环的性能更好 “如果使用循环，程序性能可能更高；如果使用递归，程序可能更容易理解...
算法基础——递归神经网络RNN
Evan_qin_yi_quan的博客
12-05 350
算法基础——递归神经网络RNN
经典算法之——递归
m0_68987535的博客
05-22 1804
说明而单单的说递归话，就是函数调用自身那么简单，但是在真正的实现过程或者解决实际问题中，并没有那么简单，所设计的范围与应用的场景还是比较广的。介绍其实斐波那契数列算法也可以更好的说明简单的递归形式。这里介绍几个属于递归的几种形式算法。
基础算法——递归
qq_42425563的博客
03-05 749
算法思想 递归（recursion algorithm）：在计算机科学中是指一种通过重复将问题分解为同类的子问题而解决问题的方法。也可以说递归就是在函数定义中再调用自身的做法。好了，虽然其算法思维很简单，但是要使用起来却是很困难。有时候一个递归的算法光是理解起来就很难。（大师 L.Peter Deutsch 说过：To Iterate is Human, to Recurse, Divine.中文译为：人理解迭代，神理解递归。毋庸置疑地，递归确实是一个奇妙的思维方式。） 递归三要素 在这里本菜鸟只说一下对递
算法入门——递归与栈
qq_55977554的博客
02-05 3188
目录 递归 栈 栈的操作 调用栈 python中实现一个栈 总结 递归 什么是递归？递归就是方法自己调用自己。比如下面这个例子 def fun(n): print(n) fun(n-1) if __name__ == '__main__': fun(10) 它就是个递归函数，但是你会发现它会一直运行下去 10 9 8 7 6 ..... 但这样就会导致很多错误，我想没人会要一个无线循环的函数吧，所以我们需要有跳出循环的条件，正因为如此，每个递归函...
算法学习——递归和排列组合
m0_52380556的博客
01-12 2465
排列组合三大问题： 1.打印n个数的全排列 2.打印n个数中任意m个数的全排列 3.打印n个数中任意m个数的组合 1.打印n个数的全排列 这个题实际上是可以直接用STL中的next_permutation()函数，代码如下： #include<bits/stdc++.h> using namespace std; int main(){ int data[4]={5,2,4,1}; sort(data,data+4);//先排序得到字典序最小的序列 do{ for(int i=0;i&
python：算法——递归算法
热门推荐
abraham_ly的博客
08-13 1万+
python：算法——递归算法 1、什么是递归算法 ​ 在计算机中，程序调用自身的编程技巧我们称之为递归算法。那么再通俗一点来讲就是：在某个python文件中，有一个函数，这个函数可以在自己的函数体内根据条件，自己调用自己的函数，那么这样自身调用自身的过程或者说行为，我们称之为递归。 2、递归的详细理解 ​ （1）假设，有一个直线型的迷宫（只有一条路，不能拐弯），迷宫中有一份藏宝图。 ​ （2）那么，有一天我来到迷宫入口，那么当我进入这个迷宫的大门的时候。我们就可以理解为：就是在程序中的某个地方调用了
基础算法 —— 递归算法
Alex_McAvoy的博客
04-28 1828
【概述】 递归算法：一种通过重复将问题分解为同类的子问题而解决问题的方法。 适用问题：解决结构自相似的问题。即：构成原问题的子问题与原问题在结构上相似，可以用类似的方法解决。 特点：反复执行、结束反复执行的条件 缺点：占用大量内存且不易阅读 【两个问题】 递归边界条件（递归终止条件）：确定递归到何时终止，或者说，直接有解的情况。 递归模式（递归体）：大问题是如何分解为小问题的。 注：...
斐波那契数列——递归算法
Lucifer_Selina的博客
12-05 4895
【题目描述】 用递归函数输出斐波那契数列第n项。0,1，1，2，3，5，8，13…… 【输入】 一个正整数n,表示第n项。 【输出】 第n项是多少。 ———————————————————————————————— 分析： 斐波那契数列，即第n个数的前两个数相加之和所排列出的数列； 除第一项为0，第二项为1。 从第三项开始n=（n-2）+（n-1) ___________________________________________________________ #inclu
算法——递归
观则明的博客
07-30 253
算法——递归
算法思想——递归与分治
04-18
算法思想——递归与分治 递归和分治是两种常用的算法思想，它们可以单独使用，也可以结合使用以解决复杂的问题。下面我们将详细探讨这两种算法思想。 递归是一种算法思想，它的基本思想是将一个问题分解成一个或多...
c语言分治法求众数重数-五大常见算法策略之——递归与分治策略，算法数据结构
04-07
以下我们将探讨几种基于递归和分治策略的算法，包括Fibonacci数列、阶乘计算和小青蛙跳台阶问题。 首先，Fibonacci数列是递归的一个经典例子。递归定义了一个数列，其中每个数是前两个数的和。在C语言中，我们可以...
算法思想——递归与分治.ppt
10-18
递归与分治的运用不仅限于基础算法，还广泛应用于数据结构（如树的遍历）、图论问题（如最短路径算法）和组合优化问题（如动态规划）等领域。例如，Ackerman函数是一个双递归函数，其定义本身包含递归，且没有非递归...
5力扣：最长回文子串
m0_75015083的博客
08-02 267
从后到前遍历是为了让每一次遍历时所需用到的子串提前被计算过。
LeetCode：2740. 找出分区值（Java 排序）
Cosmoshhhyyy的博客
08-02 281
一道简单的mid题，翻译题目其实就是找出排序后两个相邻数之间的最小差值。
算法第十七天：leetcode242.有效的字母异位词
最新发布
m0_75068978的博客
08-02 498
如下表所示，您可以直接复制下面网址进入力扣学习，在观看下面的内容之前您一定要先做一遍哦，以便让你印象更加深刻！
代码随想录算法训练营第三十三天 | 动态规划理论基础、509. 斐波那契数、70. 爬楼梯、746. 使用最小花费爬楼梯
weixin_43581681的博客
08-01 301
1. 动态规划基础；2. 背包问题；3. 打家劫舍；4. 股票问题；5. 子序列问题。1. 确定 dp[ i ] 数组及下标含义；2. 确定递推公式；3.确定dp数组如何初始化；4. 确定遍历顺序（背包问题中很重要）；5. 举例推导dp数组。
汉诺塔问题——递归算法
10-07
汉诺塔问题是一个经典的递归问题。它是一个益智游戏，目标是将一堆圆盘从一个柱子移动到另一个柱子，并且在移动过程中保持大盘子永远在小盘子上方。问题可以分解为三个子问题：将n-1个圆盘从起始柱子移动到辅助柱子，将最大的圆盘从起始柱子移动到目标柱子，然后再将n-1个圆盘从辅助柱子移动到目标柱子。通过递归调用自身来解决这些子问题，最终完成整个移动过程。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Caaaaaan

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值