枚举算法

枚举法的本质就是从所有候选答案中搜索正确的解,使用该算法需要满足两个条件:

  1. 可预先确定候选答案的数量。
  2. 候选答案的范围在求解之前必须有一个确定的集合。

填数游戏 (即 ABCDE * A = EEEEEE)

每个字母表示从0~9的一个整数,且不同字母之间代表的整数是不同的,要求找出这些字母表示的整数,使得算式成立。
这种类型的题目有两个特点:

  1. 无规律性,也就是我们没有办法按照一定的规律从众多的候选答案中找到正解。
  2. 有穷性,也就是说这种题目在计算量上总会有一个上界,要么在上界范围内即可得出正解,要么不存在正解。
字母 变量 变量范围
A i 1-9
B j 0-9
C k 0-9
D l 0-9
E r 1-9

然后穷举所有可能性,直到满足条件为止。

public class FindCalu {
    public static void main(String[] args) {
        for(int i=1;i<=9;i++) {
            for(int j=0;j<=9;j++) {
                for(int k=0;k<=9;k++) {
                    for(int l=0;l<=9;l++) {
                        for(int r=0;r<=9;r++) {
                            //计算的时候记得要用long型
                            long mul=i*10000+j*1000+k*100+l*10+r;
                            long res=r*111111;
                            if(mul*(long)i==res) {
                                System.out.println(mul+"*"+i+"="+res);
                            }
                        }
                    }
                }
            }
        }
    }
}

填运算符

5 5 5 5 5=5 (中间的空间填的是运算符)。
即通过加减乘除来等于相应的结果数。
注意:

  1. 除号后面的被除数一定不为0
  2. 乘除法的优先级比加减法的优先级高

分析:

  1. 先把已经计算过的结果存储到一个变量名为left中,准备和下一个数字进行运算(待运算的第一个数据存储到另一个变量名为right中)两个变量均为double型;
  2. 如果为加/减则为顺序计算:left = left +or- right;
    如果为乘除,则先计算当前乘除部分: right = *or/ num[下一个数据],作为下一个数字进行运算
    如果为除则下一个运算数据不能为0才能继续运算:if (i[当前] < 4 || num[下一个数据] != 0){……}; (注意)
  3. left初始值为0,right初始值为输入待运算的第一个数;
  4. 运算完之后筛选判断:if (left + right == result) 计数器自增,输出;如果全部结束计数器为零,则表示无所需结果;
import java.util.Scanner;
public class FindOper {
    public static void main(String[] args) {
        char oper[]=new char[]{' ','+','-','*','/'};  //操作符号,稍微注意一下
        int type[] = new int[5];  //存放操作符号顺序
        int flag=1;//1为正数,-1为负数
        double left,right;
        int count=0;
        int num[]=new int[6];
        Scanner input=new Scanner(System.in);
        for(int i=1;i<=5;i++) {
            num[i]=input.nextInt();
        }
        int result=input.nextInt();
        input.close();
        for(type[1]=1;type[1]<=4;type[1]++) {
            if(type[1]<4||num[2]!=0) {
                for(type[2]=1;type[2]<=4;type[2]++) {
                    if(type[2]<4||num[3]!=0) {
                        for(type[3]=1;type[3]<=4;type[3]++) {
                            if(type[3]<4||num[4]!=0) {
                                for(type[4]=1;type[4]<=4;type[4]++) {
                                    if(type[4]<4||num[5]!=0) {
                                        left=0;
                                        right=num[1];
                                        flag=1;
                                        for(int o=1;o<=4;o++) {
                                            switch(oper[type[o]]) {
                                                case '+':{
                                                    left=left+right*flag;
                                                    right=num[o+1];
                                                    flag=1;
                                                    break;
                                                }
                                                case '-':{
                                                    left=left+right*flag;
                                                    right=num[o+1];
                                                    flag=-1;
                                                    break;
                                                }
                                                case '*':{
                                                    right=right*num[o+1];
                                                    break;
                                                }
                                                case '/':{
                                                    right=right/num[o+1];
                                                    break;
                                                }
                                            }
                                        }
                                        if(left+flag*right==result) {
                                            count++;
                                            for(int a=1;a<=4;a++) {
                                                System.out.print(""+num[a]+oper[type[a]]);
                                            }
                                            System.out.print(num[5]+"="+result);
                                            System.out.println();
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        if(count==0) {
            System.out.println("无!");
        }
    }
}
最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成,浏览时请结合常识与多方信息审慎甄别。
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

相关阅读更多精彩内容

  • 完美立方: //a的三次方等于a,b,c三个数的立方之和,这一组数称为完美立方 #includeusing nam...
    Tangbh阅读 754评论 0 0
  • 算法简介 这是一种入门级的算法,它是利用计算机运算速度快、精确度高的特点,对要解决问题的所有可能情况,一个不漏地进...
    xiaoshua阅读 452评论 0 0
  • 背景 一年多以前我在知乎上答了有关LeetCode的问题, 分享了一些自己做题目的经验。 张土汪:刷leetcod...
    土汪阅读 12,863评论 0 33
  • 我觉得好遗憾。不久前我在微博上看到“鱼儿”,我很喜欢它,冬天就快要冰冻人们的心,我知道那种苦痛的感觉,无家可归的它...
    KootaU阅读 463评论 1 3
  • 最近有一些之前做淘客运营朋友,想学习一些店铺淘客运营技巧,也是不厌其烦的来找我。其实我是很懒的,我在很多群里,很多...
    且随你阅读 238评论 0 0

友情链接更多精彩内容