算法学习日记（一）枚举

最新推荐文章于 2023-06-06 15:50:28 发布
最新推荐文章于 2023-06-06 15:50:28 发布
阅读量157 收藏 2
点赞数 2
分类专栏： 数据结构与算法 文章标签： 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43419801/article/details/112862402
版权

一、定义

枚举是基于逐个尝试答案的一种问题求解策略

二、算法

依次遍历每个值，直到找到问题求解答案

三、例题

1、完美立方

image-20210119105705034

确定各个变量的范围：

a：[2,N]

b：[2,a-1]

c：[b,a-1]

d：[c,a-1]

确定了各个变量的范围，避免了不必要的运算，只需要使用四个for循环，就能求出问题解了，

题解代码如下：

public class Ex_1 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        for (int a = 2;a <= n;++a)
            for (int b = 2;b <= a-1;++b)
                for (int c = b;c <= a-1;++c)
                    for (int d = c;d <= a-1;++d)
                        if(a*a*a == b*b*b + c*c*c + d*d*d)
                            System.out.println("Cube = "+a+", Triple = ("+b+","+c+","+d+")");
    }
}

运行测试结果如下：

image-20210119111927475

2、生理周期

image-20210119112036901

image-20210119112237009

**解题思路：**定义一个k，k++，当k同时满足 （k-p)%23 == 0、（k-e)%28 == 0、（k-i)%33 == 0

但是这样会去算很多不必要的数，比如，当找到第一个（k-p)%23 == 0时，我们就要去看k是否满足（k-e)%28 == 0和（k-i)%33 == 0，当后面两者不满足时，说明这个k不是我们要找的，我们就需要进行k++，但是在[k，k+23-1]之间的k一定不满足（k-p)%23 == 0，[k，k+23-1]之间的k相当于做了无意义的运算。所以，当找到第一个k满足第一个条件（k-p)%23 == 0时，在寻找满足第二个和第三个条件时，k++应该变成 k+=23；同理，当找到k满足前两个条件时，[k,k+23* 28-1]之间的数一定不满足前两个条件，所以k的步长应该从 k+=23变成 k+=23*28。经过这样的处理，可以避免大量不必要的计算。

题解代码：

public class Ex_2 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int p = in.nextInt();
        int e = in.nextInt();
        int i = in.nextInt();
        int d = in.nextInt();

        int k;
        for (k = d + 1;(k-p)%23 != 0;k++);
        for ( ;(k-e)%28 != 0;k += 23);
        for ( ;(k-i)%33 != 0;k += 23*28);
        System.out.println(k-d);
    }
}

测试结果：

image-20210119114700181

3、称硬币

image-20210119114938311

image-20210119115025117

注：up表示右边轻，称量结果都用右边和左边比。

**解题思路：**依次对每一枚硬币，首先假设它是重的，然后代入三个称量结果，如果都符合，那么这枚硬币是重的；如果不符合，那么假设这枚硬币的轻的，然后代入三个称量结果，如果都符合，那么这枚硬币是轻的，如果还是不符合，则判断下一枚硬币。

题解代码：

public class Ex_3 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        String[] left = new String[3];  //每一次称重左边的硬币
        String[] right = new String[3];  //每一次称重右边的硬币
        String[] result = new String[3];  //每一次称重的结果

        while (n > 0){
            //输入
            for (int i = 0;i < 3;i++){
                left[i] = in.next();
                right[i] = in.next();
                result[i] = in.next();
            }
            n--;
            //遍历每一个硬币
            for (char c = 'A';c <= 'L';c++){
                if(isFake(c,false,left,right,result)){
                    //假设这枚硬币是重的
                    System.out.println(c+" is the counterfeit coin and it is weight");
                    break;
                }else if(isFake(c,true,left,right,result)){
                    //假设这枚硬币是轻的
                    System.out.println(c+" is the counterfeit coin and it is light");
                    break;
                }
            }
        }

    }

    public static boolean isFake(char c,boolean isLight,String[] left,String[] right,String[] result){
        //isLight表示硬币是轻的还是重的
        //返回true代表结果符合，返回false代表结果不符合
        for (int i = 0;i < 3;i++){
            if(left[i].indexOf(String.valueOf(c)) != -1){
                //c在左边
                //轻的
                if(isLight){
                    if(!result[i].equals("down"))
                    return false;
                }
                //重的
                else if(!isLight)
                    if(!result[i].equals("up"))
                    return false;

            }else if(right[i].indexOf(String.valueOf(c)) != -1){
                //c在右边
                //轻的
                if(isLight){
                    if(!result[i].equals("up"))
                        return false;
                }
                //重的
                else if(!isLight)
                    if(!result[i].equals("down"))
                        return false;
            }
        }
        return true;
    }
}

注：isFake方法来判断硬币如果是真或假在称量结果中是否合理。

测试：

image-20210119150143438

4、熄灯问题

image-20210119195615981

image-20210119195731859

image-20210119195754416

image-20210119195822061

**大体思路：**如果第一行的灯确定类怎么按，那么第二行的灯也就确定了怎么按。

要熄灭第一行第i列某个亮着的灯，唯一办法是按下第二行第i列的灯，如果按完最后一行，所有灯未熄灭，则枚举下一种第一行灯的按下方法，以此类推。

首先，第一行按灯情况有2^6 = 64种，将0-63化成6位二进制，就是这64种按灯情况，1代表按下。

枚举这64种第一行按灯情况，后面每一行根据前一行的熄灯情况去按灯，如果前一行第i列灯亮，则按下该行第i列的灯。最后，检查最后一行的熄灯情况，如果最后一行灯全灭，说明所有灯全灭，输出该按灯方案。

题解代码：

public static String toBinary(int num, int digits) {
        int value = 1 << digits | num;
        String bs = Integer.toBinaryString(value); //0x20 | 这个是为了保证这个string长度是6位数
        return  bs.substring(1);
    }


    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[][] ori_light = new int[5][6];    //原始灯情况
        //输入数据
        for(int i = 0;i < 5;i++){
            for (int j = 0;j < 6;j++){
                ori_light[i][j] = sc.nextInt();
            }
        }
        for (int i = 0;i < 64;i++){
            int[][] result = new int[5][6];   //按灯方法
            //第一行灯的按下情况
            int[][] light = new int[5][6];
            //拷贝数组
            for (int x = 0;x < 5;x++){
                light[x] = ori_light[x].clone();
            }
            String first = toBinary(i,6);
//            System.out.println(i + " --- " + first);
            for (int j = 0;j < 6;j++){
                //按第一行
                if(String.valueOf(first.charAt(j)).equals("1")){
                    result[0][j] = 1;
                    light[0][j] = light[0][j] == 0 ? 1 : 0;
                    //影响周围灯
                    if(j > 0){
                        light[0][j-1] = light[0][j-1] == 0 ? 1 : 0;
                    }
                    if(j < 5){
                        light[0][j+1] = light[0][j+1] == 0 ? 1 : 0;
                    }
                    light[1][j] = light[1][j] == 0 ? 1 : 0;
                }
            }
            //按剩下二到五行
            for (int k = 1;k < 5;k++){
                //依据上一行情况按下一行
                for (int l = 0;l < 6;l++){
                    if(light[k-1][l] == 0){
                        //上一行该列未熄灭，按本行该列
                        result[k][l] = 1;
                        light[k][l] = light[k][l] == 0 ? 1 : 0;
                        //影响周围灯
                        if(l > 0){
                            light[k][l-1] = light[k][l-1] == 0 ? 1 : 0;
                        }
                        if(l < 5){
                            light[k][l+1] = light[k][l+1] == 0 ? 1 : 0;
                        }
                        if(k < 4){
                            light[k+1][l] = light[k+1][l] == 0 ? 1 : 0;
                        }
                        light[k-1][l] = light[k-1][l] == 0 ? 1 : 0;
                    }
                }
            }
            //最后一行全熄灭，按灯结束
            if(light[4][0] + light[4][1] + light[4][2] + light[4][3] + light[4][4] + light[4][5] == 6){
                for (int m = 0;m < 5;m++){
                    for (int n = 0;n < 6;n++){
                        System.out.print(result[m][n]+" ");
                    }
                    System.out.println();
                }
//                break;
                System.out.println("==========================");
            }
        }
    }

测试数据：

image-20210120113615095

]+" “);
}
System.out.println();
}
// break;
System.out.println(”==========================");
}
}
}


**测试数据：**

[外链图片转存中...(img-8HNkoHN9-1611118056359)]

手工验证该熄灯方案，确实可以将所有灯熄灭。

原文链接：# 算法学习日记（一）-----枚举

## 一、定义

枚举是基于逐个尝试答案的一种问题求解策略

## 二、算法

依次遍历每个值，直到找到问题求解答案

## 三、例题

### 1、完美立方

![image-20210119105705034](https://img-picgo.oss-cn-hangzhou.aliyuncs.com/img/image-20210119105705034.png)



确定各个变量的范围：

a：[2,N]

b：[2,a-1]

c：[b,a-1]

d：[c,a-1]

确定了各个变量的范围，避免了不必要的运算，只需要使用四个for循环，就能求出问题解了，

题解代码如下：

```java
public class Ex_1 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        for (int a = 2;a <= n;++a)
            for (int b = 2;b <= a-1;++b)
                for (int c = b;c <= a-1;++c)
                    for (int d = c;d <= a-1;++d)
                        if(a*a*a == b*b*b + c*c*c + d*d*d)
                            System.out.println("Cube = "+a+", Triple = ("+b+","+c+","+d+")");
    }
}

运行测试结果如下：

image-20210119111927475

2、生理周期

image-20210119112036901

image-20210119112237009

**解题思路：**定义一个k，k++，当k同时满足 （k-p)%23 == 0、（k-e)%28 == 0、（k-i)%33 == 0

但是这样会去算很多不必要的数，比如，当找到第一个（k-p)%23 == 0时，我们就要去看k是否满足（k-e)%28 == 0和（k-i)%33 == 0，当后面两者不满足时，说明这个k不是我们要找的，我们就需要进行k++，但是在[k，k+23-1]之间的k一定不满足（k-p)%23 == 0，[k，k+23-1]之间的k相当于做了无意义的运算。所以，当找到第一个k满足第一个条件（k-p)%23 == 0时，在寻找满足第二个和第三个条件时，k++应该变成 k+=23；同理，当找到k满足前两个条件时，[k,k+23* 28-1]之间的数一定不满足前两个条件，所以k的步长应该从 k+=23变成 k+=23*28。经过这样的处理，可以避免大量不必要的计算。

题解代码：

public class Ex_2 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int p = in.nextInt();
        int e = in.nextInt();
        int i = in.nextInt();
        int d = in.nextInt();

        int k;
        for (k = d + 1;(k-p)%23 != 0;k++);
        for ( ;(k-e)%28 != 0;k += 23);
        for ( ;(k-i)%33 != 0;k += 23*28);
        System.out.println(k-d);
    }
}

测试结果：

image-20210119114700181

3、称硬币

image-20210119114938311

image-20210119115025117

注：up表示右边轻，称量结果都用右边和左边比。

**解题思路：**依次对每一枚硬币，首先假设它是重的，然后代入三个称量结果，如果都符合，那么这枚硬币是重的；如果不符合，那么假设这枚硬币的轻的，然后代入三个称量结果，如果都符合，那么这枚硬币是轻的，如果还是不符合，则判断下一枚硬币。

题解代码：

public class Ex_3 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        String[] left = new String[3];  //每一次称重左边的硬币
        String[] right = new String[3];  //每一次称重右边的硬币
        String[] result = new String[3];  //每一次称重的结果

        while (n > 0){
            //输入
            for (int i = 0;i < 3;i++){
                left[i] = in.next();
                right[i] = in.next();
                result[i] = in.next();
            }
            n--;
            //遍历每一个硬币
            for (char c = 'A';c <= 'L';c++){
                if(isFake(c,false,left,right,result)){
                    //假设这枚硬币是重的
                    System.out.println(c+" is the counterfeit coin and it is weight");
                    break;
                }else if(isFake(c,true,left,right,result)){
                    //假设这枚硬币是轻的
                    System.out.println(c+" is the counterfeit coin and it is light");
                    break;
                }
            }
        }

    }

    public static boolean isFake(char c,boolean isLight,String[] left,String[] right,String[] result){
        //isLight表示硬币是轻的还是重的
        //返回true代表结果符合，返回false代表结果不符合
        for (int i = 0;i < 3;i++){
            if(left[i].indexOf(String.valueOf(c)) != -1){
                //c在左边
                //轻的
                if(isLight){
                    if(!result[i].equals("down"))
                    return false;
                }
                //重的
                else if(!isLight)
                    if(!result[i].equals("up"))
                    return false;

            }else if(right[i].indexOf(String.valueOf(c)) != -1){
                //c在右边
                //轻的
                if(isLight){
                    if(!result[i].equals("up"))
                        return false;
                }
                //重的
                else if(!isLight)
                    if(!result[i].equals("down"))
                        return false;
            }
        }
        return true;
    }
}

注：isFake方法来判断硬币如果是真或假在称量结果中是否合理。

测试：

image-20210119150143438

4、熄灯问题

image-20210119195615981

image-20210119195731859

image-20210119195754416

image-20210119195822061

**大体思路：**如果第一行的灯确定类怎么按，那么第二行的灯也就确定了怎么按。

要熄灭第一行第i列某个亮着的灯，唯一办法是按下第二行第i列的灯，如果按完最后一行，所有灯未熄灭，则枚举下一种第一行灯的按下方法，以此类推。

首先，第一行按灯情况有2^6 = 64种，将0-63化成6位二进制，就是这64种按灯情况，1代表按下。

枚举这64种第一行按灯情况，后面每一行根据前一行的熄灯情况去按灯，如果前一行第i列灯亮，则按下该行第i列的灯。最后，检查最后一行的熄灯情况，如果最后一行灯全灭，说明所有灯全灭，输出该按灯方案。

题解代码：

public static String toBinary(int num, int digits) {
        int value = 1 << digits | num;
        String bs = Integer.toBinaryString(value); //0x20 | 这个是为了保证这个string长度是6位数
        return  bs.substring(1);
    }


    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[][] ori_light = new int[5][6];    //原始灯情况
        //输入数据
        for(int i = 0;i < 5;i++){
            for (int j = 0;j < 6;j++){
                ori_light[i][j] = sc.nextInt();
            }
        }
        for (int i = 0;i < 64;i++){
            int[][] result = new int[5][6];   //按灯方法
            //第一行灯的按下情况
            int[][] light = new int[5][6];
            //拷贝数组
            for (int x = 0;x < 5;x++){
                light[x] = ori_light[x].clone();
            }
            String first = toBinary(i,6);
//            System.out.println(i + " --- " + first);
            for (int j = 0;j < 6;j++){
                //按第一行
                if(String.valueOf(first.charAt(j)).equals("1")){
                    result[0][j] = 1;
                    light[0][j] = light[0][j] == 0 ? 1 : 0;
                    //影响周围灯
                    if(j > 0){
                        light[0][j-1] = light[0][j-1] == 0 ? 1 : 0;
                    }
                    if(j < 5){
                        light[0][j+1] = light[0][j+1] == 0 ? 1 : 0;
                    }
                    light[1][j] = light[1][j] == 0 ? 1 : 0;
                }
            }
            //按剩下二到五行
            for (int k = 1;k < 5;k++){
                //依据上一行情况按下一行
                for (int l = 0;l < 6;l++){
                    if(light[k-1][l] == 0){
                        //上一行该列未熄灭，按本行该列
                        result[k][l] = 1;
                        light[k][l] = light[k][l] == 0 ? 1 : 0;
                        //影响周围灯
                        if(l > 0){
                            light[k][l-1] = light[k][l-1] == 0 ? 1 : 0;
                        }
                        if(l < 5){
                            light[k][l+1] = light[k][l+1] == 0 ? 1 : 0;
                        }
                        if(k < 4){
                            light[k+1][l] = light[k+1][l] == 0 ? 1 : 0;
                        }
                        light[k-1][l] = light[k-1][l] == 0 ? 1 : 0;
                    }
                }
            }
            //最后一行全熄灭，按灯结束
            if(light[4][0] + light[4][1] + light[4][2] + light[4][3] + light[4][4] + light[4][5] == 6){
                for (int m = 0;m < 5;m++){
                    for (int n = 0;n < 6;n++){
                        System.out.print(result[m][n]+" ");
                    }
                    System.out.println();
                }
//                break;
                System.out.println("==========================");
            }
        }
    }

测试数据：

image-20210120113615095

手工验证该熄灯方案，确实可以将所有灯熄灭。

原文链接：http://www.codeaper.cn/blog/QZL5f9EoC1nL

qq_43419801
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构,贪心算法,枚举法的典型例题
05-22
数据结构典型例题,里面包含了几种典型的数据结构的详细讲解,典型算法,枚举算法,贪心算法..等等..是非常好的培训教材.
算法学习日记
qq_45487715的博客
10-27 259
carl算法学习日记一.回溯算法初探1.什么是回溯法2.回溯算法效率3.回溯算法解决的问题4.如何理解回溯算法5.模板 一.回溯算法初探 1.什么是回溯法 回溯算法是一种暴力的枚举算法。二叉树的递归算法即是回溯算法。递归和回溯指的是同一个东西。 2.回溯算法效率 回溯本质上是枚举算法，并不高效。某些问题之所以使用回溯算法是因为没得选，只能进行暴力求解。最多进行剪枝优化。 3.回溯算法解决的问题 回溯法，一般可以解决如下几种问题： 组合问题：N个数里面按一定规则找出k个数的集合 排列问题：N个数按一定规则全排
算法学习日记(一)
Code杂货店
12-31 414
算法学习日记(一)二分法：猜数游戏运用的主要思想是二分法，运用二分法逐步缩减区间，从而猜到最终结果。 二分法运用了分治的思想，即： 把一个大问题分解成若干个相同性质的子问题 再逐一解决这些子问题 最后合并子问题，从而解决大问题递推算法： 又分为顺推和逆推 顺推： 如斐波那契数列 逆推： 如存入银行一笔钱，每个月取1000元，5年后，金额正好为0，求存入银行的金额穷举算法：经典例题：
算法学习日志（一）
心若有依，便是归处
04-30 689
看了MIT的算法导论视频，觉得很不错，就用JAVA把视频里的算法写了出来。 插入排序 private void insertSort(int[] a){ int now,tmp; for(int i = 1;i < a.length; ++i){ now = i; tmp=a[i]; for(int j=i-1;j>-1; --j){
《算法导论》学习日记（一）
塞北一枝花的博客
04-15 226
第一部分 基础知识 第一章 算法在计算中的作用 什么是算法？ 算法就是将输入转化为输出的计算步骤的一个序列 什么是数据结构？ 数据结构是一种存储和组织数据的方式，为了方便人们访问以及修改 没有一种数据结构是可以对所有的用途都有效的，所以说对于我们学习数据结构来说，最重要的是 知道几种数据结构的优势以及局限性。 第二章 算法基础 什么是插入排序？ 点击这里曾经写过一些排序 再来一遍加深理解： inp...
快速学习c# 枚举
12-17
一、在学习枚举之前，首先来听听枚举的优点。 　1、枚举能够使代码更加清晰，它允许使用描述性的名称表示整数值。 　2、枚举使代码更易于维护，有助于确保给变量指定合法的、期望的值。 　3、枚举使代码更易输入。 ...
枚举算法枚举算法枚举算法.ppt
05-26
枚举算法枚举算法枚举算法.ppt
枚举算法枚举算法.ppt
05-30
枚举算法枚举算法.ppt
Python学习之路——枚举类
12-21
文章目录前言:一、枚举什么是枚举？枚举的作用二、代码实现1. Enum类2. IntEnum类3. IntFlag类4. Flag类5. unique装饰器6. auto函数三、官方文档 前言: 首先大家要明白的是：枚举类不是Python的原生类！不是原生类！...
枚举算法精选习题集
02-22
枚举算法从入门到精通习题集，超详细，可以作为广大人民群众的算法入门知识
算法学习打卡日记
ZP_icenow的博客
01-18 1052
一来通过每日打卡的方式督促自己每天学习，二来总结一下知识点；主要面向自己，希望自己能坚持住吧，有一个好的结果 2019年1月18日打卡 编程语言推荐C++（包含C） 用scanf和printf相比cin/cout效率更高 int 的范围是±21亿，超过用long long 声明赋值后面加LL 小数全用double 小写字母比大写字母ASCII码大32 #define和c...
算法学习日记（七）
西窗的博客
03-18 261
在n×n格的棋盘上放置彼此不受攻击的n个皇后。按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。n后问题等价于再n×n的棋盘上放置n个皇后，任何2个皇后不妨在同一行或同一列或同一斜线上。 输入描述 Input Description 给定棋盘的大小n (n ≤ 13) 输出描述 Output Description 输出整数表示有多少种放置方法。 样例输入 Sample I...
算法学习日记（十二）
西窗的博客
05-07 315
标题：密文搜索 福尔摩斯从X星收到一份资料，全部是小写字母组成。 他的助手提供了另一份资料：许多长度为8的密码列表。 福尔摩斯发现，这些密码是被打乱后隐藏在先前那份资料中的。 请你编写一个程序，从第一份资料中搜索可能隐藏密码的位置。要考虑密码的所有排列可能性。 数据格式： 输入第一行：一个字符串s，全部由小写字母组成，长度小于1024*1024 紧接着一行是一个整数n,表示以下有n行密码，1&lt...
《算法笔记》学习日记——9.7 堆
一只奋斗中的本科生
04-17 250
目录9.7 堆问题 A: 算法10-10,10-11：堆排序问题 B: 序列合并问题 C: 合并果子（堆）小结 9.7 堆 Codeup Contest ID:100000616 问题 A: 算法10-10,10-11：堆排序 题目描述 堆排序是一种利用堆结构进行排序的方法，它只需要一个记录大小的辅助空间，每个待排序的记录仅需要占用一个存储空间。 首先建立小根堆或大根堆，然后通过利用堆的性质即堆顶...
枚举法的简单心得
L未若的博客
11-30 5269
枚举法： 百度百科的解释是：在进行归纳推理时，如果逐个考察了某类事件的所有可能情况，因而得出一般结论，那么这结论是可靠的，这种归纳方法叫做枚举法． 优点：算法简单，容易想到        缺点：时间复杂度高，运算量大， 但是，但是，如果，我们能排除那些明显不属于题解的元素，在局部使用枚举，它的效果是相当非常好的。 ps：下面两个问题均摘自百度,其中第二题的判断条件也是借鉴与
枚举算法总结
lihanyu_2026的博客
03-12 3410
枚举算法总结 本节课我学习了枚举算法。 枚举法就是按问题本身的性质，一一列举出该问题所有可能的解，并在逐一列举的过程中，检验每个可能解是否是问题的真正解，若是，我们采纳这个解，否则抛弃它。在列举的过程中，既不能遗漏也不应重复。 而枚举算法的优势很明显 枚举算法的优点： 1.由于枚举算法一...
算法数据结构——枚举算法（Enumeration Algorithm）讲解，如何简单快速的解决问题
最新发布
白话机器学习
06-06 3407
枚举算法（Enumeration Algorithm）：也称为穷举算法，指的是按照问题本身的性质，一一列举出该问题所有可能的解，并在逐一列举的过程中，将它们逐一与目标状态进行比较以得出满足问题要求的解。在列举的过程中，既不能遗漏也不能重复。枚举算法的核心思想是：通过列举问题的所有状态，将它们逐一与目标状态进行比较，从而得到满足条件的解。由于枚举算法要通过列举问题的所有状态来得到满足条件的解，因此，在问题规模变大时，其效率一般是比较低的。
在C语言中使用枚举法算法思想解决奥数问题
姚蔚敏的博客
03-27 895
枚举算法 是我们在日常中使用到的最多的一个算法，它的核心思想就是:枚举所有的可能，大力出奇迹。 枚举法的本质就是从所有候选答案中去搜索正确的解,使用该算法需要满足两个条件：(1)可预先确定候选答案的数量；(2)候选答案的范围在求解之前必须有一个确定的集合。 代码如下: int main() { int i1,i2,i3,i4,i5; long multi,result; ...
python写一个枚举算法
05-01
好的，这是一个使用Python编写的枚举算法的示例： ```python from enum import Enum class Color(Enum): RED = 1 GREEN = 2 BLUE = 3 ``` 在这个示例中，我们定义了一个Color枚举，包含三个不同的选项：RED，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值