之前看了网上很多关于24点问题的总结,网上有很多算法,主要来讲一下,像以下有几个来比较一下。如:点击连接地址这种方式没有考虑加括号的情况,不能很好地解决问题,再如点击连接地址还是没有完整地解决问题,这里只对前两个数及后两个数进行了加括号,即先计算两个数,再计算后两个数,最后把两个结果进行计算。没有计算的顺序和加括号。最后,在看了朋友(真的厉害)的代码和加上自己的一些想法,最后将几十万种情况以不到一秒的时间运算出来。以下是我对该算法原理及实现的理解。以下是算法概要。
第一,有一定的数学基础,知道简单的排列组合原理。52张牌,其中只有13种数字。用四重循环将每次得到的四个数记录下来,另写方法判断组合的数量。这样看下面的代码的 times()方法就会明了。
第二,理解算法的整体运作过程。例如:a,b,c,d四个数,在计算时,要么我们先计算a,b,要么我们先计算b,c要么我们先计算c,d,三元到二元也是同样的道理,最后二元到一元,就可以得到结果了。对于四个数,根据算术优先级,从高到低,一定会有三个运算符。(这里指的是一种排列)。
步骤:
1.得到四个数,对这四个数进行排列组合,比如(10,2,3,6)有(2,3,10,6),(2,6,10,3)等这些组合呀,以便构成不同的算式。
2.采用三重循环的方式,每一次循环都会是不同的运算符,这一步是为了得到各种运算符的组合。
3,然后在三重循环里面,分别进行优先级组合,同时进行计算,将四元转化为三元,如下,这里只展示了四元转三元,三元转二元,同理,这一步是为了得到各个优先级层次上的各种组合。与步骤2一起构成了所有的组合。话不多说,直接上代码。
代码如下:
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
/**
*
* @author SUNJIN
*
*/
public class QuickFindSolution {
// 将4个操作数简化为3个操作数时,将这三个操作数存放在temp1中
private static double[] temp1 = new double[3];
// 将3个操作数简化为2个操作数时,将这两个操作数存放在temp2中
private static double[] temp2 = new double[2];
private static double sum;
private static int[] cardArray = new int[4];
private static char[] operator = { '+', '-', '*', '/' };
private static double[] scard = new double[4];
private static boolean isCorrect = false;
/**
* 列出所有不重复的组合
*/
public static void main(String[] args) {
int allcount = 0;
int count = 0;
int times = 0;
long starttime = System.currentTimeMillis();
// 这里只考虑对数据
// 为了减少运算量,避免重复的排列组合,比如1,2,3,4与1,2,4,3,这样就是重复的,采用了j = i, k = j这种来控制循环
for (int i = 1; i < 14; i++) {
for (int j = i; j < 14; j++) {
for (int k = j; k < 14; k++)
for (int l = k; l < 14; l++) {
// 判断花色重复的数量
times = times(i, j, k, l);
allcount += times;
// 判断该表达式是否正确
if (getExpression(i, j, k, l) != null) {
count += times;
}
}
}
}
double rate = (double) count / allcount;
System.out.println("所有可能的组合共有:" + allcount);
System.out.println("结果为24的组合共有: " + count);
System.out.println("成功的几率是:" + rate);
long endtime = System.currentTimeMillis();
System.out.println("共耗时间" + (endtime - starttime) + "毫秒," + "即"
+ (double) (endtime - starttime) / 1000 + "秒。");
}
/**
* 方法简述:输入4个数判断其能产生多少个结果等于24的算式,就是选出来的四个数一个会有多少种排列组合,这样是为了得到更多
*
* @param i
* @param j
* @param k
* @param l
* @return
*/
public static ArrayList<String> getExpression(int num1, int num2, int num3,
int num4) {
// 声明一个ArrayList,用于存放所有可能的表达式
ArrayList<String> expressionList = new ArrayList<String>();
for (int a = 0; a < 4; a++)
for (int b = 0; b < 4; b++) {
// 这些判断是为了防止产生错误的组合,比如传进来的数是1,4,6,8,如果没有判断,就可能导致产生1,1,6,8这种组合
if (b == a) {
continue;
}
for (int c = 0; c < 4; c++) {
if (c == a || c == b) {
continue;
}
for (int d = 0; d < 4; d++) {
if (d == a || d == b || d == c) {
continue;
}
// 让四个数产生了不同的组合,比如1,4,6,8--8,1,6,4等
cardArray[a] = num1;
cardArray[b] = num2;
cardArray[c] = num3;
cardArray[d] = num4;
for (int m = 0; m < 4; m++) {
// 这里转换为double类型是为了方便后面的除法运算
scard[m] = (double) cardArray[m];
}
// 进行一次搜索
expressionList = search();
// 如果搜索出来的是正确的,那么将isCorrect置为false,便于下次使用
if (isCorrect) {
isCorrect = false;
return expressionList;
}
}
}
}
return null;
}
/**
* 方法简述:基本计算
*
* @param number1
* 数字1
* @param number2
* 数字2
* @param operator
* 数字3
* @return
*/
private static double calcute(double number1, double number2, char operator) {
if (operator == '+') {
return number1 + number2;
} else if (operator == '-') {
return number1 - number2;
} else if (operator == '*') {
return number1 * number2;
} else if (operator == '/' && number2 != 0) {
return number1 / number2;
} else {
return -1;
}
}
private static ArrayList<String> search() {
// 声明一个ArrayList,用于存放所有可能的表达式
ArrayList<String> expressionList = new ArrayList<String>();
// 第一次放置的符号(算术优先级最高)
for (int i = 0; i < 4; i++) {
// 第二次放置的符号(算术优先级次高)
for (int j = 0; j < 4; j++) {
// 第三次放置的符号(最后一个计算)
for (int k = 0; k < 4; k++) {
// 首先计算的两个相邻数字,共有3种情况,相当于括号的作用,也就是各种优先级顺序组合
for (int m = 0; m < 3; m++) {
// 如果出现除数为零则表达式出错,结束此次循环
if (scard[m + 1] == 0 && operator[i] == '/') {
break;
}
// 从4个操作数中提取出两个数,然后将可能进行优先计算的两个数计算,然后得到值,注意:这里是优先级最高的运算符,也就是第一次放置的符号
temp1[m] = calcute(scard[m], scard[m + 1], operator[i]);
// 将其余两个没有进行计算的值赋值给temp1数组
temp1[(m + 1) % 3] = scard[(m + 2) % 4];
temp1[(m + 2) % 3] = scard[(m + 3) % 4];
// 先确定首先计算的两个数字,计算完成相当于剩下三个数,按顺序储存在temp1数组中
// 三个数字选出先计算的两个相邻数字,两种情况,相当于第二个括号
for (int n = 0; n < 2; n++) {
if (temp1[n + 1] == 0 && operator[j] == '/') {
break;
}
// 简化运算,将三个操作数简化为两个操作数,注意:这里是优先级最高的运算符,也就是第二次放置的符号
temp2[n] = calcute(temp1[n], temp1[n + 1],
operator[j]);
temp2[(n + 1) % 2] = temp1[(n + 2) % 3];
if (temp2[1] == 0 && operator[k] == '/') {
break;
}
// 将两个操作数简化为一个操作数,注意:这里是优先级最高的运算符,也就是第三次放置的符号
sum = calcute(temp2[0], temp2[1], operator[k]);
// 如果能够24,那么将该算式输出来
if (sum == 24) {
isCorrect = true;
String expression = "";
// // 根据组合列出算式
// if (m == 0 && n == 0) {
// expression = "((" + (int) scard[0]
// + operator[i] + (int) scard[1]
// + ")" + operator[j]
// + (int) scard[2] + ")"
// + operator[k] + (int) scard[3]
// + "=" + (int) sum;
// } else if (m == 0 && n == 1) {
// expression = "(" + (int) scard[0]
// + operator[i] + (int) scard[1]
// + ")" + operator[k] + "("
// + (int) scard[2] + operator[j]
// + (int) scard[3] + ")=" + (int) sum;
// } else if (m == 1 && n == 0) {
// expression = "(" + (int) scard[0]
// + operator[j] + "("
// + (int) scard[1] + operator[i]
// + (int) scard[2] + "))"
// + operator[k] + (int) scard[3]
// + "=" + (int) sum;
// } else if (m == 2 && n == 0) {
// expression = "(" + (int) scard[0]
// + operator[j] + (int) scard[1]
// + ")" + operator[k] + "("
// + (int) scard[2] + operator[i]
// + (int) scard[3] + ")=" + (int) sum;
// } else if (m == 2 && n == 0) {
// expression = (int) scard[0] + operator[k]
// + "(" + (int) scard[1]
// + operator[j] + "("
// + (int) scard[2] + operator[i]
// + (int) scard[3] + "))="
// + (int) sum;
// }
// System.out.println(expression);
expressionList.add(expression);
}
}
}
}
}
}
return expressionList;
}
/**
* 利用对花色的排列组合,避免花色重复,大量地减少运算量,提高效率(一次)
*
* @param i
* @param j
* @param k
* @param l
* @return
*/
private static int times(int i, int j, int k, int l) {
// 利用set判断有多少种重复
Set<Integer> set = new HashSet<Integer>();
set.add(i);
set.add(j);
set.add(k);
set.add(l);
// 当4个数的数字全部一样时,只可能有一种花色的组合,比如红桃6,梅花6,方块6,黑桃6
if (set.size() == 1) {
return 1;
}
// 当4个数中,有两个数相同,其余的数都不相同时,就有C4取2乘以C4取1乘以C4取1种可能的花色组合,比如红桃6,梅花6,方块7,黑桃8
else if (set.size() == 3) {
return 96;
}
// 当4个数全部不同时,就有C4取1乘以C4取1乘以C4取1乘以C4取1种(256)情况
else if (set.size() == 4) {
return 256;
} else {
// 当4个数中,两两相同时,同样的,利用排列组合,一共有C4取2乘以C4取2,共36种情况
if ((i == j && k == l) || (i == k && j == l)) {
return 36;
}
// 当4个数中有三个数相同,另外一个数不同时
else {
return 16;
}
}
}
}