递归——算24

递归——分解成子问题
问题
给出4个小于10个正整数，你可以使用加减乘除4种运算以及括
号把这4个数连接起来得到一个表达式。现在的问题是，是否存
在一种方式使得得到的表达式的结果等于24。
这里加减乘除以及括号的运算结果和运算的优先级跟我们平常
的定义一致（这里的除法定义是实数除法）。
比如，对于5，5，5，1，我们知道5 * (5 – 1 / 5) = 24，因此
可以得到24。又比如，对于1，1，4，2，我们怎么都不能得到
24。
输入
输入数据包括多行，每行给出一组测试数据，包括4个小于10个正整
数。最后一组测试数据中包括4个0，表示输入的结束，这组数据不用
处理。
输出
对于每一组测试数据，输出一行，如果可以得到24，输出“YES”；
否则，输出“NO”。
样例输入
5 5 5 1
1 1 4 2
0 0 0 0
样例输出
YES
NO
分析
n个数算24，必有两个数要先算。这两个数算的结果，和剩余n-2个数，就构成了n-1个数求24的问题
枚举先算的两个数，以及这两个数的运算方式。
边界条件：一个数算24
注意：浮点数比较是否相等，不能用 ==

import java.util.Scanner;

public class Count24 {
    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        while (true){
            double x[]=new double[4];
            for (int i=0;i<4;i++){
                x[i]=reader.nextDouble();
            }
            if (isZero(x[0])){
                break;
            }
            if (twentyFour(x,4)){
                System.out.println("YES");
            }else{
                System.out.println("NO");
            }
        }
    }
    public static boolean twentyFour(double[] x,int n){
        //用数组x中的n个数进行计算24
        //边界条件：一个数计算24
        if (n==1){
            if (isZero(x[0]-24)){
                return true;
            }else{
                return false;
            }
        }
        double[] b=new double[5];//储存未参与过计算的数
        for (int i=0;i<n-1;i++){
            for (int j=i+1;j<n;j++){//遍历选出两个数的所有情况
                int m=0;//还剩m个数
                for (int k=0;k<n;k++){
                    if (k!=i&&k!=j){
                        b[m++]=x[k];
                    }
                }
                //储存两个数计算结果，算成一个新数参与后续计算
                b[m]=x[j]+x[i];
                if (twentyFour(b,m+1)){//数组长度要+1
                    return true;
                }
                b[m]=x[j]-x[i];//减有两种情况
                if (twentyFour(b,m+1)){
                    return true;
                }
                b[m]=x[i]-x[j];
                if (twentyFour(b,m+1)){
                    return true;
                }
                b[m]=x[j]*x[i];
                if (twentyFour(b,m+1)){
                    return true;
                }
                if (!isZero(x[j])){//除有两种情况，且除数不为0
                    b[m]=x[i]/x[j];
                    if (twentyFour(b,m+1)){
                        return true;
                    }
                }
                if (!isZero(x[i])){
                    b[m]=x[j]/x[i];
                    if (twentyFour(b,m+1)){
                        return true;
                    }
                }
            }
        }
        return false;
    }
    public static boolean isZero(double x){
        //浮点数比较，差的绝对值够小，就认为相等
        return Math.abs(x)<=1e-6;
    }
}