算法笔记——递归(1)

已于 2023-11-24 15:08:55 修改
阅读量75 收藏
点赞数
分类专栏： # 算法笔记刷题 文章标签： 算法 笔记 c++
于 2023-11-12 13:59:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yihoujian_2003/article/details/134359213
版权

这里写目录标题

递归的思想

  • 子问题须与原始问题为同样的事，且更为简单。
    不能无限制地调用本身，须有个出口，化简为非递归状况处理

序列求最大值

在这里插入图片描述
求出输出n个数据中的最大值
方法一：直接一边输出然后进行比较大小
方法二：利用数组然后用递归的思想进行

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 100;
int a[N];//全局变量嘛，随意函数不需要再一次的定义了
int fin(int n)
{
	if (n == 1)
	{
		return a[1];
	}
	else  
		return max(fin(n - 1), a[n]);  
}
int main()  
{
	int n;  
	cin >> n;  
	for (int i = 0; i < n; i++)  
	{
		cin >> a[i];  
	}
	printf("%d", fin(n));  
	return 0;  
}

翻转字符串

在这里插入图片描述

  1. 需要知道的是在c++中string库中 字符相加是自动的链接的
  2. 其中考察的知识点有tring sub2 = s.substr(5, 3); //从下标为5开始截取长度为3位：sub2 = “567”

substr函数格式 (俗称：字符截取函数)
　　格式1： substr(string string, int a, int b);
　　格式2：substr(string string, int a) ;

解释：

格式1：
1、string 需要截取的字符串
2、a 截取字符串的开始位置（注：当a等于0或1时，都是从第一位开始截取）
3、b 要截取的字符串的长度

格式2：
1、string 需要截取的字符串
2、a 可以理解为从第a个字符开始截取后面所有的字符串。

//翻转字符串
//利用了一个函数s.substr()
#include<iostream>  
#include<algorithm>  
#include<string>  
using namespace std;  
const int N = 1001;  
string s;  
string reverse(int n)  
{
	if (n == 1)  
	{
		return s.substr(0, 1);  
	}
	else  
		return s.substr(n - 1, 1) + reverse(n - 1);  
}
int main()  
{
	cin >> s;  
	cout << reverse(s.length()) << endl;  
	return 0;  
}

斐波那契数列

在这里插入图片描述

雯波那契数列
给定一个正整数n，求结果第n项f[n]
当n=1时，f[n]=1 n=2时 f[n]=1
n>2时 f(n)=f(n-1)+f(n-2)

#include <cstdio>   

int f(int n) {   
    if (n <= 2) {   
        return 1;   
    } else {   
        return f(n - 1) + f(n - 2);   
    }
}

int main() {   
    int n;   
    scanf("%d", &n);   
    printf("%d\n", f(n));   
    return 0;   
}

数塔

在这里插入图片描述

在这里插入图片描述

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 1001;
int a[N][N], n;
int getmax(int i, int j)//从左边和右边分别求出最大值的路径，递归的方式
{
	if (n == i)//这个是到n层是的条件，进行反向的输出数据
	{
		return a[n][j];
	}
	else
	{
		return max(getmax(i + 1, j), getmax(i + 1, j + 1));//求出的是左右边值的最大值
	}

}
int main()
{
	cin >> n;
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= i; j++)//纵坐标是根据衡坐标来的，但是本质上还是二维数组
		{
			cin >> a[i][j];
		}
	}
	printf("%d", getmax(1, 1));//调用二维数组衡坐标和纵坐标
	return 0;
}

回文字符串

在这里插入图片描述


//运用的是true进行判断的，实际的效果真的很好
//注意的点：
//求字符串的长度的时候，用s.length()本身自带的函数
//利用布尔函数进行
#include<iostream>
using namespace std;
string s;
bool personer(int i, int j)
{
	if (i >= j)
	{
		return true;
	}
	else  
		return (personer(i + 1, j - 1) && s[i] == s[j]);  
}
int main()  
{
	cin >> s;  
	//判断是不是回文,'YES'是true，’NO‘是false  
	cout << personer(0, s.length() - 1) ? "YES" : "NO" << endl;  
	return 0;  
}

上楼

在这里插入图片描述
在这里插入图片描述
上楼问题，一共有n级台阶，每次选择上一级或者两级
例如当 n=3时，共有三种方式上楼：
一级->一级->一级；
一级->二级；
二级->一级。

对于截止条件n<=1是考虑的是终止条件，因为最后走到顶点的是二步或者一步，所以终止条件的设置表明了这一条方案走的步骤是对的，所有步数为1


#include <cstdio>
int f(int n) 
{
    if (n <= 1) 
    {
        return 1;
    }
    else 
    {
        return f(n - 1) + f(n - 2);
    }
}
int main()   
{
    int n;  
    scanf("%d", &n);  
    printf("%d\n", f(n));  
    return 0;  
}

汉诺塔

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

//#include <cstdio>
//#include <cmath>
//void moveHanoi(int n, char from, char to, char mid) 
//{
//    if (n == 0) 
//    {
//        return;
//    }
//    else 
//    {
//        moveHanoi(n - 1, from, mid, to);
//        printf("%c->%c\n", from, to);
//        moveHanoi(n - 1, mid, to, from);
//    }
//}
//
//int main() 
//{
//    int n;
//    scanf("%d", &n);
//    printf("%d\n", (int)pow(2.0, 1.0 * n) - 1);
//    moveHanoi(n, 'A', 'C', 'B');
//    return 0;
//}


//步骤，将n-1个圆盘移动到辅助柱上面，最后一个移动到目标柱，然后将辅助柱上的所有移动到目标柱子上面
//void hanoi(int num,char sou, char tar, char aux)//圆盘的个数，起始点，目标点，辅助点
//{
//    static int count = 1;
//    if (num == 1)
//    {
//        cout << "第" << count << "次：从<<sou<<"移动到" <<tar<<endl;



//            count++   
//    }   
//    else   
//    {   
//        hanoi(num - 1, sou, aux, tar);   
//        cout << "第" << count << "次：从" << sou << "移动到" << tar << endl;



//        count++;   
//        hanoi(num - 1, aux, tar, sou);   
//    }   
//}

棋盘覆盖问题

在这里插入图片描述在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include <iostream>
int tile = 1;        // 骨牌序号
int board[128][128]; // 二维数组模拟棋盘

 
// (tr,tc)表示棋盘的左上角坐标(即确定棋盘位置), (dr,dc)表示特殊方块的位置, size=2^k确定棋盘大小
void chessBoard(int tr, int tc, int dr, int dc, int size)
{
    // 递归出口
    if (size == 1)
        return;
    int s = size / 2; //分割棋盘
    int t = tile++;   //t记录本层骨牌序号
    // 判断特殊方格在不在左上棋盘
    if (dr < tr + s && dc < tc + s)
    {
        chessBoard(tr, tc, dr, dc, s); //特殊方格在左上棋盘的递归处理方法
    }
    else
    {
        board[tr + s - 1][tc + s - 1] = t;             // 用t号的L型骨牌覆盖右下角
        chessBoard(tr, tc, tr + s - 1, tc + s - 1, s); // 递归覆盖其余方格
    }
    // 判断特殊方格在不在右上棋盘
    if (dr < tr + s && dc >= tc + s)
    {
        chessBoard(tr, tc + s, dr, dc, s);
    }
    else
    {
        board[tr + s - 1][tc + s] = t;
        chessBoard(tr, tc + s, tr + s - 1, tc + s, s);
    }
    // 判断特殊方格在不在左下棋盘
    if (dr >= tr + s && dc < tc + s)
    {
        chessBoard(tr + s, tc, dr, dc, s);
    }
    else
    {
        board[tr + s][tc + s - 1] = t;
        chessBoard(tr + s, tc, tr + s, tc + s - 1, s);
    }

    // 判断特殊方格在不在右下棋盘
    if (dr >= tr + s && dc >= tc + s)
    {
        chessBoard(tr + s, tc + s, dr, dc, s);
    }
    else
    {
        board[tr + s][tc + s] = t;
        chessBoard(tr + s, tc + s, tr + s, tc + s, s);
    }
}

int main()
{
    int boardSize = 8;                 // 棋盘边长
    chessBoard(0, 0, 3, 3, boardSize); // (0, 0)为顶点，大小为boardSize的棋盘； 特殊方块位于(3, 3)
    // 打印棋盘
    int i, j;
    printf("\n\n\n");
    for (i = 0; i < boardSize; i++)
    {
        for (j = 0; j < boardSize; j++)  
        {
            printf("%d\t", board[i][j]);  
        }
        printf("\n\n\n");  
    }
    return 0;  
}

数字螺旋矩阵

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include <cstdio>

const int MAXN = 25;
int a[MAXN][MAXN], idx = 1;

void genMatrix(int n, int x, int y) {
    if (n == 0) {
        return;
    } else if (n == 1) {
        a[x][y] = idx++;
    } else {
        for (int j = y; j < y + n - 1; j++) {
            a[x][j] = idx++;
        }
        for (int i = x; i < x + n - 1; i++) {
            a[i][y + n - 1] = idx++;
        }
        for (int j = y + n - 1; j > y; j--) {
            a[x + n - 1][j] = idx++;
        }
        for (int i = x + n - 1; i > x; i--) {
            a[i][y] = idx++;
        }
        genMatrix(n - 2, x + 1, y + 1);
    }
}

int main() {  
    int n;  
    scanf("%d", &n);  
    genMatrix(n, 0, 0);  
    for(int i = 0; i < n; i++) {  
        for(int j = 0; j < n; j++) {  
            printf("%d", a[i][j]);  
            printf(j < n - 1 ? " " : "\n");  
        }
    }
    return 0;  
}

盒分形

在这里插入图片描述
在这里插入图片描述

#include <cstdio>
#include <cmath>
#include <cstring>

const int MAXN = 3 * 3 * 3 * 3 * 3 * 3;
char mp[MAXN][MAXN];

void f(int n, int x, int y) {
    if (n == 1) {
        mp[x][y] = 'X';
    } else {
        int unit = (int)pow(3.0, n - 2);
        f(n - 1, x, y);
        f(n - 1, x, y + 2 * unit);
        f(n - 1, x + unit, y + unit);
        f(n - 1, x + 2 * unit, y);
        f(n - 1, x + 2 * unit, y + 2 * unit);
    }
}

int main() {
    int n;
    scanf("%d", &n);
    memset(mp, ' ', sizeof(mp));
    f(n, 0, 0);
    int edge = (int)pow(3.0, n - 1);
    for (int i = 0; i < edge; i++) {
        for (int j = 0; j < edge; j++) {
            printf("%c", mp[i][j]);
        }
        printf("\n");
    }
    return 0;
}

在这里插入图片描述

一直爱莲子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
算法学习笔记——递归算法
qq_59575689的博客
03-23 192
递归思维是一种从下向上的思维方式，使用递归算法往往可以简化我们的代码，而且还帮我们解决了很复杂的问题。当你将问题不断缩小规模递去的时候，必须有一个明确的结束递去的临界点（递归出口），一旦达到这个临界点即就从该点原路返回到原点，最终问题得到解决。将递归问题分解为若干个规模较小，与原问题形式相同的子问题，这些子问题可以用相同的解题思路来解决。递归算法就是将原问题不断分解为规模缩小的子问题，然后递归调用方法来表示。（用同一个方法去解决规模不同的问题）（2）提取重复的逻辑，缩小问题的规模不断递去。
算法图解——递归
01-07
递归 函数自己调用自己 在用递归的同时，也可以用while循环实现 递归只是让解决方案更加清晰，并没有性能上的优势，有时候甚至循环的性能更好 “如果使用循环，程序性能可能更高；如果使用递归，程序可能更容易理解...
算法笔记——递归练习
weixin_44698281的博客
11-25 198
1、分治思想与递归手段 首先，分治的英文是divide and conquer， 也就是分而治之的意思，基本策略是将原问题划分为若干个规模较小而结构与原问题相同或相似的子问题，然后分别解决这些子问题，最后合并子问题的解就能得到原问题的解。 一般我们都是使用递归的手段去实现分治思想 2、递归 概念：通过反复调用自身函数， 但是每次都把问题范围缩小，直到范围缩小到可以直接得到边界数据的结果，然...
数据结构与算法笔记01——递归
qq_29787929的博客
01-15 452
以爬楼梯为例，每次只能爬一个台阶或两个台阶，爬上n个台阶有多少种爬法。上述方法存在多次函数调用及重复计算可以用一下的方式进行改进。
算法课程笔记——如何递归
2302_79123319的博客
04-23 186
Java数据结构与算法笔记——递归简介
Mr_Wanderer的博客
02-12 139
文章目录递归简介递归案例 递归简介 程序调用自身的编程技巧称为递归。 递归的思路是把一个大型复杂问题层层转化为一个与原问题相似的规模较小的问题来求解。 递归策略只需少量的程序就可以描述出解题过程所需的多次重复计算，极大地减少了程序的代码量。 递归必须要有三个要素： 边界条件：当边界条件不满足时，递归前进；边界条件满足时，递归返回。 递归前进段：实现递归前进 递归返回段：实现递归返回 使用递归，主要是用它的思路来解决问题，而不是因为它的效率。For循环的效率其实优于递归。 递归案例 例如：求一个数的阶乘：n!
算法学习笔记——递归思想
清丶弦的博客
01-04 297
理解递归的含义 理解递归的含义是我们熟练运用递归的前提，首先，什么是递归？递归即是指函数、过程、子过程在运行过程中直接或间接调用自身而产生的重入现象。 ...
Elixir学习笔记——递归
chenxupest的专栏
06-05 835
Elixir 不提供循环构造。相反，我们利用递归和高级函数来处理集合。本章将探讨前者。
Java笔记 —— 递归
一纸春秋的博客
10-19 624
目录递归与嵌套的区别递归实例一实例二实例三实例四实例五 递归与嵌套的区别 递归： 方法定义本身调用方法本身的现象叫递归 方法嵌套：Math.max(Math.max(a,b),c); 这仅仅是方法的嵌套使用 递归的注意点： 递归一定要有一个出口，也就是结束条件，否则就是死循环。可以用System.exit(0);退出递归调用 递归的次数不能太多，否则就会发生内存溢出。因为每次递归都会占用一定的栈内存 构造方法不能递归使用 递归的思路： 第一件事，需要明确递归方法的功能。 比如说这个方法是要计算一个数的
算法学习笔记——递归注意事项
m0_52671591的博客
03-20 154
算法学习笔记——递归注意事项 递归总有一个最简单的情况——方法的第一条语句总是一个包含return的语句； 递归调用总是尝试解决一个规模更小的子问题，这样递归才能收敛到最简单的情况； 递归的子问题中不能有交集。 ...
算法导论学习笔记——递归及解法
wennin的博客
04-11 284
算法导论学习笔记——递归及解法 大O表示法：算法运行上界 f(n)=O(g(n))f(n)=O(g(n))f(n)=O(g(n)) ： 存在一个常数 c>0,n0>0c>0,n_0>0c>0,n0​>0，such that 0<=f(n)<=cg(n)0 <= f(n) <= cg(n)0<=f(n)<=cg(n), for all n>=n0n >= n_0n>=n0​。 f(n)f(n)f(n)以g(n)g(n)
算法思想——递归与分治
04-18
算法思想——递归与分治 算法思想——递归与分治
C语言——递归算法
05-18
C语言中递归是重中之重的部分，多数用于求解N！等含有迭代性质的问题，此文档详细介绍了递归算法，实用。
c语言分治法求众数重数-五大常见算法策略之——递归与分治策略，算法数据结构
04-07
c语言分治法求众数重数-五大常见算法策略之——递归与分治策略，算法数据结构 五大常用算法
东北大学2022编译原理实验课——递归下降分析简单算术表达式（C++）
05-11
1．设计简单算数表达式语法分析器算法；（用递归下降分析来实现） 2．编写代码并上机调试运行通过。 【输入形式】 简单算数表达式 【输出形式】 True/False 【样例输入】 x+y*(3*a+7)-b/5 x+y*(3*a+7-b/5 【样例输出...
牛客网刷题 | BC118 N个数之和
m0_64000959的博客
06-09 493
目前主要分为三个专栏，后续还会添加： 专栏如下： C语言刷题解析 C语言系列文章 我的成长经历感谢阅读！初来乍到，如有错误请指出，感谢！输入数字N，然后输入N个数，计算这N个数的和。第一行输入一个整数N(0≤N≤50)，第二行输入用空格分隔的N个整数。输出为一行，为第二行输入的“N个整数之和”的计算结果。使用数组的方式 先将用户输入的几个数字分别存起来定义一个变量将它数字的和加起来然后输出 代码 2 ： 输入n个数相加，应该想到循
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 404
【代码】力扣LCP 08.剧情触发时间。
LeetCode 算法：轮转数组c++
小金牛来了
06-09 684
LeetCode 算法：轮转数组c++
LSS 和 BEVDepth算法解读
最新发布
pytorch内部机制解读
06-13 932
当前BEV的研究大都基于深度学习的方法，从组织BEV特征信息的方式来看，主流方法分属两类：自底向上方法和自顶向下方法。自底向上方法比较早的代表工作是LSS，后来BEVDet、BEVDepth等也是基于LSS的框架来进行优化。自底向上方法核心是：Lift——对各相机的图像显性地估计像平面下采样后特征点的深度分布，得到包含图像特征的视锥（点云）；Splat——结合相机内外参把所有相机的视锥（点云）分配到BEV网格中，对每个栅格中的多个视锥点进行sum-pooling计算，形成BEV特征图；
汉诺塔问题——递归算法
10-07
问题可以分解为三个子问题：将n-1个圆盘从起始柱子移动到辅助柱子，将最大的圆盘从起始柱子移动到目标柱子，然后再将n-1个圆盘从辅助柱子移动到目标柱子。通过递归调用自身来解决这些子问题，最终完成整个移动过程。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一直爱莲子

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

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

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

打赏作者

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

抵扣说明：

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

余额充值