算法笔记1：枚举

最新推荐文章于 2024-04-01 14:12:04 发布

qq_39286015

最新推荐文章于 2024-04-01 14:12:04 发布

阅读量934

点赞数

文章标签：算法

本文链接：https://blog.csdn.net/qq_39286015/article/details/113740562

版权

1.枚举

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

例如：求小于N的最大素数
找不到一个数学公式，使得根据N就可以计算出这个素数
所有就只能从N-1,N-2,N-3…这样逐个判断才能找出来这就是枚举

例题一：完美立方


形如a^3= b^3 + c^3 + d^3的等式被称为完美立方等式。例如12^3= 6^3 + 8^3 + 10^3 。

编写一个程序，对任给的正整数N(N≤100)，寻找所有的四元组(a, b, c, d)，使得a3 = b3 + c3 + d3，其中a,b,c,d 大于1, 小于等于N，且b<=c<=d。

输入格式

一个正整数N (N≤100)。

输出格式

每行输出一个完美立方。输出格式为：
Cube = a, Triple = (b,c,d)
其中a,b,c,d所在位置分别用实际求出四元组值代入。

PS：请按照a的值，从小到大依次输出。当两个完美立方等式中a的值相同，则b值小的优先输出、仍相同则c值小的优先输出、再相同则d值小的先输出

输入样例
24

输出样例

Cube = 6, Triple = (3,4,5)
Cube = 12, Triple = (6,8,10)
Cube = 18, Triple = (2,12,16)
Cube = 18, Triple = (9,12,15)
Cube = 19, Triple = (3,10,18)
Cube = 20, Triple = (7,14,17)
Cube = 24, Triple = (12,16,20)

解题思路

四重循环枚举a，b，c，d，a在最外层，d在最里层，每一次都从大到小枚举
a枚举范围[2，N]
b枚举范围[2，a-1] (因为b不可能大于等于a)
c枚举范围[b，a-1]
d枚举范围[c，a-1] (这是因为b<=c<=d)
从这里可以看出即使是枚举也不是每一种都要死，合理设置枚举范围和顺序可以达到提高枚举效率的效果

import java.util.Scanner;

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

例题二：生理周期

人有体力、情商、智商的高峰日子，它们分别每隔 23天、28天和33天出现一次。

对于每个人，我们想 知道何时三个高峰落在同一天。给定三个高峰出现 的日子p,e和i（不一定是第一次高峰出现的日子）

再给定另一个指定的日子d，你的任务是输出日子d 之后，下一次三个高峰落在同一天的日子（用距离d 的天数表示）

例如：给定日子为10，下次出现三 个高峰同一天的日子是12，则输出2。

输入： 输入四个整数：p, e, i和d。 

p, e, i分别表示体力、情感和 智力高峰出现的日子 。d是给定的日子，可能小于p, e或 i。 

所有给定日子是非负的并且小于或等于365，所求的日子小于 或等于21252。 

输入样例
0 0 0 0
0 0 0 100
5 20 34 325
4 5 6 7
283 102 23 320
203 301 203 40
-1 -1 -1 -1

输出样例
Case 1: the next triple peak occurs in 21252 days.
Case 2: the next triple peak occurs in 21152 days.
Case 3: the next triple peak occurs in 19575 days.
Case 4: the next triple peak occurs in 16994 days.
Case 5: the next triple peak occurs in 8910 days.
Case 6: the next triple peak occurs in 10789 days.

解题思路

从d+1天开始，一直试到21252天（因为232833是21252所以最佳生理周期最迟也是在21252天后出现）
对其中每个日期K，看是否满足 (k-p)%230&&(k-e)%280&&(k-i)%33==0 判断是否满足三个高峰同一天
怎样试的更快？
答;我们可以跳着试，因为我们是要找到三个高峰同一天的日子
我们可以一个个试，先找到一个体力高峰的日子，之后我们需要找到即是体力高峰有啥情商高峰的日子
所以之后就可以不用一个个试，而是每次加一个23保证这个日子绝对是是体力高峰

import java.util.Scanner;

public class SLZQ {
    public static void main(String[] args) {
        int N = 21252;
        int p,e,i,d;
        int ncase = 0;
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            p = sc.nextInt();
            e = sc.nextInt();
            i = sc.nextInt();
            d = sc.nextInt();
            ncase++;
            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("Case"+ncase+": the next triple peak occurs in " + (k - d) + " days.");
        }
    }
}

例题三：称硬币

有12枚硬币。其中有11枚真币和1枚假币。假币和真币重量不同， 但不知道假币比真币轻还是重。

现在用一架天平称了这些币三次，告诉你称的结果，请你找出假币并且确定假币是轻是重（数据保证一能找出来）。

输入：第一行是测试数据组数。

每组数据有三行，每行表示一次称量的结果。银币标号为A-L。

每次称量的结果用三个以空格隔开的字符串表示：天平左边放置的硬币，天平右边放置的硬币平衡状态。

其中平衡状态用"up",“down”,或"even"表示, 分别为右端高、右端低和平衡。天平左右的硬币数总是相等的。

输入样例:
1
ABCD EFGH even
ABCI EFJK up
ABIJ EFGH even

输出样例
K is the counterfeit coin and it is light.

解题思路

这个题目与智力题不同，不是让你设计称量方法，而是已经给出称量方法，有了称量结果。
并且保证在结果中一定可以找出哪个是假币，这个假币是轻还是重。
对于解题思路，这里是在讲解枚举，大方向肯定是枚举嘛，一共有12个硬币，对每一个硬币进行枚举。
对于每一枚硬币先假设它是假币且是轻的，拿这个假设带入三次称量的结果中，看是否符合称量结果。
如果符合，问题即解决，确定这个硬币是假币且轻。
如果不符合，就假设这个硬币是假币且是重的，看是否符合称量结果。把所有硬币都试一遍，一定能找到这个假币且判判断出假币是轻还是重。

import java.util.Scanner;

public class CYB {
    static String[] left= new String[3];//天平左边硬币
    static String[] right= new String[3];//天平右边硬币
    static String[] result = new String[3];//结果

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n  = sc.nextInt();
        for (int k = 0; k < n; k++) {
            for (int i = 0; i < 3; i++) {
                left[i]  = sc.next();
                right[i] = sc.next();
                result[i] = sc.next();
            }
        }

        for (char c = 'A'; c <= 'L' ; c++) {
            if (IsFake(c,true)){
                System.out.println(c+" is the counterfeit coin and it is light");
                break;
            }
            else if(IsFake(c, false)){//假设为重
                System.out.println(c+" is the counterfeit coin and it is heavy");
                break;
            }
        }

    }

    //light为真表示假设假币为轻，否则表示假设假币为重
    public static boolean IsFake(char c, boolean light){//静态方法（main）只能调用静态方法
        String lf,rt;
        for (int i = 0; i < 3; i++) {
            if (light){
                lf = left[i];
                rt  = right[i];
            }else{
                lf = right[i];
                rt = left[i];
            }
            switch (result[i].charAt(0)){
                case 'u':
                    if (rt.indexOf(c)==-1)
                    	//indexOf()方法返回指定字符在字符串中第一次出现处的索引
                        // 如果此字符串中没有这样的字符，则返回 -1。
                        return false;
                    break;
                case 'e':
                    if (lf.indexOf(c)!=-1||rt.indexOf(c)!=-1)
                        return false;
                    break;
                case 'd':
                    if (lf.indexOf(c)==-1)
                        return false;
                    break;
            }
        }
        return true;
    }

}

例题四：熄灯问题

有一个由按钮组成的矩阵，其中每行有6个按钮，共5行。

每个按钮的位置上有一盏灯。

当按下一个按钮后，该按钮以及周围位置(上边、下边、左边、右边)的灯都会改变一次。

即，如果灯原来是点亮的，就会被熄灭；如果灯原来是熄灭的，则会被点亮。

在矩阵角上的按钮改变3盏灯的状态；在矩阵边上的按钮改变4盏灯的状态；其他的按钮改变5盏灯的状态。

请你写一个程序，确定需要按下哪些按钮，恰好使得所有的灯都熄灭。

输入：
5行组成，每一行包括6个数字（0或1）。相邻两个数字之间用单个空格隔开。

0表示灯的初始状态是熄灭的，1表示灯的初始状态是点亮的。

输出

5行组成，每一行包括6个数字（0或1）。相邻两个数字之间用单个空格隔开。

其中的1表示需要把对应的按钮按下，0则表示不需要按对应的按钮。

样例输入

0 1 1 0 1 0
1 0 0 1 1 1
0 0 1 0 0 1
1 0 0 1 0 1
0 1 1 1 0 0

样例输出

1 0 1 0 0 1
1 1 0 1 0 1
0 0 1 0 1 1
1 0 0 1 0 0
0 1 0 0 0 0

解题思路

第一想法：
枚举所有可能的按钮（开关）状态，对每个状态计算一下最后灯的情况，看是否都熄灭
每个按钮都有两种状态（按下或不按）
一共有30个开关，那么状态数是2^30，太多，会超时
如何减少枚举的状态数目呢?
基本思路: 如果存在某个局部, 一旦这个局部的状态被确定, 那么剩余其他部分的状态只能是确定的一种,
或者不多的n种, 那么就只需枚举这个局部的状态即可。
本题是否存在这样的 “ 局部” 呢?
经过观察, 发现第1行就是这样的一个 “ 局部”
因为第1行的各开关操作方案确定的情况下, 这些开关操作过后,将导致第1行某些灯是亮的, 某些灯是灭的。
要熄灭第1行某个亮着的灯(假设位于第i列), 那么唯一的办法就是按下第2行第i列的开关。
(因为第1行的开关已经用过了,而第3行及其后的开关不会影响到第1行)
为了使第1行的灯全部熄灭, 第2行的合理开关操作方案就是唯一的。
第2行的开关操作过后,为了熄灭第2行的灯, 第3行的合理开关操作方案就也是唯一的。以此类推, 最后一行的开关操作方案也是唯一的。
只要第1行的操作方案定下来, 记作A, 那么剩余行的操作方案就是确定唯一的了。

推算出最后一行的开关操作方案, 然后看看最后一行的开关操作过后,最后一行的所有灯是否都熄灭：如果是, 那么A就是一个解的状态；
如果不是, 那么A不是解的状态, 第1行换个状态重新试试。
只需枚举第1行的操作方案, 状态数是2^6 = 64

有没有状态数更少的做法？
枚举第一列, 状态数是2^5 = 32
总的来说就是先第一行按的按钮从000000到100000到010000到111111
这样枚举中有没有一个看是不是最后一行恰好全都熄灭

import java.util.Scanner;

public class XDWT {
    static int[][] oriLights = new int[5][6];//最初灯矩阵，一个比特表示一盏灯
    static int[][] light = new int[5][6];//不停变化的灯矩阵
    static int[][] result = new int[5][6];//结果开关矩阵

    public static void input(){//初始化最初灯矩阵
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 6; j++) {
                oriLights[i][j] = sc.nextInt();
            }
        }
    }

    public static void init(){//初始化变化的灯矩阵
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 6; j++) {
                light[i][j] = oriLights[i][j];
                result[i][j] = 0;
            }
        }
    }

    public static void fun(int n) {//生成第一行方案的方法
        for (int i = 0; i < 6; i++) {//通过n和二进制原理生成不同方案
            result[0][i] = n % 2;
            n = n / 2;
        }
    }

    public static void set(int i, int j) {//变化周围灯的方法
        light[i][j] = light[i][j] ^ 1;//取反
        if (i - 1 >= 0) light[i - 1][j] = light[i - 1][j] ^ 1;
        if (i + 1 < 5) light[i + 1][j] = light[i + 1][j] ^ 1;
        if (j - 1 >= 0) light[i][j - 1] = light[i][j - 1] ^ 1;
        if (j + 1 < 6) light[i][j + 1] = light[i][j + 1] ^ 1;
    }

    public static void main(String[] args) {
        input();//输入最初灯矩阵

        for (int n = 0; n < 64; n++) {
            int sum=0;
            init();//初始化变化矩阵
            fun(n);//生成第一排方案
            for (int i = 0; i < 6; i++) {//操作第一行
                if (result[0][i] == 1)
                    set(0, i);
            }
            for (int i = 1; i < 5; i++) {//操作第二行到第五行
                for (int j = 0; j < 6; j++) {
                    if (light[i-1][j]==1)
                        {
                            set(i, j);
                            result[i][j]=1;
                        }
                }
            }
            //检验第4行是否已经完全关闭
            int a;
            for (a = 0; a < 6; a++) {
                if(light[4][a]==1)
                    break;
            }
            if (a>=6)
                break;

        }

        //输出结果 
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 6; j++) {
                System.out.print(result[i][j]+" ");
            }
            System.out.println();
        }
        System.out.println();
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 6; j++) {
                System.out.print(light[i][j]+" ");
            }
            System.out.println();
        }
    }
}