《啊哈！算法》第三章代码

最新推荐文章于 2022-07-26 17:02:06 发布
最新推荐文章于 2022-07-26 17:02:06 发布
阅读量174 收藏
点赞数
分类专栏： 入门 算法 文章标签： 《啊哈！算法》 算法 入门
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43177214/article/details/100252599
版权
本文介绍了《啊哈！算法》第三章的内容，包括3.2节的炸弹人问题，3.3节的火柴棍等式，以及3.4节的全排列。作者使用枚举法解决这些问题，并期待第四章的学习。
摘要由CSDN通过智能技术生成

细心的小伙伴可能发现我断更了一天，为什么呢？那是因为我开学啦（才不是因为懒呢）
在这里插入图片描述
那么，不废话了 第三章 3.2 炸弹人

public void bomberman(char[][] map){
        int most=0;
        int a1=0,a2=0;
        Scanner sc=new Scanner(System.in);
        for(int i=0;i<map.length;i++){
            map[i]=sc.next().toCharArray();
        }
        for(int i=0;i<map.length;i++){
            for(int j=0;j<map[0].length;j++){
                if(map[i][j]=='.'){
                    int x=0,y=0;
                    int sum=0;
                    x=i;
                    y=j;
                    while(map[x][y]!='#'){
                        if(map[x][y]=='G')
                            sum++;
                        x--;
                    }
                    x=i;
                    y=j;
                    while(map[x][y]!='#'){
                        if(map[x][y]=='G')
                            sum++;
                        x++;
                    }
                    x=i;
                    y=j;
                    while(map[x][y]!='#'){
                        if(map[x][y]=='G')
                            sum++;
                        y--;
                    }
                    x=i;
                    y=j;
                    while(map[x][y]!='#'){
                        if(map[x][y]=='G')
                            sum++;
                        y++;
                    }
                    if(most<sum){
                        most=sum;
                        a1=i;
                        a2=j;
                    }
                }
            }
        }
        System.out.println("the best place is ("+a1+","+a2+"),which can kill "+most
                +" enemies!");
    }

其实就是完全列一遍，比较好理解。
3.3 火柴棍等式

 public int Matchnum(int a){
        int[] matchNeed={6,2,5,5,4,5,6,3,7,6};
        int sum=0;
        while(a/10!=0){
            sum+=matchNeed[a%10];
            a=a/10;
        }
        sum+=matchNeed[a];
        return sum;
    }
    public static void main(String[] args){
        algorithm test=new algorithm();
        Scanner sc=new Scanner(System.in);
        int m=sc.nextInt();
        for(int i=0;i<11111;i++){
            for(int j=0;j<11111;j++){
                if(test.Matchnum(i)+test.Matchnum(j)+test.Matchnum(i+j)==m-4){
                    int sum=i+j;
                    System.out.println(i+"+"+j+"="+sum);
                }
            }
        }
    }

3.4 全排列 啊哈磊大佬完全把谜题留到第四章啦~先用现学的枚举做一遍吧，迫不及待想看第四章了?

public void Permutations(int n){
        int[] book=new int[11];
        for(int i=1;i<=9;i++)
            book[i]=0;
        if(n==1)
            System.out.println("1");
        if(n==2)
            System.out.println("12,21");
        if(n==3){
            for(int a=1;a<=3;a++){
                for(int b=1;b<=3;b++){
                    for(int c=1;c<=3;c++){
                        for(int i=1;i<=3;i++)
                            book[i]=0;
                        int sum=0;
                        book[a]=1;
                        book[b]=1;
                        book[c]=1;
                        for(int i=1;i<=3;i++)
                            sum+=book[i];
                        if(sum==3) {
                            System.out.print(a);
                            System.out.print(b);
                            System.out.print(c+" ");
                        }
                    }}}}
        if(n==4) {
            for (int a = 1; a <= 4; a++) {
                for (int b = 1; b <= 4; b++) {
                    for (int c = 1; c <= 4; c++) {
                        for (int d = 1; d <= 4; d++) {
                            for(int i=1;i<=4;i++)
                                book[i]=0;
                            int sum=0;
                            book[a]=1;
                            book[b]=1;
                            book[c]=1;
                            book[d]=1;
                            for(int i=1;i<=4;i++)
                                sum+=book[i];
                            if(sum==4) {
                                System.out.print(a);
                                System.out.print(b);
                                System.out.print(c);
                                System.out.print(d+" ");
                            }
                        }
                    }
                }
            }
        }
            if(n==5){
                for(int a=1;a<=5;a++) {
                    for (int b = 1; b <= 5; b++) {
                        for (int c = 1; c <= 5; c++) {
                            for (int d = 1; d <= 5; d++) {
                                for(int e=1;e<=5;e++){
                                    for(int i=1;i<=5;i++)
                                        book[i]=0;
                                    int sum=0;
                                    book[a]=1;
                                    book[b]=1;
                                    book[c]=1;
                                    book[d]=1;
                                    book[e]=1;
                                    for(int i=1;i<=5;i++)
                                        sum+=book[i];
                                    if(sum==5) {
                                        System.out.print(a);
                                        System.out.print(b);
                                        System.out.print(c);
                                        System.out.print(d);
                                        System.out.print(e+" ");
                                    }
                            }}}}}
            }
            if(n==6){
                for(int a=1;a<=6;a++) {
                    for (int b = 1; b <= 6; b++) {
                        for (int c = 1; c <= 6; c++) {
                            for (int d = 1; d <= 6; d++) {
                                for(int e=1;e<=6;e++){
                                    for(int f=1;f<=6;f++){
                                    for(int i=1;i<=6;i++)
                                        book[i]=0;
                                        int sum=0;
                                        book[a]=1;
                                        book[b]=1;
                                        book[c]=1;
                                        book[d]=1;
                                        book[e]=1;
                                        book[f]=1;
                                        for(int i=1;i<=6;i++)
                                            sum+=book[i];
                                        if(sum==6) {
                                            System.out.print(a);
                                            System.out.print(b);
                                            System.out.print(c);
                                            System.out.print(d);
                                            System.out.print(e);
                                            System.out.print(f+" ");
                                        }
                                }}}}}}
            }
            if(n==7){
                for(int a=1;a<=7;a++) {
                    for (int b = 1; b <= 7; b++) {
                        for (int c = 1; c <= 7; c++) {
                            for (int d = 1; d <= 7; d++) {
                                for(int e=1;e<=7;e++){
                                    for(int f=1;f<=7;f++){
                                        for(int g=1;g<=7;g++){
                                            for(int i=1;i<=7;i++)
                                                book[i]=0;
                                            int sum=0;
                                            book[a]=1;
                                            book[b]=1;
                                            book[c]=1;
                                            book[d]=1;
                                            book[e]=1;
                                            book[f]=1;
                                            book[g]=1;
                                            for(int i=1;i<=7;i++)
                                                sum+=book[i];
                                            if(sum==7) {
                                                System.out.print(a);
                                                System.out.print(b);
                                                System.out.print(c);
                                                System.out.print(d);
                                                System.out.print(e);
                                                System.out.print(f);
                                                System.out.print(g+" ");
                                            }
                                    }}}}}}}
            }
            if(n==8){
                for(int a=1;a<=8;a++) {
                    for (int b = 1; b <= 8; b++) {
                        for (int c = 1; c <= 8; c++) {
                            for (int d = 1; d <= 8; d++) {
                                for(int e=1;e<=8;e++){
                                    for(int f=1;f<=8;f++){
                                        for(int g=1;g<=8;g++){
                                            for(int h=1;h<=8;h++){
                                                for(int i=1;i<=8;i++)
                                                    book[i]=0;
                                                int sum=0;
                                                book[a]=1;
                                                book[b]=1;
                                                book[c]=1;
                                                book[d]=1;
                                                book[e]=1;
                                                book[f]=1;
                                                book[g]=1;
                                                book[h]=1;
                                                for(int i=1;i<=8;i++)
                                                    sum+=book[i];
                                                if(sum==8) {
                                                    System.out.print(a);
                                                    System.out.print(b);
                                                    System.out.print(c);
                                                    System.out.print(d);
                                                    System.out.print(e);
                                                    System.out.print(f);
                                                    System.out.print(g);
                                                    System.out.print(h+" ");
                                                }
                                        }}}}}}}}
            }
            if(n==9){
                for(int a=1;a<=9;a++) {
                    for (int b = 1; b <= 9; b++) {
                        for (int c = 1; c <= 9; c++) {
                            for (int d = 1; d <= 9; d++) {
                                for(int e=1;e<=9;e++){
                                    for(int f=1;f<=9;f++){
                                        for(int g=1;g<=9;g++){
                                            for(int h=1;h<=9;h++){
                                                for(int k=1;k<=9;k++){
                                                    for(int i=1;i<=9;i++)
                                                        book[i]=0;
                                                    int sum=0;
                                                    book[a]=1;
                                                    book[b]=1;
                                                    book[c]=1;
                                                    book[d]=1;
                                                    book[e]=1;
                                                    book[f]=1;
                                                    book[g]=1;
                                                    book[h]=1;
                                                    book[k]=1;
                                                    for(int i=1;i<=9;i++)
                                                        sum+=book[i];
                                                    if(sum==9) {
                                                        System.out.print(a);
                                                        System.out.print(b);
                                                        System.out.print(c);
                                                        System.out.print(d);
                                                        System.out.print(e);
                                                        System.out.print(f);
                                                        System.out.print(g);
                                                        System.out.print(h);
                                                        System.out.print(k+" ");
                                                    }
                                            }}}}}}}}}
            }
    }
    public static void main(String[] args){
        algorithm test=new algorithm();
        Scanner sc=new Scanner(System.in);//要求不大于9的正整数
        int m=sc.nextInt();
        test.Permutations(m);
    }

呕——太变态了！说到底数据太多枚举听起来就很不靠谱嘛！还是期待期待第四章好了。

小啾
关注
专栏目录
啊哈算法——第三章：暴力枚举
fatfairyyy的博客
10-08 248
第三章：暴力枚举 枚举的思想不必多说，此处仅引数中两例。 火柴棍等式 #include <iostream> using namespace std; const int maxn = 10; int f[maxn] = {6,2,5,5,4,5,6,3,7,6};//组成0~9数字需要的火柴棍个数 int n,cnt = 0; int solve(int x){ //计算当前枚举的数字需要多少根火柴棍来表示 int res = 0; while(x/10){ res += f
《啊哈！算法》克鲁斯卡尔算法源代码（Kruskal）
^.^
08-12 551
算法思想：首先按照边的权值进行由小到大的排序，每次从剩余的边中选择权值较小且边的两个顶点不在同一个集合内的边（就是不会产生回路的边），加入到生成树中，直到加入了n-1条边为止。 #include<iostream> #include<cstdio> #include<algorithm> using namespace std; typedef stru...
啊哈算法，深搜，源代码
^.^
08-22 322
#include<bits/stdc++.h> using namespace std; int a[10],book[10],n; void dfs(int step) { int i; if(step==n+1) { for(int i=1;i<=n;i++) cout<<a[i]; cout<&l...
《啊哈！算法》并查集源代码
^.^
08-09 377
#include<cstdio> #include<iostream> using namespace std; int f[1001]={0},n,m,sum=0; void init(); int getf(int v); void merge2(int v,int u); int main() { int i,x,y; scanf("%d %d",&...
《啊哈！算法》之 迪杰斯特雷算法，源代码
^.^
08-13 237
#include<iostream> #include<cstdio> #include<algorithm> using namespace std; #define INF 1<<31-1 const int maxn=101; int e[maxn][maxn],dis[maxn],book[maxn]; int main() { ...
《啊哈！算法》第八章代码下
weixin_43177214的博客
09-18 251
8.2 最小生成树的堆实现 在这里卡了很久，一直没搞明白pos数组的必要性，最后先不加pos数组写的时候终于发现是需要在边松弛之后直接shift相关终点，所以需要一个点的index导向堆index的数组。 import java.util.Scanner; class Test{ static int size; static int[] h=new int[10]; s...
啊哈！算法-阅读笔记
Lip0041的博客
08-15 275
Table of Contents 第一章 一大波数正在靠近——排序 最快最简单的排序——桶排序 邻居好说话——冒泡排序 最常用的排序——快速排序 总结一哈 第二章 栈、队列、链表 解密回文——栈 典型运用——小猫钓鱼（接树干儿） 模拟链表 第三章 枚举！很暴力 第四章 万能的搜索 深度优先搜索 广度优先搜索 第五章 图的遍历 图的深度优先遍历 图的广度优先遍历 第六章 最短路径 只有五行的算法——Floyd-Warshall Dijkstra算法——通过边实现松弛 Bellma
【蓝桥杯】【啊哈！算法】纸牌游戏——小猫钓鱼（队列和栈的应用）
MCP的博客
04-08 1493
【啊哈！算法】系列文章目录 目录【啊哈！算法】系列文章目录需求介绍思路分析C语言代码存在的问题C++ 代码 需求介绍   星期天小哼和小哈约在一起玩桌游，他们正在玩一个非常古怪的扑克游戏——“小猫钓鱼”。游戏的规则是这样的：将一副扑克牌平均分成两份，每人拿一份。小哼先拿出手中的第一张扑克牌放在桌上，然后小哈也拿出手中的第一张扑克牌，并放在小哼刚打出的扑克牌的上面，就像这样两人交替出牌。出牌时，如果某人打出的牌与桌上某张牌的牌面相同，即可将两张相同的牌及其中间所夹的牌全部取走，并依次放到自己手中牌的末尾。
初入算法门——《啊哈！算法》代码实现
weixin_43177214的博客
08-29 623
突然想要记录一下自己写算法的过程，也算是自我的督促！ 《啊哈！算法》是一本非常有趣可爱的算法书，这也是我把它作为入门算法第一步的原因~那么就开始吧。 第一个代码块 第一章 1.2 冒泡排序 public static void main(String[] args){ Scanner sc=new Scanner(System.in); int N=sc.next...
【蓝桥杯】【啊哈！算法】深度优先搜索——全排列
MCP的博客
04-10 605
【啊哈！算法】系列文章目录 目录【啊哈！算法】系列文章目录需求介绍思路分析C语言代码总结 需求介绍 输入一个数nnn , 输出1 n1~n1 n 的全排列。 思路分析   这里我们先将这个问题形象化， 举个例子，假如有编号为1 、2、3 的3 张扑克牌和编号为1 、2、3 的3 个盒子。现在需要将这3 张扑克牌分别放到3 个盒子里面， 并且每个盒子有且只能放一张扑克牌。那么一共有多少种不同的放法呢？   好了， 现在轮到小哼出马。小哼手拿3 张扑克牌， 首先走到了1 号盒子面前。此时
aHa-algorithm:啊哈算法
03-28
算术算法 啊哈算法
啊哈算法系列-2023-10-11.pdf
最新发布
10-11
啊哈算法系列-2023-10-11
【C++】【啊哈！算法】Folyd算法实现
linghugoogle的博客
10-26 978
#include  using namespace std; int main(){ int n,m; int i,j,k; int t1,t2,t3; int inf=9999;  cin>>n>>m; int e[10][10]; //int *e=new int[n][n]; //初始化为无穷大  for(i=1;i for(j=1;j e[i][j]=inf;
啊哈！算法 案例用c++实现
qq_23923713的博客
12-22 977
第二章 题目： 思路： 题目其实已经给出思路了 代码 #include<iostream> #include<vector> #include<queue> using namespace std; class Solution { public: vector<int> deCode(vector<int>& nums) { vector<int> ret_v; queue<int> qu; f
啊哈算法系列（C语言、python、Java ）
青少年趣味编程
03-14 2735
关于《啊哈！算法》相关资源 关于《啊哈！算法》相关资源 - 欣乐 - 博客园 第1章　一大波数正在靠近--排序 第1节　最快最简单的排序--桶排序 【坐在马桶上看算法】算法1：最快最简单的排序——桶排序 - 啊哈磊 - 博客园 【坐在马桶上看算法】算法1：最快最简单的排序——桶排序 【坐在马桶上看算法】算法1：最快最简单的排序——桶排序 - 啊哈磊 - 博客园 啊哈算法学习-简化版桶排序 啊哈算法学习-简化版桶排序_vivi_vivi_fu的专栏-CSDN博客 第2节　邻居
啊哈算法Demo
u013196181的博客
08-01 1104
根据《啊哈算法》书籍，自己跟着敲的Demo，慢慢的添加，当做记录。// // main.c // ahasuanfa // // Created by pacino on 16/7/22. // Copyright © 2016年 pacino. All rights reserved. //#include <stdio.h> #include <string.h> #include <s
《啊哈！算法》第1章
PoetVVV的博客
09-25 271
章节构成: 桶排序(伪) 例： 题目： 将一堆数排序，给了范围0～10，设一个数组a[11]，下标表示数，值表示该数出现几次，初始情况如图所示： 每个数出现一次，该数组值就 +1。 代码： #include<iostream> using namespace std; int main() { int a[11],i,j,t; for(i=0;i<=10;i+...
【Java】《啊哈算法》-第一章排序
qq_44458489的博客
07-26 243
排序：桶排序、冒泡排序、快速排序
啊哈算法---快速排序（C语言）
m0_54129816的博客
06-24 5292
文章目录前言一、快速排序是什么？实现原理二1.![在这里插入图片描述](https://img-blog.csdnimg.cn/20210624142203649.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzU0MTI5ODE2,size_16,color_FFFFFF,t_70#pic_center)快速排序代码块 前言 冒泡排序在啊
啊哈！算法：寻找缺失的32位整数
算法》这一章中，作者提到了三个小问题来引导读者思考和探索算法的力量。第一个问题是关于在一个包含最多40亿个随机排列32位整数的顺序文件中找出缺失的32位整数。这个问题可以通过理解文件中的数字范围和整数性质来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值