24点算法

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

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

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

  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);

                    gg++;
                }
            }

        }
    }
    
    /** *//**
     * 组合表达式
     */
    private static void creatStr(List<String> l, String a, String b, int hasBracket) {
        String[] operatorArr = {"+", "-", "*", "/"};
        
        for (String opr : operatorArr)
        {
            // 需要括号
            if (hasBracket == 1)
            {
                l.add("(" + a + opr + b + ")");
            } else {
                l.add(a + opr + b);
            }
        }
    }

    /** *//**
     * 得出所有的排序情况
     */
    private static List<List<Float>> creatNum(List<Float> d) {
        List<List<Float>> a = new ArrayList<List<Float>>();
        
        if (d.size() == 1)
        {
            List<Float> dd1 = new ArrayList<Float>();
            dd1.add(d.get(0));
            a.add(dd1);
            return a;

        } else {
            for (int j=0;j<d.size();j++)
            {
                List<Float> d3 = new ArrayList<Float>();
                
                // 将传入的List复制出来
                for (int i=0;i<d.size();i++)
                {
                    d3.add(d.get(i));
                }

                float x = d3.get(j);
                d3.remove(j);
                
                // 递归
                List<List<Float>> tmp1 = creatNum(d3);
                
                for (List<Float> l : tmp1)
                {    
                    List<Float> d2 = new ArrayList<Float>();
                    // 添加第一位截取的数字
                    d2.add(x);
                    // 添加递归后得到的数字
                    for (float f : l)
                    {
                        d2.add(f);
                    }
                    a.add(d2);
                }
            }
            return a;
        }
    }

    /** *//**
     * 得到两个数加减乘除后的结果    
     */
    private static List<Float> calcTwoNum(float n1, float n2){
        List<Float> a = new ArrayList<Float>();
        a.add(n1 + n2);
        a.add(n1 - n2);
        a.add(n1 * n2);
        a.add(n1 / n2);
         return a;
    }
}