递归与递推

最新推荐文章于 2022-06-25 11:21:58 发布

幸愉聊信奥

最新推荐文章于 2022-06-25 11:21:58 发布

阅读量283

点赞数

分类专栏：蓝桥杯文章标签：递归与递推

本文链接：https://blog.csdn.net/Edviv/article/details/106994371

版权

蓝桥杯专栏收录该内容

16 篇文章 1 订阅

订阅专栏

文章目录

递归实现指数型枚举
递归实现排列型枚举
简单斐波那契
费解的开关
递归实现组合型枚举
带分数
飞行员兄弟
翻硬币

递归实现指数型枚举

题目大意
从 1 ~ n 这 n 个整数中随机选取任意多个，输出所有可能的选择方案。
输入格式
输入一个整数n。
输出格式
每行输出一种方案。
同一行内的数必须升序排列，相邻两个数用恰好1个空格隔开。
对于没有选任何数的方案，输出空行。
本题有自定义校验器（SPJ），各行（不同方案）之间的顺序任意。
数据范围
1<=n<=15
输入样例

输出样例

解题思路
递归搜索解空间,到搜索边界输出,每个数只有两种状态,选或是不选,选就记录一下。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
vector< int>v;
int n;
void dfs(int x)
{
    if(x==n+1)  // 递归边界
    {
        for(int i=0;i < v.size();++i) printf("%d ",v[i]);
        puts("");
        return;
    }
    //不选
    dfs(x+1);
    //选
    v.push_back(x);
    dfs(x+1);
    //还原现场
    v.pop_back();
}
int main()
{
    scanf(" %d",&n);
    dfs(1);
    return 0;
}

递归实现排列型枚举

题目大意
把 1 ~ n 这 n 个整数排成一行后随机打乱顺序，输出所有可能的次序。
输入格式
一个整数n。
输出格式
按照从小到大的顺序输出所有方案，每行1个。
首先，同一行相邻两个数用一个空格隔开。
其次，对于两个不同的行，对应下标的数一一比较，字典序较小的排在前面。
数据范围
1≤n≤9
输入样例

输出样例

解题思路
在这里插入图片描述

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;
int n;
bool vis[20];
vector <int> v;
void dfs(int x)
{
    if(x>n) //递归边界
    {
        for(int i = 0;i < v.size(); ++i) printf("%d ",v[i]);
        puts("");
        return;
    }
    //解空间
    for(int i = 1; i <= n; ++i)
    {
        if(vis[i]) continue;  //当前这个数已经选择则不选
        // 选择 i 
        v.push_back(i);   
        vis[i]=true;
        // 递归搜索
        dfs(x+1);
        //现场还原
        v.pop_back();
        vis[i]=false;
    }
}
int main()
{
    scanf("%d",&n);
    dfs(1);
    return 0;
}

简单斐波那契

题目大意
以下数列0 1 1 2 3 5 8 13 21 …被称为斐波纳契数列。
这个数列从第3项开始，每一项都等于前两项之和。
输入一个整数N，请你输出这个序列的前N项。
输入格式
一个整数N。
输出格式
在一行中输出斐波那契数列的前N项，数字之间用空格隔开。
数据范围
0<N<46
输入样例

输出样例

0 1 1 2 3

解题思路
f[i] = f[i-1] + f[i-2] (1<i<n)

#include <cstdio>
using namespace std;
const int maxn=50;
int f[50],n;
int main()
{
    scanf("%d",&n);
    f[1]=1;
    if(n>1)
        for(int i=2;i < n;++i) f[i]=f[i-1]+f[i-2];
    for(int i=0;i < n;++i) printf("%d ",f[i]);
    return 0;
}

费解的开关

题目大意
你玩过“拉灯”游戏吗？25盏灯排成一个5x5的方形。每一个灯都有一个开关，游戏者可以改变它的状态。每一步，游戏者可以改变某一个灯的状态。游戏者改变一个灯的状态会产生连锁反应：和这个灯上下左右相邻的灯也要相应地改变其状态。
我们用数字“1”表示一盏开着的灯，用数字“0”表示关着的灯。下面这种状态

在改变了最左上角的灯的状态后将变成：

再改变它正中间的灯后状态将变成：

给定一些游戏的初始状态，编写程序判断游戏者是否可能在6步以内使所有的灯都变亮。
输入格式
第一行输入正整数n，代表数据中共有n个待解决的游戏初始状态。
以下若干行数据分为n组，每组数据有5行，每行5个字符。每组数据描述了一个游戏的初始状态。各组数据间用一个空行分隔。
输出格式
一共输出n行数据，每行有一个小于等于6的整数，它表示对于输入数据中对应的游戏状态最少需要几步才能使所有灯变亮。
对于某一个游戏初始状态，若6步以内无法使所有灯变亮，则输出“-1”。
数据范围
0< n ≤500
输入样例

输出样例

3
2
-1

解题思路
1.每一行的灯光只按一次。
2.每一行开关的操作,完全被前一行的灯的亮灭状态所决定。
按法与灯是否开或者关没有影响

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#define INF 0x3f3f3f3f
using namespace std;
const int N=10;
int a[N][N],b[N][N];
int dir[6][2]={-1,0,0,0,1,0,0,1,0,-1};
bool inbound(int x,int l,int r) //判断位置是否合法
{
    if(x<l || x>r) return false;
    return true;
}
bool check()  //判断灯是否全亮
{
    for(int i=1;i<=5;++i)
        for(int j=1;j<=5;++j)
            if(!b[i][j]) return false; //1表示亮，0表示关
    return true;
}
void Change(int x,int y)  //转变函数
{
    for(int i=0;i<5;++i)
    {
        int tx=x+dir[i][0],ty=y+dir[i][1];
        if(!inbound(tx,1,5)||!inbound(ty,1,5)) continue;
        b[tx][ty]^=1;
    }
}
void work()
{
    int ans=INF;
    for(int i=1;i<=1<<5;++i)  //32种状态,二进制状态枚举
    {
        memcpy(b,a,sizeof(a));  //复制
        int step=0;
        for(int j=1;j<=5;++j)  //枚举第一行
        {
            if(!(i>>(j-1)&1))  //第一行的第j个灯是关着的,0按，1不按
            {
                Change(1,j);
                step++;
            }
        }
        
        for(int j=1;j<=4;++j)  //剩下i+1行
            for(int k=1;k<=5;++k)
                if(!b[j][k])
                {
                    step++;
                    Change(j+1,k);
                }
            if(check()) ans=min(ans,step);
    }
    if(ans>6) puts("-1");
    else printf("%d\n",ans);
}
int main()
{
    int t;
    scanf(" %d",&t);
    while(t--)
    {
        getchar();
        char ch;
        for(int i=1;i<=5;++i){
            for(int j=1;j<=5;++j)
            {
                scanf(" %c",&ch);
                a[i][j]=ch-'0';
            }
        }
        getchar();
        work();
    }
    return 0;
}

递归实现组合型枚举

题目大意
从 1 ~ n 这 n 个整数中随机选出 m 个，输出所有可能的选择方案。
输入格式
两个整数 n，m，在同一行用空格隔开。
输出格式
按照从小到大的顺序输出所有方案，每行1个。
首先，同一行内的数升序排列，相邻两个数用一个空格隔开。
其次，对于两个不同的行，对应下标的数一一比较，字典序较小的排在前面（例如1 3 5 7排在1 3 6 8前面）。
数据范围
n>0 ,
0≤m≤n ,
n+(n−m)≤25
输入样例

5 3

输出样例

解题思路
递归搜索,剪枝

#include <cstdio>
#include <vector>
#include <iostream>
using namespace std;
const int maxn=1e5+7;
vector<int>v,ans[maxn];
int n,m,idx;
void dfs(int x)
{
    if(v.size()>m||v.size()+(n-x+1)<m) return; //剪枝
    if(x==n+1)  //递归边界
    {
        for(int i=0;i<v.size();++i) ans[idx].push_back(v[i]);
        idx++;
        return;
    }
    dfs(x+1);
    v.push_back(x);
    dfs(x+1);
    v.pop_back();
}
int main()
{
    scanf(" %d%d",&n,&m);
    dfs(1);
    
    for(int i=idx-1;i>=0;--i){
        for(vector<int>::iterator it=ans[i].begin();it!=ans[i].end();++it){
            cout<<*it<<" ";
        }
        puts("");
    }
    return 0;
}

#include <cstdio>
using namespace std;
const int maxn=1e5+7;
int ans[maxn],n,m;
void dfs(int x,int s)
{
    if(x+n-s<m) return; //剪枝
    if(x==m+1)
    {
        for(int i=1;i<=m;++i) printf("%d ",ans[i]);
        puts("");
        return;
    }
    for(int i=s;i<=n;++i)
    {
        ans[x]=i;
        dfs(x+1,i+1);
        // 恢复现场
        ans[x]=0;
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    dfs(1,1);
    return 0;
}

带分数

题目大意
100 可以表示为带分数的形式：100=3+69258714
还可以表示为：100=82+3546197
注意特征：带分数中，数字 1 ∼ 9 分别出现且只出现一次（不包含 0）。
类似这样的带分数，100 有 11 种表示法。
输入格式
一个正整数。
输出格式
输出输入数字用数码 1∼9 不重复不遗漏地组成带分数表示的全部种数。
数据范围
1≤N<10^6
输入样例

输出样例

解题思路
n = a + b/c --> nc = ac + b
枚举 a; 枚举 c; 判断 b 是否成立。

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn=15;
typedef long long ll;
int n,ans;
bool vis[maxn],t[maxn];
bool check(int a,int c)
{
    ll b=(ll)(n-a)*c;  //求b
    if(!a || !b || !c) return false;  //a!=0,b!=0,c!=0
    memcpy(t,vis,sizeof vis);  //复制
    while(b)  //枚举b的每一位
    {
        ll x=b%10; 
        b/=10;
        if(!x || t[x]) return false;
        t[x]=1;
    }
    for(int i=1;i<=9;++i)  
        if(!t[i]) return false;  //有没出现过的数字
    return 1;
}
void dfs_c(int s,int a,int c)
{
    if(check(a,c)) ans++;  //满足条件
    for(int i=1;i<=9;++i)   
        if(!vis[i])   //未出现过
        {
            vis[i]=1;  // 记录
            dfs_c(s+1,a,c*10+i);  //搜索
            vis[i]=0;  //回溯
        }
}
void dfs_a(int s,int a) //s:当前状态, a:枚举的数字
{
    if(a>=n) return;   //边界
    if(a) dfs_c(s,a,0);  // a!=0
    for(int i=1;i<=9;++i)
        if(!vis[i])   //未出现过
        {
            vis[i]=1;  //记录
            dfs_a(s+1,a*10+i); //搜索
            vis[i]=0;  //回溯
        }
}

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

飞行员兄弟

题目大意
“飞行员兄弟”这个游戏，需要玩家顺利的打开一个拥有16个把手的冰箱。
已知每个把手可以处于以下两种状态之一：打开或关闭。
只有当所有把手都打开时，冰箱才会打开。
把手可以表示为一个4х4的矩阵，您可以改变任何一个位置[i,j]上把手的状态。
但是，这也会使得第i行和第j列上的所有把手的状态也随着改变。
请你求出打开冰箱所需的切换把手的次数最小值是多少。
输入格式
输入一共包含四行，每行包含四个把手的初始状态。
符号“+”表示把手处于闭合状态，而符号“-”表示把手处于打开状态。
至少一个手柄的初始状态是关闭的。
输出格式
第一行输出一个整数N，表示所需的最小切换把手次数。
接下来N行描述切换顺序，每行输入两个整数，代表被切换状态的把手的行号和列号，数字之间用空格隔开。
注意：如果存在多种打开冰箱的方式，则按照优先级整体从上到下，同行从左到右打开。
数据范围
1≤i,j≤4
输入样例

-+--
----
----
-+--

输出样例
6
1 1
1 3
1 4
4 1
4 3
4 4
解题思路
1.二进制状态枚举,总共有1<<16种情况。
2.开关的关闭或者打开与其自身的状态没有关系。

#include <cstdio>
#include <vector>
#include <cstring>
#define f first
#define s second
#define pb push_back
using namespace std;
typedef pair<int,int>PII;
const int maxn=10;
char a[maxn][maxn],t[maxn][maxn];
void turn(int x,int y)  //转换
{
    for(int i=0;i<4;++i)
    {
        if(a[x][i]=='-') a[x][i]='+';
        else a[x][i]='-';
        if(a[i][y]=='-') a[i][y]='+';
        else a[i][y]='-';
    }
    if(a[x][y]=='-') a[x][y]='+';
    else a[x][y]='-';
}
int main()
{
    for(int i=0;i<4;++i) scanf(" %s",a[i]);
    vector<PII>ans;
    for(int op=0;op<(1<<16);++op)
    {
        memcpy(t,a,sizeof t);  //备份
        vector<PII>temp;   //临时变量
        for(int i=0;i<4;++i)  //操作
            for(int j=0;j<4;++j)
                if(op>>(i*4+j)&1)
                {
                    temp.pb({i,j});
                    turn(i,j);
                }
        bool ok=true;  //判断灯是否全亮的标志
        for(int i=0;i<4;++i)
            for(int j=0;j<4;++j)
                if(a[i][j]=='+') ok=false;
        if(ok&&(ans.empty()||ans.size()>temp.size())) ans=temp;
        memcpy(a,t,sizeof a);
    }
    int len=ans.size();
    printf("%d\n",len);
    for(int i=0;i<len;++i) printf("%d %d\n",ans[i].f+1,ans[i].s+1);
    return 0;
}

翻硬币

题目大意
小明正在玩一个“翻硬币”的游戏。
桌上放着排成一排的若干硬币。我们用 * 表示正面，用 o 表示反面（是小写字母，不是零）。
比如，可能情形是：

**oo***oooo

如果同时翻转左边的两个硬币，则变为：

oooo***oooo

现在小明的问题是：如果已知了初始状态和要达到的目标状态，每次只能同时翻转相邻的两个硬币,那么对特定的局面，最少要翻动多少次呢？
我们约定：把翻动相邻的两个硬币叫做一步操作。
输入格式
两行等长的字符串，分别表示初始状态和要达到的目标状态。
输出格式
一个整数，表示最小操作步数
数据范围
输入字符串的长度均不超过100。
数据保证答案一定有解。
输入样例

**********
o****o****

输出样例

解题思路
贪心思路:枚举对应位置是否相等,不等就改变当前状态和下一个状态,最后输出答案。

#include <cstdio>
#include <cstring>
using namespace std;
const int maxn=107;
char s[maxn],p[maxn];
int main()
{
    scanf(" %s %s",s,p);
    int ans=0;
    int lens=strlen(s);
    for(int i=0,j=0;i<lens;++i,++j)
           if(s[i]!=p[j])
           {
               ans++;
               if(s[i+1]=='*') s[i+1]='o';
               else s[i+1]='*';
           }
    printf("%d\n",ans);
    return 0;
}

幸愉聊信奥

关注

0
点赞
踩
0

收藏

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

文章目录递归实现指数型枚举递归实现排列型枚举简单斐波那契费解的开关递归实现组合型枚举带分数飞行员兄弟翻硬币本博客题目来源于Acwing,个人学习总结。递归实现指数型枚举递归实现指数型枚举题目大意从 1 ~ n 这 n 个整数中随机选取任意多个，输出所有可能的选择方案。输入格式输入一个整数n。输出格式每行输出一种方案。同一行内的数必须升序排列，相邻两个数用恰好1个空格隔开。对于没有选任何数的方案，输出空行。本题有自定义校验器（SPJ），各行（不同方案）之间的顺序任意。数据范围1&l
复制链接

扫一扫