第一讲之递归与递推下篇

news2025/2/26 14:42:08

第一讲之递归与递推下篇

  • 带分数
  • 费解的开关
  • 飞行员兄弟
  • 翻硬币

带分数

在这里插入图片描述

用暴力将所有全排列的情况都算出来
在这里插入图片描述> 有三个数，a,b,c
每种排列情况，可以用两层for循环，暴力分为三个部分，每个部分一个数
在这里插入图片描述

当然注意这里，第一层for循环，小于7.因为一共9个数，要保证剩下2个数不为0，要留2个位置
第二层循环，小于8，要保证剩下一个数不为0了，要留一个位置

如果边界值都写小于9的话，那么就会出现a,b,c三个数出现0的情况，这个时候，我们就要特殊的判断下

#include <iostream>

using namespace std;

const int N = 10;

int target;  // 题目给出的目标数
int num[N];  // 保存全排列的结果
bool used[N];  // 生成全排列过程中标记是否使用过
int cnt;  // 计数，最后输出的结果

// 计算num数组中一段的数是多少
int calc(int l, int r) {
  int res = 0;
  for (int i = l; i <= r; i++) {
    res = res * 10 + num[i];
  }
  return res;
}

// 生成全排列
// 当全排列生成后进行分段
void dfs(int u) {
  // 用两层循环分成三段
  if (u == 9) {
    for (int i = 0; i < 7; i++) {
      for (int j = i + 1; j < 8; j++) {
        int a = calc(0, i);
        int b = calc(i + 1, j);
        int c = calc(j + 1, 8);
        // 注意判断条件，因为C++中除法是整除，所以要转化为加减乘来计算
        if (a * c + b == c * target) {
          cnt++;
        }
      }
    }
    return;
  }
  // 搜索模板
  for (int i = 1; i <= 9; i++) {
    if (!used[i]) {
      used[i] = true; // 标记使用
      num[u] = i;
      dfs(u + 1);
      used[i] = false; // 还原现场
    }
  }
}

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

C++STL函数中也有现成的全排列函数(next_permutation等)，可以不用自己手写

#include <bits/stdc++.h>

using namespace std;

const int N = 10;

int target;
int num[N];

int calc(int l, int r) {
  int res = 0;
  for (int i = l; i <= r; i++) {
    res = res * 10 + num[i];
  }
  return res;
}

int main() {
  cin >> target;
  for (int i = 0; i < 9; i++) {
    num[i] = i + 1;
  }
  int res = 0;
  do {
    for (int i = 0; i < 9; i++) {
      for (int j = i + 1; j < 9; j++) {
        int a = calc(0, i);
        int b = calc(i + 1, j);
        int c = calc(j + 1, 8);
        if (a == 0 || b == 0 || c == 0) {
          continue;
        }
        if (a * c + b == c * target) {
          ++res;
        }
      }
    }
    // 调用函数生成全排列
  } while (next_permutation(num, num + 9));
  cout << res << '\n';
  return 0;
}

这主要用两层dfs嵌套来做
先dfs算出a,每个dfs算出的a中，在dfs c,b的话可以根据a与c的值来算

#include<iostream>
#include<cstdio>
#include<cstring>


using namespace std;

const int N = 10;

int n;    //目标数
bool used[N], backup[N];  //全排列的状态数组
int num[N];   //存储全排列的数据
int ans;


bool check(int a, int c)
{
     long long b = n * (long long)c - a * c;
     
     
     if(!a || !b || !c) {return false;}
     
     memcpy(backup, used, sizeof used);
     
     
     //b是算出来的，所以b的数字是没用用到过的
     
     //因为这里要改变used[]数组，递归也在调用used数组那些
     //所以我们要重新创个数组
     
     while(b) 
     {
         int x = b %10; //取出个位数
         b /= 10;
         
         if(! x|| backup[x])
         {
             return false;
         }
         
         backup[x] = true;  //将b中用的数变为真
     }
     
     for(int i = 1; i <= 9; i++)
     {
         if(!backup[i])
         {
             return false;
         }
     }
    return true;
     
}

void dfs_c(int u, int a, int c)
{
    if(u > 9) 
    {
        return;
    }

    if(check(a, c))
    {
        ans++;
    }
    
    
    for(int i = 1;i <= 9; i++)
    {
        if(!used[i])
        {
            used[i] = true;
            dfs_c(u + 1, a, c * 10 + i);
            used[i] = false;         
        }
    }
}   

void dfs_a(int u, int a)
{
    if(a >= n) {return;}
    if(a) {dfs_c(u, a, 0);}
    
    for(int i = 1; i <= 9; i++)
    {
        if(!used[i])
        {
            used[i] = true;
            num[u] = i;
            
           dfs_a(u + 1, a * 10 + i );
            
            used[i] = false;
            
        }
    }
}



int main()
{
    
    scanf("%d", &n);
    dfs_a(0, 0);
    
    cout << ans << endl;
    
    return 0;
    
}

费解的开关

在这里插入图片描述

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

费解的开关，这道题的话，采用暴力的方法。一个开关2种状态：(选与不选)
，因为要求最优的，一个灯改变，它的上下左右相邻的回改变

解题思路：
所以我们先枚举第一行所有的情况 2^32 = 32,然后选择最优的情况
第一行枚举之后，后面依次枚举(利用下一行选开关，来改变上一行开关的状态)，
但是要留下最后一行(因为最后一行，就没有下一行来改变这一行的状态了)，然后检查这一行的状态
如果全是开的，说明这一行都打开了，说明这种枚举方式成功，记录下步数(与之前的比较，选择最优的)
如果不是全部开的，那么就说明枚举失败，进行下一次循环

代码部分细节讲解：

  1. i >> j & 1
    这里其实用的是二进制的形式表示开关，对开关进行的一种优化
    注意：结果的1与0，不表示开关的状态， 结果如果是1表示开关要按，为0表示开关不按
    例如： 如果i为 00001， j为0， 右移0位表示00001，然后和1进行&运算，结果为1，表示开关(00001,从右往左看)，第一个位置要按，j = 1, j = 2…，都表示不按，所以在开关00001这种枚举情况中，按第一个开关就行，其余开关不用按

2.这里开关状态的变化，采用的枚举的方式
3.注意每种枚举情况，都得把数据拷贝下，然后还原初始状态

#include<iostream>
#include<cstdio>
#include<cstring>

using namespace std;


const int N = 6;

char g[N][N], backup[N][N]; //题目要求一组5个字符， 所以是char类型


int dx[5] = {0,-1 , 1, 0, 0}, dy[5] = {0, 0, 0, -1, 1};

void turn(int x, int y)
{
    for(int i = 0; i < 5; i++)
    {
        //四周的开关状态改变
        int a = x + dx[i];
        int b = y + dy[i];
        
        if(a >= 0 && a < 5 && b >=0 &&  b < 5)
        {
            g[a][b] ^= 1;  //用异或来进行状态的改变
        }
    }
}

int main()
{
    int T;
    cin >> T;
    
    while(T--)
    {
        for(int i = 0; i < 5; i++)
        {
           cin >> g[i];
        }
        
        int res = 10; // 题目要求步数小于6，这里用来存每种枚举情况更新的步数
        
       
        
        //枚举第一行32种情况
        for(int i = 0; i < 1 << 5 ; i++)
        {
            int step = 0;
             
            memcpy(backup, g, sizeof g);
            for(int j = 0; j < 5; j++)  
            {

                if(i >> j & 1)
                {
                    step++;
                    turn(0, j); 
                }
            }
            
            //剩下几行(除了最后一行)
            for(int i = 0; i < 4; i++)
             {
                for(int j = 0; j < 5; j++)
                {
                    if(g[i][j] == '0')
                    {
                        step++;
                        turn(i + 1, j); // 让上一行的打开   
                    }
                }
            }
        
        //检查最后一行是否全部都开了
            bool dark = false;  //判断是否关了
        
            for(int i = 0; i < 5; i++)
            {
                if(g[4][i] == '0' )
                {
                    
                    dark = true;
                    break;
                }
            }
        
            if(!dark) //最后一行全开了，比较那个步骤少 ，res更新结果
            {
                //printf("res = %d , step = %d\n", res, step);
                res = min(res, step);  
            }
            memcpy(g, backup,sizeof backup);
        }
        
         if(res > 6) 
        {
            cout << -1 << endl;
        }
        else
        {
            cout << res << endl;
        }
    }
    
    return 0;
}

飞行员兄弟

在这里插入图片描述

在这里插入图片描述

这题的思路，跟上题费解的开关，思路差不多，不同的是上题是枚举第一行数据找最优
因为这个开关变化之后，这个开关对应的这一行，这一列都会变化，因为数据不多，
所以可以全部开关都进行暴力枚举

也是采用二进制数进行优化
枚举之后，在判断是否符合条件，当然这里需要我们输出每次改变开关的位置
我这里用vector存储的，pair类型<int, int>

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>

#define x first
#define y second

using namespace std;

const int N = 5;
char g[N][N], backup[N][N];

//返回位置
int get(int x, int y)
{
    return x * 4 + y;
}

void turn_one(int x, int y)
{
    if(g[x][y] == '+')
    {
        g[x][y] = '-';
    }
    else
    {
        g[x][y] = '+';
    }
}

void turn_all(int x, int y)
{
    for(int j = 0; j < 4; j++)
    {
        turn_one(x, j);
        turn_one(j, y);
    }
    //本身翻了2次，相当于没翻，所以还得翻一次
    turn_one(x, y);
}


int main()
{
    
    for(int i = 0; i < 4; i++)
    {
        for(int j = 0; j < 4; j++)
        {
            cin >> g[i][j];
        }
    }
    
    vector<pair<int, int>> result;
    
    //枚举出所有的情况
    for(int pos = 0 ; pos < 1 << 16; pos++)
    {
        vector<pair<int, int>> temp;

        memcpy(backup, g, sizeof g);     
     
        for(int i = 0; i < 4; i++)
        {
            for(int j = 0; j < 4; j++)
            {
                if(pos >> get(i, j) & 1)  //二进制的形式，为1表示需要按， 注意:这里的get(i, j) 要求得具体翻那几个位置
                {
                    temp.push_back({i, j});
                    turn_all(i, j);                
                }
            }
        }
        
        bool has_closed = false;
        
        //看是否所有的灯都开了
        for(int i = 0; i < 4; i++)
        {
            for(int j = 0; j < 4; j++)
            {
                if(g[i][j] == '+')
                {
                    has_closed = true;
                    break;
                }
            }
        }
        
        if(!has_closed)
        {
            if(result.empty() || result.size() > temp.size())
                {
                    result = temp;
                }
        }
        
        memcpy(g, backup, sizeof backup);
    }
    
    cout << result.size() << endl;
        
    for(auto v : result)
    {
        cout << v.first + 1 << " " << v.second + 1 << endl;
    }
    
    return 0;
}

翻硬币

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

这题的话，虽然看着代码简单，但是也还是需要我们自己模拟下情况，才做的出来
判断开关的状态的话，前n- 1个就行，第n个肯定一样，因为题干说肯定有解

#include<iostream>
#include<cstdio>
#include<string>

using namespace std;

string a, b;

void turn(int x)
{
    if(a[x] == 'o')
    {
        a[x] = '*';
    }
    else
    {
        a[x] = 'o';
    }
    
}

int main()
{
    
    cin >> a >> b;

    int count = 0;
    
    //前n- 1个就行，第n个肯定一样，因为题干说肯定有解
    for(int i = 0; i < a.size() - 1; i++)
    {
        if(a[i] != b[i])
        {
            count++;
            turn(i);
            turn(i + 1);
        }
    }
    cout << count << endl;
    
    return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1214754.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【Spring进阶系列丨第二篇】Spring中的两大核心技术IoC（控制反转）与DI（依赖注入）

【Spring进阶系列丨第二篇】Spring中的两大核心技术IoC（控制反转）与DI（依赖注入）

前言 我们都知道Spring 框架主要的优势是在 简化开发 和 框架整合 上&#xff0c;至于如何实现就是我们要学习Spring 框架的主要内容&#xff0c;今天我们就来一起学习Spring中的两大核心技术IoC&#xff08;控制反转&#xff09;与DI&#xff08;依赖注入&#xff09;。 文章目…
阅读更多...
关于CISSP中文版计算机化自适应考试（CAT），你需要知道的！

关于CISSP中文版计算机化自适应考试（CAT），你需要知道的！

进入ISC2宣布CISSP简体中文的线性考试(Linear Test)被取消&#xff0c;逐步实行CISSP中文版计算机化自适应考试&#xff08;CAT&#xff09;。接下来我根据ISC2官网和互联网中关于CAT相关信息&#xff0c;给大家对CISSP认证CAT进行介绍。 一、什么是CISSP认证线性考试&#xf…
阅读更多...
实时云渲染技术在智慧园区中的广泛应用

实时云渲染技术在智慧园区中的广泛应用

智慧园区是指通过运用先进的信息技术&#xff0c;利用物联网、大数据、云计算等技术手段&#xff0c;来实现对园区内各类设备、设施和资源进行监测、管理、控制和优化的平台。这一概念旨在提高园区运行的效率、实现资源的可持续利用&#xff0c;并通过数字化和智能化手段来推动…
阅读更多...
010.cat、find

010.cat、find

1、用cat进行拼接 cat命令能够显示或拼接文件内容&#xff0c;不过它的能力远不止如此。比如说&#xff0c;cat能够将标准输入数据与文件数据组合在一起。通常的做法是将stdin重定向到一个文件&#xff0c;然后再合并两个文件。而cat命令一次就能搞定这些操作。 用cat读取文件…
阅读更多...
QGIS之二十二矢量线交点处分割线

QGIS之二十二矢量线交点处分割线

效果 步骤 1、准备数据 现有的线数据有部分线相交的地方并没有分割 2、分割 运行 3、结果
阅读更多...
打造“下一个鹿晗”，是风华秋实的上市“通行证”？

打造“下一个鹿晗”，是风华秋实的上市“通行证”？

今年以来&#xff0c;文娱公司们动作频频&#xff0c;乐华娱乐、巨星传奇接连“上岸”港交所。近日&#xff0c;因2010年一场“怒放”演唱会声名鹊起的风华秋实&#xff0c;也第七次向港交所递交了招股书。 据招股书披露&#xff0c;2020至2022年&#xff0c;风华秋实连续三年…
阅读更多...
网站SEO优化

网站SEO优化

网站SEO优化 浏览722 一、合理的title、description、keywords 搜索对着三项的权重逐个减小&#xff0c;title值强调重点即可&#xff1b;description把页面内容高度概括&#xff0c;不可过分堆砌关键词&#xff1b;keywords列举出重要关键词。 1、title title&#xff0c;…
阅读更多...
Java爬取哔哩哔哩视频（可视化）

Java爬取哔哩哔哩视频（可视化）

链接&#xff1a;我的讲解视频https://www.bilibili.com/video/BV14e411Q7oG/ 本文仅供学术用途 先上图 代码 爬虫核心 import com.alibaba.fastjson2.JSON; import com.alibaba.fastjson2.JSONObject; import com.gargoylesoftware.htmlunit.*; import org.apache.commons.…
阅读更多...
【500强 Kubernetes 课程】第3章 运行docker容器

【500强 Kubernetes 课程】第3章 运行docker容器

一 - 三 &#xff0c;docker基础操作见 第2章7节 四、docker部署web网站 1、安装 nginx &#xff08;适合场景&#xff1a;学习 - 略&#xff09; 2、docker 安装 nginx Stage 1 &#xff1a;docker hub 上 搜索 nginx 镜像 Stage 2&#xff1a;拉取官方镜像 Stage 3&…
阅读更多...
【开源】基于微信小程序、Vue和SpringBoot的智慧家政系统

【开源】基于微信小程序、Vue和SpringBoot的智慧家政系统

项目编号&#xff1a; S 063 &#xff0c;文末获取源码。 \color{red}{项目编号&#xff1a;S063&#xff0c;文末获取源码。} 项目编号&#xff1a;S063&#xff0c;文末获取源码。 目录 一、摘要1.1 项目介绍1.2 项目录屏 二、功能模块三、系统展示四、核心代码4.1 查询家政服…
阅读更多...
软件自动化测试代码覆盖率

软件自动化测试代码覆盖率

在<professional software testing with visual studio 2005 team system tools for software developer>中提到了代码覆盖率&#xff0c;我很久没有去书店了&#xff0c;不知道是不是出了新的版本&#xff0c;觉得书里面关于代码覆盖率方面的知识有些地方没有讲&#xf…
阅读更多...
wpf devexpress数据统计

wpf devexpress数据统计

GridControl允许显示总结信息关于单个数据行分组。例如&#xff0c;你可以显示记录数量&#xff0c;最小和最大值。这个统计信息可以叫做数据统计。 创建统计 GridControl 支持总结和分组统计&#xff1a; 总结统计 - 一个总结函数值计算对于所有列和视图显示统计面板和固定统…
阅读更多...
04.智慧商城——短信验证码倒计时、登录请求、响应拦截器统一处理、请求loading效果

04.智慧商城——短信验证码倒计时、登录请求、响应拦截器统一处理、请求loading效果

01. 短信验证倒计时功能 (1) 倒计时基础效果 准备 data 数据 data () {return {totalSecond: 60, // 总秒数second: 60, // 倒计时的秒数timer: null // 定时器 id} },给按钮注册点击事件 <button click"getCode">{{ second totalSecond ? 获取验证码 : s…
阅读更多...
Go 使用Viper处理Go应用程序的配置

Go 使用Viper处理Go应用程序的配置

在开发Go应用程序时&#xff0c;处理配置是一个常见的需求。配置可能来自于配置文件、环境变量、命令行参数等等。Viper是一个强大的库&#xff0c;可以帮助我们处理这些配置。 什么是Viper&#xff1f; Viper是一个应用程序配置解决方案&#xff0c;用于Go应用程序。它支持JS…
阅读更多...
Go fsnotify简介

Go fsnotify简介

fsnotify是一个用Go编写的文件系统通知库。它提供了一种观察文件系统变化的机制&#xff0c;例如文件的创建、修改、删除、重命名和权限修改。它使用特定平台的事件通知API&#xff0c;例如Linux上的inotify&#xff0c;macOS上的FSEvents&#xff0c;以及Windows上的ReadDirec…
阅读更多...
220V交流转直流的简易电源设计

220V交流转直流的简易电源设计

220V交流转直流的简易电源设计 设计简介设计原理电路图变压器电路交流转直流电路3.3V电源接口电路 PCB3D图 实践检验 设计简介 通过模拟电路的相关知识&#xff0c;尝试将220V的交流电转化为我们指定电压的直流电。 设计原理 将220V交流电转化为直流电的方法常用的有通过变压器…
阅读更多...
（四）什么是Vite——冷启动时vite做了什么（源码、middlewares）

（四）什么是Vite——冷启动时vite做了什么（源码、middlewares）

vite分享ppt&#xff0c;感兴趣的可以下载&#xff1a; ​​​​​​​Vite分享、原理介绍ppt 什么是vite系列目录&#xff1a; &#xff08;一&#xff09;什么是Vite——vite介绍与使用-CSDN博客 &#xff08;二&#xff09;什么是Vite——Vite 和 Webpack 区别&#xff0…
阅读更多...
IO流回顾与装饰者模式

IO流回顾与装饰者模式

目录 代码图示原理 代码 // 初始化服务器System.out.println("初始化服务器");ServerSocket serverSocket new ServerSocket(8087);System.out.println("服务器初始化成功");// 监听服务器Socket accept serverSocket.accept();System.out.println("…
阅读更多...
vue-vuex详解

vue-vuex详解

​&#x1f308;个人主页&#xff1a;前端青山 &#x1f525;系列专栏&#xff1a;Vue篇 &#x1f516;人终将被年少不可得之物困其一生 依旧青山,本期给大家带来vue篇专栏内容:vue-vuex详解 目录 Vuex 1.vuex是什么&#xff1f; 2.vuex核心概念 3.vuex模块化 4. Vuex中ac…
阅读更多...
【Java 进阶篇】JQuery 动画：为页面添彩的魔法

【Java 进阶篇】JQuery 动画：为页面添彩的魔法

在现代的Web开发中&#xff0c;用户体验的提升是至关重要的一环。而动画作为页面交互中的重要组成部分&#xff0c;更是为用户带来了全新的感官体验。本篇博客将深入探讨 JQuery 中动画的应用&#xff0c;带你进入一个充满活力的前端世界。 前言 动画是网页设计的一种重要手段…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023