算法思想篇-枚举法 - 图1

1. 枚举法

1.1 基本概念

枚举法，又称暴力算法，它就是把可能的结果一一列举出来，然后通过条件判断结果是否需要保留，通常枚举法通过循环来实现。枚举法的最大特点就是，在面对任何问题时，都会去尝试每一种解决方法。

枚举算法解题基本思路：

  1. 确定枚举对象、枚举范围和判定条件。
  2. 逐一列举可能的解，验证每一个解是否是问题的解。

枚举算法一般按照如下3个步骤进行：

  1. 题解的可能范围，不能遗漏任何一个真正的解，也要避免有重复。
  2. 判定是否是真正解的方法。
  3. 时可能解的范围降至最小，以便提高解决问题的效率。

算法思想篇-枚举法 - 图2

1.2 案例

1.2.1 百钱买百鸡

公鸡5文钱一只，母鸡3文钱一只，小鸡3只一文钱， 用100文钱买一百只鸡,其中公鸡，母鸡，小鸡都必须要有，问公鸡，母鸡，小鸡要买多少只刚好凑足100文钱。
https://blog.csdn.net/xiangxizhishi/article/details/79118561
x+y+z=100
5x+3y+z/3=100

因为用100文钱买一百只鸡,其中公鸡，母鸡，小鸡都必须要有
5x < 100 ==> 0 < x < 20
3y < 100 ==< 0 < y < 33

  1. package com.muzili.alg;
  3. /**
  4.  *
  5.  * @author: muzili(李敷斌)
  6.  * @date: 2021/7/24
  7.  * @version: v0.0.1
  8.  * @description: 百钱买百鸡
  9.  */
  10. public class BuyChickenSolution{
  12.     public static void main(String[] args){
  14.         int x = 0; //公鸡数量
  15.         int y = 0; //母鸡数量
  16.         int z = 0; //小鸡数量
  18.         for(x = 1;x < 20;x++){
  19.             for(y = 1;y < 33;y++){
  20.                 z =  100 - x - y;
  21.                 if(z % 3 != 0){
  22.                     continue;
  23.                 }
  24.                 int totalAmount = (x * 5) + (y * 3) + (z / 3);
  25.                 if(totalAmount == 100){
  26.                     System.out.println("100钱可买得公鸡"+x+"只，母鸡"+y+"只，小鸡"+z+"只！");
  27.                 }
  28.             }
  29.         }
  31.     }
  33. }
  35. 100钱可买得公鸡4只，母鸡18只，小鸡78只！
  36. 100钱可买得公鸡8只，母鸡11只，小鸡81只！
  37. 100钱可买得公鸡12只，母鸡4只，小鸡84只！
  39. Process finished with exit code 0

1.2.2 填写运算符

  1.  输入五个数，数与数之间用空格分开，然后给出结果，然后在5个数间只能添加“+”，“-”，“*”，“/”这4种运算符，使得等式成立。<br /> 例如：<br /> 输入五个运算数：3 3 3 3 3<br />       输入结果：3
  1. package com.muzili.alg;
  3. import com.muzili.stack.MathElCalcu;
  5. import java.math.BigDecimal;
  7. /**
  8.  * 输入五个数，数与数之间用空格分开，然后给出结果，然后在5个数间只能添加“+”，“-”，“*”，“/”这4种运算符，
  9.  * 使得等式成立。
  10.  * 例如：
  11.  * 输入五个运算数：3 3 3 3 3
  12.  * 输入结果：3
  13.  *
  14.  *  3+3+3-3-3=3
  15.  *  3+3+3-3-3=3
  16.  *  3+3+3-3-3=3
  17.  *  3+3+3-3-3=3
  18.  *  3-3-3+3+3=3
  19.  *  3-3-3+3+3=3
  20.  *  3-3-3+3+3=3
  21.  *  3-3-3+3+3=3
  22.  *  3*3*3/3/3=3
  23.  *  3*3*3/3/3=3
  24.  *  3*3*3/3/3=3
  25.  *  3*3*3/3/3=3
  26.  *
  27.  * @author: muzili(李敷斌)
  28.  * @date: 2021/7/24
  29.  * @version: v0.0.1
  30.  * @description: 填写运算符
  31.  */
  32. public class FillOperatorSolution {
  34.     char[] operators = {'+','-','*','/'};
  36.     public void fillOperator(BigDecimal res,BigDecimal ... params){
  38.         for (int i = 0; i < operators.length; i++) {
  39.             for (int j = 0; j < operators.length; j++) {
  40.                 for (int k = 0; k < operators.length; k++) {
  41.                     for (int l = 0; l < operators.length; l++) {
  42.                         StringBuilder calcElSb = new StringBuilder(String.valueOf(params[0]));
  43.                         calcElSb.append(operators[i]);
  44.                         calcElSb.append(params[1]);
  45.                         calcElSb.append(operators[j]);
  46.                         calcElSb.append(params[2]);
  47.                         calcElSb.append(operators[k]);
  48.                         calcElSb.append(params[3]);
  49.                         calcElSb.append(operators[k]);
  50.                         calcElSb.append(params[4]);
  52.                         String calcEl = calcElSb.toString();
  53.                         MathElCalcu mathElCalcu = new MathElCalcu();
  54.                         BigDecimal calc = mathElCalcu.calc(calcEl);
  55.                         if (calc.compareTo(res) == 0){
  56.                             System.out.println(calcEl + "=3");
  57.                         }
  58.                     }
  59.                 }
  60.             }
  61.         }
  62.     }
  64.     public static void main(String[] args) {
  66.         FillOperatorSolution solution = new FillOperatorSolution();
  67.         solution.fillOperator(BigDecimal.valueOf(3),BigDecimal.valueOf(3),
  68.                               BigDecimal.valueOf(3),BigDecimal.valueOf(3),
  69.                               BigDecimal.valueOf(3),BigDecimal.valueOf(3));
  71.     }
  73. }

1.3 枚举法的缺点

每一种可能的结果都会列举出来，哪怕它不是最总结果这样会耗费大量的时间。