精华内容
下载资源
问答
  • 穷举法

    2020-02-27 22:48:44
    1、介绍 穷举法是将所有的可能性罗列出来,在其中寻找答案的一种方法。理论上讲,穷举法几乎能解决所有问题,但是穷举法通常效率差,就算使用一般也需要做一些优化。 2、实例1 ...

    1、介绍

    穷举法是将所有的可能性罗列出来,在其中寻找答案的一种方法。理论上讲,穷举法几乎能解决所有问题,但是穷举法通常效率差,就算使用一般也需要做一些优化。

    2、实例1

    有5个海盗相约进行一次帆船比赛,先后经过一个无名的荒岛,并且每个人都觉得自己是第一个经过该岛的人。 第一个人在沙滩上发现了一堆金币。他把金币分成5等份。发现刚好少一个金币。他就从自己口袋拿出一个金币补充进去,然后把属于自己的那份拿走。第二个到达的人也看到了金币,他也和第一个人一样,把所有金币5等分,发现刚好缺少一个金币,于是自己补进去一个,拿走了属于自己的那份。第三,第四,第五人的情况一模一样。等他们到了目的地,都说自己的情况,才恍然大悟,一起去荒岛找金币,然而再也没有找到荒岛。他们都惋惜地说:岛上还有一千多枚金币呢!请你根据这些信息,推算荒岛上最初有多少金币?

    代码实现:(python3)

    #海盗离开岛后,接下来另一个海盗还未到岛时,岛上的金币数量为n,判断此n是否符合题意
    def panduan(n):
        T=False
        if (n+1)%5==0:
            T=True
        return T
    
    #sum表示起初岛上的金币数量,i表示第i个海盗,返回值表示第i个海盗离开后剩余的金币数量
    def sheng(sum,i):
        if i==1:
            return 4 * (sum+1) / 5
        else:
            return 4*(sheng(sum,i-1)+1)/5
    #求起初岛上的金币数量(穷举法)
    for i in range(1000,5000):#(1000,5000)是通过看出来的,这里也可以做进一步优化
        if panduan(sheng(i,1)) and panduan(sheng(i,2)) and panduan(sheng(i,3)) and panduan(sheng(i,4)):
            if sheng(i,5)>1000 and sheng(i,5)<2000:
                print(i)
    

    3、实例3

    现在有n根火柴棍,你可以拼出多少个形如“A+B=C”的等式?等式中的A、B、C是用火柴棍拼出的整数(若该数非零,则最高位不能是0)。用火柴棍拼数字0-9的拼法如图所示:

    注意:

    1. 加号与等号各自需要两根火柴棍

    2. 如果A≠B,则A+B=C与B+A=C视为不同的等式(A、B、C>=0)

    3. n根火柴棍必须全部用上

    现在只有n(n<=24)根火柴,可以拼多少个等式?

    代码实现:(python3)

    n = int(input())
    list = [6,2,5,5,4,5,6,3,7,6]
    #制作0~999对应的火柴棒列表
    for i in range(10,100):
        gewei = i%10
        shiwei = i//10
        list.append(list[gewei]+list[shiwei])
    for i in range(100,1000):
        baiwei = i//100
        shiwei = i//10
        gewei = i%10
        list.append(list[gewei]+list[shiwei])
        
    count = 0  #用于计数
    #穷举(部分优化)
    for x in range(0,1000):
        if list[x]<=18:
           for y in range(0,1000):
               if (list[x]+list[y]<=18) and ((x+y)<1000 and (list[x]+list[y]+list[x+y]==(n-4))):
                    count = count + 1
    print(count,end='')
    
    展开全文
  • 穷举法代码解析带注释(学习穷举法代码好资料)
  • 使用穷举法生成长度是3个字符串,匹配上述生成的密码 要求: 分别使用多层for循环 和 递归解决上述问题 Math.random()的使用及做题思路 java.lang.Character.isLetterOrDigit(int codePoint) 确定指定字符...

    问题+代码:

    1. 生成一个长度是3的随机字符串,把这个字符串作为当做密码

    2. 使用穷举法生成长度是3个字符串,匹配上述生成的密码

    要求: 分别使用多层for循环 和 递归解决上述问题

    在这里插入图片描述
    Math.random()的使用及做题思路

    java.lang.Character.isLetterOrDigit(int codePoint)
    确定指定字符(Unicode代码点)是一个字母或数字。
    字符被确定是字母或数字,如果不是isLetter(codePoint) 也不是 isDigit(codePoint) 的字符,则返回true。

    System.currentTimeMillis()计算方式
    在开发过程中,通常很多人都习惯使用new Date()来获取当前时间。new Date()所做的事情其实就是调用了System.currentTimeMillis()。如果仅仅是需要或者毫秒数,那么完全可以使用System.currentTimeMillis()去代替new Date(),效率上会高一点。如果需要在同一个方法里面多次使用new Date(),通常性能就是这样一点一点地消耗掉,//获得系统的时间,单位为毫秒,转换为妙

     //获得系统的时间,单位为毫秒,转换为妙
        long totalMilliSeconds = System.currentTimeMillis();
        long totalSeconds = totalMilliSeconds / 1000;
         
        //求出现在的秒
        long currentSecond = totalSeconds % 60;
         
        //求出现在的分
        long totalMinutes = totalSeconds / 60;
        long currentMinute = totalMinutes % 60;
         
        //求出现在的小时
        long totalHour = totalMinutes / 60;
        long currentHour = totalHour % 24;
         
        //显示时间
        System.out.println("总毫秒为: " + totalMilliSeconds);
        System.out.println(currentHour + ":" + currentMinute + ":" + currentSecond + " GMT");
    

    String.valueOf() 方法的使用
    转换变量

    package Fengzhaung;
    
    public class demoo2 {
        //生成一个长度是3的随机字符串,把这个字符串作为当做密码
        public String getPassword() {
            char password[] = new char[3];
            for (int i = 0; i < password.length; i++) {
                while (true) {
                    char make = (char) (Math.random() * (122 - 48 + 1) + 48); //48-122
                    if (Character.isLetterOrDigit(make)) {//如果是字母或者数字
                        password[i] = make;
                        break;
                    }
                }
            }
            return new String(password);
        }
    
        private String password = getPassword();
    
        public void forMethod() {//使用for循环穷举
            // 使用穷举法生成长度是3个字符串,匹配上述生成的密码
            long start = System.currentTimeMillis(); //获取开始时间
            char password[] = new char[this.password.length()];
            boolean flag = true;
            while (flag) {
                for (int i = '0'; i <= 'z'; i++) {
                    for (int j = '0'; j <= 'z'; j++) {
                        for (int z = '0'; z <= 'z'; z++) {
                            if (!Character.isLetterOrDigit(i) || !Character.isLetterOrDigit(j) || !Character.isLetterOrDigit(z))
                                //三个不能有一个是false,既不能不是字母或者数字
                                continue;
                            password[0] = (char) i;
                            password[1] = (char) j;
                            password[2] = (char) z;
                            if (String.valueOf(password).equals(this.password)) {
                                //如果password字符串数组转为字符串 与equals   this.password 密码比较
                                System.out.println("密码已经找到:" + String.valueOf(password));
                                long end = System.currentTimeMillis();//获取结束时间
                                System.out.printf("使用for循环穷举法耗费的时间是:%d ms %n", (end - start));
                                flag = false;
                            }
                        }
                    }
                }
            }
        }
    
        //->放外面是为了让isreturn初始化为false但是可以修改,避免方法的递归使得每次isreturn都初始化为false变得无法修改
        boolean isreturn = false;  //用于程序的结束return
    
        public void diguiMethod(char[] random, int index) {  //使用递归法穷举
            long start = System.currentTimeMillis();  //开始时间
            for (int i = '0'; i <= 'z'; i++) {
                if (!Character.isLetterOrDigit(i))
                    continue;
                random[index] = (char) i; //把字符存入random字符串数组中
                if (index < random.length - 1) {//如果数组没有填满则递归,进入套娃
                    if (isreturn)
                        //判断结束语句应该放这里,因为第一个(套娃)递归结束之后
                        // 会回到进入递归的方法这里也就是for循环里面,遇到return结束上一个套娃,直到全部结束
                        return;
                    diguiMethod(random, index + 1);
                } else if (String.valueOf(random).equals(this.password)) {
                    System.out.println();
                    System.out.println("密码已经找到:" + String.valueOf(random));
                    long end = System.currentTimeMillis();
                    System.out.format("使用递归穷举法耗费的时间是:%d ms %n", (end - start));
                    isreturn = true;  //用于结束全部的方法
                    return;  //结束该递归(套娃)方法
                }
            }
        }
    
        public static void main(String[] args) {
            demoo2 demoo2 = new demoo2();
            System.out.println("随机三位密码是" + demoo2.password);
            System.out.println();
            demoo2.forMethod();
            demoo2.diguiMethod(new char[3], 0);
        }
    }
    

    在这里插入图片描述

    展开全文
  • 枚举法 穷举法 笨人之法 把所有可能的情况一一测试 筛选出符合条件的各种结果进行输出 分析 这是个不定方程 三元一次方程组问题 三个变量 两个方程 x y z 1005x 3y z 3 100设公鸡为x只 母鸡为y只 小鸡为z只 百元买...

    枚举法 穷举法 笨人之法 把所有可能的情况一一测试 筛选出符合条件的各种结果进行输出 分析 这是个不定方程 三元一次方程组问题 三个变量 两个方程 x y z 1005x 3y z 3 100设公鸡为x只 母鸡为y只 小鸡为z只 百元买百鸡问题分析 x y z 1005x 3y z 3 100 三重循环 voidmain intx y z for x 0 x 100 x for y 0 y 100 y for z 0 z 100 z if x y z 100 结果 x 0 y 25 z 75x 4 y 18 z 78x 8 y 11 z 81x 12 y 4 z 84 讨论 为什么多了几组解 百元买百鸡问题分析 voidmain intx y z for x 0 x 100 x for y 0 y 100 y for z 0 z 100 z if z 3 0 结果 x 0 y 25 z 75x 4 y 18 z 78x 8 y 11 z 81x 12 y 4 z 84 讨论 此为 最笨 之法 要进行101 101 101 1030301次 100多万次 运算 优化 voidmain intx y z for x 0 x 100 x for y 0 y 100 y z 100 x y if z 3 0 讨论 令z 100 x y只进行101 101 10201次运算 前者的1 取x 20 y 33只进行21 34 714次运算 第1种运算的6 9e 4 继续优化 voidmain intx y z for x 0 x 14 x for y 0 y 25 y if 7 x 4 y 100 z 100 x y printf cocks d hens d chickens d n x y z 取x 14 y 25只进行15 26 390次运算 课堂讨论 谁做的好事 有四位同学中的一位做了好事 不留名 表扬信来了之后 校长问这四位是谁做的好事 A说 不是我 B说 是C C说 是D D说 C胡说 已知三个人说的是真话 一个人说的是假话 现在要根据这些信息 找出做了好事的人 编程思路 如何找到该人 一定是 先假设该人是做好事者 然后到每句话中去测试看有几句是真话 有三句是真话就确定是该人 否则换下一人再试 比如 先假定是A同学 让thisman A 代入到四句话中A说 thisman A A A 假 值为0 B说 thisman C A C 假 值为0 C说 thisman D A D 假 值为0 D说 thisman D A D 真 值为1 显然 不是 A 做的好事 四个关系表达式值的和为1 再试B同学 让thisman B 代入到四句话中A说 thisman A B A 真 值为1 B说 thisman C B C 假 值为0 C说 thisman D B D 假 值为0 D说 thisman D B D 真 值为1 显然 不是 B 所为 四个关系表达式值的和为2 再试C同学 让thisman C 代入到四句话中A说 thisman A C A 真 值为1 B说 thisman C C C 真 值为1 C说 thisman D C D 假 值为0 D说 thisman D C D 真 值为1 显然 就是 C 做了好事 四个关系表达式值之和为3 这时 我们可以理出头绪 要用枚举法 一个人一个人地去试 四句话中有三句为真 该人即所求 includevoidmain charthisman intsa sb sc sd cond for thisman A thisman D thisman sa thisman A sb thisman C sc thisman D sd thisman D cond sa sb sc sd if cond 3 printf 做好事的人是 c n thisman 利用穷举法求解趣味智力题 韩信点兵 韩信有一队兵 他想知道有多少人 便让士兵排队报数 按从1至5报数 最末一个士兵报的数为1 按从1至6报数 最末一个士兵报的数为5 按从1至7报数 最末一个士兵报的数为4 最后再按从1至11报数 最末一个士兵报的数为10 你知道韩信至少有多少兵吗 设兵数为x 则x应满足 x 5 1 x 6 5 x 7 4 x 11 10穷举法对x从1开始试验 includevoidmain intx for x 1 x 5000 x if x 5 1 属于 瞎猫碰死耗子 的做法 穷举法求解韩信点兵 includevoidmain intx for x 1 x if x 5 1 死循环 永远不会退出的循环 穷举法求解韩信点兵 穷举法求解韩信点兵 方案1 goto includevoidmain intx for x 1 x if x 5 1 穷举法求解韩信点兵 方案2 break includevoidmain intx for x 1 x if x 5 1 穷举法求解韩信点兵 方案3 标志变量 includevoidmain intx intfind 0 设置找到标志为假 for x 1 find x if x 5 1 练习题1 试编程求出100000 200000之间间隔最大的两个素数并输出 同时输出最大间隔 2 试编程求出八位数中所有的水仙花数 三位水仙花为abc a 3 b 3 c 3 八位数水仙花为该数字等于所有位数的八次方之和 3 年龄几何 张三 李四 王五 刘六的年龄成一等差数列 他们四人的年龄相加是26 相乘是880 求以他们的年龄为前4项的等差数列的前20项 4 委派任务 某侦察队接到一项紧急任务 要求在A B C D E F六个队员中尽可能多地挑若干人 但有以下限制条件 A和B两人中至少去一人 A和D不能一起去 A E和F三人中要派两人去 B和C都去或都不去 C和D两人中去一个 若D不去 则E也不去 问应当让哪几个人去 5 在下面的加法算式中 不同的符号代表不同的数字 相同的符号代表相同的数字 请设计程序求出 都 要 学 C 4个符号分别代表的数字 提示 让计算机解奥数题 穷举 都 要 学 C 4个符号分别代表的数字 从0到9 然后进行组合 如果组合起来符合规则 不同的符号代表不同的数字 相同的符号代表相同的数字 且使等式成立 则为正解 6 警察局抓住了A B C D四名盗窃嫌疑犯 其中只有一人是小偷 在审问时 A说 我不是小偷 B说 C是小偷 C说 小偷肯定是D D说 C在冤枉好人 现在已经知道这四人中有三人说的是真话 一人说的是假话 请问到底谁是小偷

    展开阅读全文

    展开全文
  • 穷举法入门

    2012-11-17 09:50:20
    穷举法 一说老师就知道 密码破解入门等基础 一个vc++6.0编译通过的软件
  • C语言24点游戏穷举法

    2021-04-02 09:11:41
    C语言24点游戏穷举法
  • 穷举法打印n阶魔方

    2018-09-19 23:35:59
    n阶魔方算法,用c语言写的,用的是穷举法
  • 穷举法解决01背包利用暴力破解法(穷举法) 问题描述:给定n个重量为{w1, w2, … ,wn}、价值为{v1, v2, … ,vn}的物品和一个容量为C的背包,求这些物品中的一个最有价值的子集,且要能够装到背包中。 包的总容量 ...

    穷举法解决01背包利用暴力破解法(穷举法)

    问题描述:给定n个重量为{w1, w2, … ,wn}、价值为{v1, v2, … ,vn}的物品和一个容量为C的背包,求这些物品中的一个最有价值的子集,且要能够装到背包中。

    包的总容量15kg

    物品情况

    物品编号价值重量
    14$12kg
    22$2kg
    32$1kg
    41$1kg
    510$4kg

    思路:

    • 利用递归进行遍历求出各个的可能性
    • 将遍历出的结果存入int[] back = new int[N],进行缓存
    • 没存入一个back[]数组,进行遍历,将符合的题目要求allWigth[总的重量]<=15的,存入到Map<String, Integer>中
    • String表示背包情况. Integer表示总价值
    • 在存入的Map<String, Integer>的所有数据中,遍历出最大的Integer,也就是最大的价值
    • 根据Integer值,遍历出对应的String,就是背包的情况

    代码

    利用递归求出所有的背包情况

    public class GiveBack {
         //	定义一个int数组
    	int array[]=new int[1000]; 
    	int N=5;
        //n为当前层数
    	//求n的子集
    	public  void giveback(int n){
    		if(n>=N){
    			for (int i = 0; i <N; i++) {
    				System.out.print(array[i]);
    			}
    			System.out.println();
    			return;
    		}
    		array[n]=0;
    		giveback(n+1);
    		array[n]=1;
    		giveback(n+1);
    		return;
    	}
    	public static void main(String[] args) {
    		GiveBack giveback=new GiveBack();
    		giveback.giveback(0);
    	}
    }
    

    结果

    所有背包情况

    00000	00001	00010	00011	00100	00101	00110	00111	01000	01001	01010	01011	01100	01101	01110	01111	10000	10001	10010	10011	10100	10101	10110	10111	11000	11001	11010	11011	11100	11101	11110	11111	
    

    最终代码

    package school;
    
    import java.util.*;
    
    public class GiveBack3 {
        //	定义一个int数组
        int array[] = new int[1000];
        int N = 5;
        int[] value = {4, 2, 2, 1, 10};//价格
        int[] wight = {12, 2, 1, 1, 4};//体积
        int[] back = new int[N];//用来缓存所便利的可能存在的背包
        int all = 0;  //总的价值
        int allWigth = 0;//总的重量
        int count = 0;//标记遍历的次数
        Map<String, Integer> map = new HashMap<>();
    
        public void giveback(int n) {
            if (n >= N) {
                all = 0;//每次遍历一个循环后要置零,防止对后的影响
                allWigth = 0;
                count = 0;
                for (int i = 0; i < N; i++) {
                    back[i] = array[i];
                    //遍历back数组 ,所存放的背包 00100  1表示已经由背包,0表示没有
                    if (back[i] == 1) {
                        all += value[i];
                        allWigth += wight[i];
                        count++;//标记遍历的次数
                    } else {
                        count++;
                    }
                    //当遍历的次数为5和所存放的总重量小于等于15 放入Map中
                    if (count == 5 && allWigth <= 15) {
                        map.put(Arrays.toString(back), all);
                    }
                }
                return;
            }
            //运用递归进行调用
            array[n] = 0;
            giveback(n + 1);
            array[n] = 1;
            giveback(n + 1);
            return;
        }
    
        /**
         * @param map   遍历存入输入的图
         * @param value 重量
         * @return 返回value所对应的kye值
         */
        private <K, V> K getKeyByLoop(Map<K, V> map, V value) {
            for (Map.Entry<K, V> entry : map.entrySet()) {
                if (Objects.equals(entry.getValue(), value)) {
                    return entry.getKey();
                }
            }
            return null;
        }
    
        public static void main(String[] args) {
            GiveBack3 giveback = new GiveBack3();
            giveback.giveback(0);
            //通过迭代遍历values
            Collection<Integer> values = giveback.map.values();
            Iterator<Integer> iterator = values.iterator();
            Integer temp = 0;
            while (iterator.hasNext()) {
                Integer integer = iterator.next();
                //遍历最大的values,并且赋值给temp
                if (integer > temp) {
                    temp = integer;
                }
            }
            System.out.print("最大的价格\t");
            System.out.println(temp + "\t");
            //通过values值    利用getKeyByLoop函数遍历出对应的key值,也就是符合题意的而背包
            System.out.print("所选符合题意的背包\t");
            System.out.println(giveback.getKeyByLoop(giveback.map, temp));
        }
    }
    

    输出

    最大的价格	15	
    所选符合题意的背包	[0, 1, 1, 1, 1]
    

    中间符合标准的,能放入背包的情况

    {[0, 0, 0, 1, 0]=1, [0, 0, 0, 1, 1]=11, [0, 0, 1, 1, 0]=3, [0, 1, 0, 1, 0]=3, [1, 1, 0, 1, 0]=7, [0, 1, 1, 0, 1]=14, [0, 1, 1, 1, 0]=5, [0, 1, 0, 1, 1]=13, [0, 1, 1, 1, 1]=15, [0, 1, 0, 0, 1]=12, [0, 1, 0, 0, 0]=2, [0, 1, 1, 0, 0]=4, [0, 0, 1, 1, 1]=13, [1, 0, 0, 1, 0]=5, [1, 0, 1, 1, 0]=7, [0, 0, 0, 0, 0]=0, [1, 1, 0, 0, 0]=6, [1, 1, 1, 0, 0]=8, [0, 0, 1, 0, 1]=12, [0, 0, 1, 0, 0]=2, [0, 0, 0, 0, 1]=10, [1, 0, 1, 0, 0]=6, [1, 0, 0, 0, 0]=4}
    
    展开全文
  • #include<stdio.h> #include<String.h> #include<...//暴力穷举法 int BaoliSubSum(int num[], int n){ int thissum, i, j, k, maxsum; maxsum = 0; for ( i = 0; i < n;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,762
精华内容 13,104
关键字:

穷举法