24点算法

题目：给四个数，用+，-，*，/进行组合，使得结果的等于24，如：1，5，5，5，则(5-1/5)*5=24

下面是我自己的算法，没有对算术表达式进行过滤~比如会认为((9-8)+7)*3 = 24和((9+7)-8)*3 = 24是不同的表达式组合

Java SE6编译通过，如有缺点请指正~

24点算法
  1import java.util.*;
  2
  3/** *//**
  4 * 24点算法
  5 */
  6class Create24
  7{
  8    public static void main(String[] args) 
  9    {
 10        // 存放4个整数
 11        List<Float> dold = new ArrayList<Float>();
 12        
 13        // 初始化，添加四个整数
 14        dold.add(9f);
 15        dold.add(8f);
 16        dold.add(7f);
 17        dold.add(3f);
 18        
 19        // 根据四个整数得出所有的排序情况
 20        List<List<Float>> dd = creatNum(dold);
 21        
 22        // 打印出可能的序列
 23        System.out.println("共有" + dd.size() + "排序方式！");
 24        for (List<Float> x : dd) 
 25        {
 26            for (float xx : x)
 27            {
 28                System.out.print((int)xx + " ");
 29            }
 30            System.out.println("");
 31        }
 32        
 33        // 记录所有的计算结果
 34        List<List<Float>> tmp2 = new ArrayList<List<Float>>();
 35    
 36        // 记录所有的表达式
 37        List<String> strList2 = new ArrayList<String>();
 38        
 39        // 得到所有可能的结果和表达式
 40        calcReuslt(dd, tmp2, strList2);
 41        
 42        // 打印出所有可能等于24的算术表达式
 43        int hh = 0;
 44        for(List<Float> l1 : tmp2){
 45            for(float j1 : l1){
 46                if (j1 == 24)
 47                {
 48                    System.out.println((strList2.get(hh)) + " = " + (int)j1);
 49                } else if (j1 == -24)
 50                {    
 51                    // 得数为负值时需要在表达式前加负号
 52                    System.out.println("-" + (strList2.get(hh)) + " = " + (int)(-j1));
 53                }
 54                hh++;
 55            }
 56        }
 57        
 58    }
 59    
 60    /** *//**
 61     * 得到所有可能的结果和表达式
 62     */
 63    private static void calcReuslt (List<List<Float>> dd, List<List<Float>> tmp2, List<String> strList2) {
 64
 65        for (List<Float> d : dd)
 66        {
 67            // 得到第一个和第二数字的计算结果
 68            List<Float> tmp0 = calcTwoNum(d.get(0), d.get(1));
 69
 70            // 存放第一个和第二数字的表达式
 71            List<String> strList0 = new ArrayList<String>();
 72            // 得到第一个和第二数字的表达式
 73            creatStr(strList0, String.valueOf(d.get(0).intValue()), String.valueOf(d.get(1).intValue()), 1);
 74
 75            // 存放第一、第二数字的计算结果和第三个数字的计算结果
 76            List<List<Float>> tmp1 = new ArrayList<List<Float>>();
 77            // 存放第一、第二数字的计算结果和第三个数字的表达式
 78            List<String> strList1 = new ArrayList<String>();
 79
 80            int ii = 0;
 81            for(float i : tmp0){
 82
 83                // 得到第一、第二数字的计算结果和第三个数字的计算结果
 84                tmp1.add(calcTwoNum(i, d.get(2)));
 85
 86                // 得到第一、第二数字的计算结果和第三个数字的表达式
 87                creatStr(strList1, strList0.get(ii), String.valueOf(d.get(2).intValue()), 1);
 88
 89                ii++;
 90            }
 91
 92            int gg = 0;
 93            for(List<Float> l : tmp1){
 94                for(float j : l){
 95                    // 得到前三个数字和第四个数字的计算结果
 96                    tmp2.add(calcTwoNum(j, d.get(3)));
 97
 98                    // 得到前三个数字和第四个数字的表达式
 99                    creatStr(strList2, strList1.get(gg), String.valueOf(d.get(3).intValue()), 0);
100
101                    gg++;
102                }
103            }
104
105        }
106    }
107    
108    /** *//**
109     * 组合表达式
110     */
111    private static void creatStr(List<String> l, String a, String b, int hasBracket) {
112        String[] operatorArr = {"+", "-", "*", "/"};
113        
114        for (String opr : operatorArr)
115        {
116            // 需要括号
117            if (hasBracket == 1)
118            {
119                l.add("(" + a + opr + b + ")");
120            } else {
121                l.add(a + opr + b);
122            }
123        }
124    }
125
126    /** *//**
127     * 得出所有的排序情况
128     */
129    private static List<List<Float>> creatNum(List<Float> d) {
130        List<List<Float>> a = new ArrayList<List<Float>>();
131        
132        if (d.size() == 1)
133        {
134            List<Float> dd1 = new ArrayList<Float>();
135            dd1.add(d.get(0));
136            a.add(dd1);
137            return a;
138
139        } else {
140            for (int j=0;j<d.size();j++)
141            {
142                List<Float> d3 = new ArrayList<Float>();
143                
144                // 将传入的List复制出来
145                for (int i=0;i<d.size();i++)
146                {
147                    d3.add(d.get(i));
148                }
149
150                float x = d3.get(j);
151                d3.remove(j);
152                
153                // 递归
154                List<List<Float>> tmp1 = creatNum(d3);
155                
156                for (List<Float> l : tmp1)
157                {    
158                    List<Float> d2 = new ArrayList<Float>();
159                    // 添加第一位截取的数字
160                    d2.add(x);
161                    // 添加递归后得到的数字
162                    for (float f : l)
163                    {
164                        d2.add(f);
165                    }
166                    a.add(d2);
167                }
168            }
169            return a;
170        }
171    }
172
173    /** *//**
174     * 得到两个数加减乘除后的结果    
175     */
176    private static List<Float> calcTwoNum(float n1, float n2){
177        List<Float> a = new ArrayList<Float>();
178        a.add(n1 + n2);
179        a.add(n1 - n2);
180        a.add(n1 * n2);
181        a.add(n1 / n2);
182         return a;
183    }
184}

转载于:https://www.cnblogs.com/lostheaven/archive/2009/03/06/1404672.html