首页 > 试题广场 >

24点游戏算法

[编程题]24点游戏算法
  • 热度指数：156773 时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32M，其他语言64M
  • 算法知识视频讲解
\hspace{15pt}对于给定的四个小于 10 的正整数，你需要计算它们能否通过计算得到数字 24。让我们来回忆标准二十四点游戏的规则：
\hspace{23pt}\bullet\,输入的数字可能会重复，每一个数字必须用且只能用一次；
\hspace{23pt}\bullet\,运算顺序可以任意安排，且可以使用括号进一步地改变运算优先级；
\hspace{23pt}\bullet\,允许使用加、减、乘、除四种算数运算符，其中除法是实数除法；
\hspace{15pt}如果可以得到 24，输出 \rm true，否则，直接输出 \rm false。

输入描述:
\hspace{15pt}在一行上输入四个整数 a,b,c,d \left(1 \leqq a,b,c,d \leqq 10\right) 代表等待计算的数字。


输出描述:
\hspace{15pt}如果可以通过规定的计算得到 24，输出 \rm true，否则，直接输出 \rm false。
示例1

输入

7 2 1 10

输出

true

说明

\hspace{15pt}在这个样例中，7 \times 1 \times 2 + 10 = 24，因此输出 \rm true。
示例2

输入

2 2 2 9

输出

true

说明

\hspace{15pt}在这个样例中，2 + 2 \times (2 + 9) = 24，因此输出 \rm true。
示例3

输入

10 9 6 9

输出

true

说明

\hspace{15pt}在这个样例中，10 \times 9 \div 6 + 9 = 24，因此输出 \rm true。
示例4

输入

3 3 8 8

输出

true

说明

\hspace{15pt}在这个样例中，8 \div (3 - 8 \div 3) = 24，因此输出 \rm true。
示例5

输入

1 1 1 1

输出

false

备注:
\hspace{15pt}本题数据已进行加强（2025/01/09）。
算法知识视频讲解
添加回答
Python
牛客130964316号头像 牛客130964316号 
import sys
def check_24(l):
    for i in l:
        l1 = l.copy()
        l1.remove(i)
        for j in l1:
            l2 = l1.copy()
            l2.remove(j)
            for k in l2:
                l3 = l2.copy()
                l3.remove(k)
                for z in l3:
                    if cal_24(str(i),str(j),str(k),str(z)) == True:
                        return 'true'
    return 'false'
def cal_24(a,b,c,d):
    symbol = ['+','-','*','/']
    for k in range(0,len(symbol)):
        for l in range(0,len(symbol)):
            for n in range(0,len(symbol)):
                if eval('('+'('+a+symbol[k]+b+')'+symbol[l]+c+')'+symbol[n]+d) == 24:
                    return True
    return False

try:
    while True:
        line = sys.stdin.readline().strip()
        if line == '':
            break
        x = list(map(int, line.split()))
        print(check_24(x))
except:
    pass


编辑于 2020-09-11 18:09:23 回复(0)
牛客993850125号头像 牛客993850125号 
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            double[] num = new double[4];
            for (int i = 0; i < 4; i++) {
                num[i] = scanner.nextDouble();
            }
            boolean flag = false;
            for (int i = 0; i < 4 && !flag; i++) {
                if (num[i] == 0)
                    continue;
                for (int j = i + 1; j < 4 && !flag; j++) {
                    for (int j2 = 0; j2 < 4 && !flag; j2++) {
                        if (j2 == i || j2 == j)
                            continue;
                        for (int k = 0; k < 4 && !flag; k++) {
                            if (k == i || k == j || k == j2)
                                continue;
                            flag = find(num[i], num[j], num[j2], num[k], true);
                        }
                    }
                }
            }
            System.out.println(flag);
        }
        scanner.close();
    }

    public static boolean find(double a, double b, double c, double d, boolean flag) {
        if (b == 0) {
            if (Math.abs(Math.abs(a) - 24) < 0.01)
                return true;
            else
                return false;
        }
        if (find(a + b, c, d, 0, false)) {
            // System.out.println(a + "+" + b + "=" + (double) (a + b));
            return true;
        }
        if (find(a * b, c, d, 0, false)) {
            // System.out.println(a + "*" + b + "=" + (double) (a * b));
            return true;
        }
        if (find(a / b, c, d, 0, false)) {
            // System.out.println(a + "/" + b + "=" + (double) (a / b));
            return true;
        }
        if (find(b / a, c, d, 0, false)) {
            // System.out.println(b + "/" + a + "=" + (double) (b / a));
            return true;
        }
        if (a != b)
            if (find(a - b, c, d, 0, false)) {
                // System.out.println(a + "-" + b + "=" + (double) (a - b));
                return true;
            }
        if (flag) {
            for (int i = 0; i < 5 - (a == b ? 1 : 0); i++) {
                for (int j = 0; j < 5 - (c == d ? 1 : 0); j++) {
                    if (find(calculate(a, b, i), calculate(c, d, j), 0, 0, false)) {
                        // switch (i) {
                        //     case 0:
                        //         System.out.println(a + "+" + b + "=" + (double) (a + b));
                        //         break;
                        //     case 1:
                        //         System.out.println(a + "*" + b + "=" + (double) (a * b));
                        //         break;
                        //     case 2:
                        //         System.out.println(a + "/" + b + "=" + (double) (a/b));
                        //         break;
                        //     case 3:
                        //         System.out.println(b + "/" + a + "=" + (double) (b/a));
                        //         break;
                        //     case 4:
                        //         System.out.println(a + "-" + b + "=" + (double) (a - b));
                        //         break;
                        //     default:
                        //         break;
                        // }
                        // switch (j) {
                        //     case 0:
                        //         System.out.println(c + "+" + d + "=" + (double) (c + d));
                        //         break;
                        //     case 1:
                        //         System.out.println(c + "*" + d + "=" + (double) (c * d));
                        //         break;
                        //     case 2:
                        //         System.out.println(c + "/" + d + "=" + (double) (c/d));
                        //         break;
                        //     case 3:
                        //         System.out.println(d + "/" + c + "=" + (double) (d/c));
                        //         break;
                        //     case 4:
                        //         System.out.println(c + "-" + d + "=" + (double) (c - d));
                        //         break;
                        //     default:
                        //         break;
                        // }
                        return true;
                    }
                }
            }
        }
        return false;
    }

    public static double calculate(double a, double b, int i) {
        switch (i) {
            case 0:
                return a + b;
            case 1:
                return a * b;
            case 2:
                return a / b;
            case 3:
                return b / a;
            case 4:
                return a - b;

            default:
                return 0;
        }
    }
}
ac代码，考虑了所有情况，把注释行去掉是倒序输出计算过程。
发表于 2020-03-09 15:44:40 回复(0)
Python
雷凌云头像 雷凌云 
# 题目的隐藏条件好像是，不考虑使用括号，数字位置可调
def helper(arr, item):
    if item < 1:
        return False
    if len(arr) == 1:
        return arr[0] == item
    for i in range(len(arr)):
        L = arr[:i] + arr[i+1:]
        v = arr[i]
        if helper(L, item-v) or helper(L, item+v) or helper(L, item*v) or helper(L, item/v):
            return True
    return False
while True:
    try:
        arr = list(map(int, input().split(' ')))
        if helper(arr, 24):
            print("true")
        else:
            print("false")
    except:
        break

发表于 2019-08-20 11:15:30 回复(6)
lizhaowei213头像 lizhaowei213
分享一下我的做法。DFS搜索 
#include <stdio.h>
#include <algorithm>
using namespace std;
const int N=4;
int num[N];
int isSolve=0;
void dfs(int index,int currentNum,int arr[])
{
        if(currentNum==24)
        {
                isSolve=1;
                return;
        }
        if(isSolve||currentNum>24||index>=4)
                return;
        for(int operFlag=0;operFlag<4;operFlag++)
        {
                switch(operFlag)
                {
                        case 0:
                                dfs(index+1,currentNum+arr[index],arr);
                                break;
                        case 1:
                                dfs(index+1,currentNum-arr[index],arr);
                                break;
                        case 2:
                                dfs(index+1,currentNum*arr[index],arr);
                                break;
                        case 3:
                                dfs(index+1,currentNum/arr[index],arr);
                                break;
                }
                if(isSolve)
                        return;
        }
}
int main()
{
        while(scanf("%d%d%d%d",&num[0],&num[1],&num[2],&num[3])>0)
        {
                isSolve=0;
                sort(num,num+4);
                do
                {
                        dfs(1,num[0],num);
                        if(isSolve)
                                break;
                } while (next_permutation(num,num+4));
                if(isSolve)
                        printf("true\n");
                else
                        printf("false\n");
        }
        return 0;
}


发表于 2016-03-15 22:12:52 回复(29)
C/C++
ZackJiang头像 ZackJiang 
#include <iostream>
#include <math.h>
/*思路：采用递归的方式，每次只取两个数做加减乘除运算，并放回数组中,直到数据中只剩下一个数，判断这个数是否等于24*/

#define LING 1E-6


using namespace std;

bool find(double *numR,int n)
{
	double num[4] = {0};
	for(int i=0;i<n;i++)
	{
		num[i] = numR[i];
	}
	
	if(n == 1)
	{
		cout<<num[0]<<endl;              //查看所有运算结果
		if(fabs(num[0]-24) <= LING)
		
			return true;
			
		
		else
			return false;
	}
	for(int i=0;i<n;i++)
		for(int j=i+1;j<n;j++)
		{
			double a,b;
			a = num[i];
			b = num[j];
			num[j] = num[n-1];				//一个偷懒技巧，自个儿画画图就明白了
			num[i] = a+b;
			if(find(num,n-1))
				return true;
			num[i] = a-b;
			if(find(num,n-1))
				return true;
			num[i] = b-a;
			if(find(num,n-1))
				return true;
			num[i] = a*b;
			if(find(num,n-1))
				return true;
			if(b!=0)
			{
				num[i] = a/b;
				if(find(num,n-1))
					return true;
			}
			if(a!=0)
			{
				num[i] = b/a;
				if(find(num,n-1))
					return true;
			}
			num[i] = a;         //一开始我特么没加这两句，不同输入顺序结果不一样？？？！！！
			num[j] = b;			//这是因为啊，我下次递归的时候要恢复现场啊！！！！！！！！
			
			
		}
		return false;
	

}

int main()
{
	double num[4]= {0};
	while(cin>>num[0]>>num[1]>>num[2]>>num[3])
	{
		bool res = false;
	
	
		res = find(num,4);
		if(res)
			cout<<"true"<<endl;
		else
			cout<<"false"<<endl;
	}
	return 0;
	
}

发表于 2016-06-29 22:05:23 回复(5)
佘溪源头像 佘溪源 
// 暴力穷举
#include<iostream>
#include<vector>
using namespace std;
bool is24(vector<double> a, int tot, double result)
{
    if(a.empty())
    {
        return result==tot;
    }
    for(int i=0; i<a.size() ;i++)
    {
        vector<double> b(a);
        b.erase(b.begin()+i);
        if(is24(b,tot,result+a[i])
           || is24(b,tot,result-a[i])
           || is24(b,tot,result*a[i])
           || is24(b,tot,result/a[i]))
            return true;
    }
    return false;
}
int main()
{
    vector<double> a(4,0);
    while(cin >> a[0] >> a[1] >> a[2] >> a[3])
    {
        if(is24(a,24,0))
            cout<<"true"<<endl;
        else cout<<"false"<<endl;
    }
}
发表于 2018-05-03 10:23:34 回复(12)
BearYH头像 BearYH 
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		double result=0.0;
		int[] num=new int[4];
		while(input.hasNext()){
			int[] temp=new int[4];
			for(int i=0;i<4;i++){
				num[i]=input.nextInt();
			}
			System.out.println(check(num,temp,result));
		}
		input.close();
	}

	private static boolean check(int[] num,int[] temp,double result) {
		for(int i=0;i<num.length;i++){
			if(temp[i]==0){
				temp[i]=1;
				if(check(num,temp,result+num[i])
						|| check(num,temp,result-num[i])
						|| check(num,temp,result*num[i])
						|| check(num,temp,result/num[i])){
					return true;
				}
				temp[i]=0;
			}
		}
		if(result==24){
			return true;
		}else{
			return false;
		}
	}
}


发表于 2016-10-13 17:55:42 回复(12)
Python
gu_xing头像 gu_xing
笨办法： 
import itertools
def is24():
    l = ['+', '-', '*', '/']
    for num in itertools.permutations(input().split()):
        a, b, c, d = num
        for i in l:
            for j in l:
                for k in l:
                    fir = eval(str(a) + i + str(b))
                    sec = eval(str(fir)+ j + str(c))
                    if 24 == eval(str(sec)+ k + str(d)):
                        return 'true'
    else:
        return 'false'
while True:
    try:
        print(is24())
    except:
        break


发表于 2020-08-11 15:22:19 回复(6)
Python
selwynlee头像 selwynlee 
#分享一种最蠢的方法，真穷举法
while True:        
    try:
        list1=input().split()
        list6=['+','-','*','/']
        flag=False
        for ii in list1:
            list2=list1.copy()
            list2.remove(ii)
            for jj in list2:
                list3=list2.copy()
                list3.remove(jj)
                for xx in list3:
                    list4=list3.copy()
                    list4.remove(xx)
                    list5=[ii,jj,xx,list4[0]]
                    for i in list6:
                        for j in list6:
                            for x in list6:
                                try:
                                    m0=eval('('+str(list5[0])+i+str(list5[1])+')'+j+str(list5[2])+x+str(list5[3]))
                                except ZeroDivisionError:
                                    m0=0
                                try:
                                    m1=eval(str(list5[0])+i+'('+str(list5[1])+j+str(list5[2])+')'+x+str(list5[3]))
                                except ZeroDivisionError:
                                    m1=0
                                try:
                                    m2=eval(str(list5[0])+i+str(list5[1])+j+'('+str(list5[2])+x+str(list5[3])+')')
                                except ZeroDivisionError:
                                    m2=0 
                                try:
                                    m3=eval('('+str(list5[0])+i+str(list5[1])+')'+j+'('+str(list5[2])+x+str(list5[3])+')')
                                except ZeroDivisionError:
                                    m3=0
                                try:
                                    m4=eval('('+str(list5[0])+i+str(list5[1])+j+str(list5[2])+')'+x+str(list5[3]))
                                except ZeroDivisionError:
                                    m4=0 
                                try:
                                    m5=eval(str(list5[0])+i+'('+str(list5[1])+j+str(list5[2])+x+str(list5[3])+')')
                                except ZeroDivisionError:
                                    m5=0 
                                try:
                                    m6=eval('('+'('+str(list5[0])+i+str(list5[1])+')'+j+str(list5[2])+')'+x+str(list5[3]))
                                except ZeroDivisionError:
                                    m6=0 
                                try:
                                    m7=eval('('+str(list5[0])+i+'('+str(list5[1])+j+str(list5[2])+')'+')'+x+str(list5[3]))
                                except ZeroDivisionError:
                                    m7=0 
                                try:
                                    m8=eval(str(list5[0])+i+'('+'('+str(list5[1])+j+str(list5[2])+')'+x+str(list5[3])+')')
                                except ZeroDivisionError:
                                    m8=0 
                                try:
                                    m9=eval(str(list5[0])+i+'('+str(list5[1])+j+'('+str(list5[2])+x+str(list5[3])+')'+')')
                                except ZeroDivisionError:
                                    m9=0 
                                try:
                                    m10=eval(str(list5[0])+i+str(list5[1])+j+str(list5[2])+x+str(list5[3]))
                                except ZeroDivisionError:
                                    m10=0
                                list7=[m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10]
                                if int(24) in list7:
                                    flag=True
        if flag:
            print('true')
        else:
            print('false')
    except:
        break


编辑于 2019-08-27 15:56:45 回复(6)
C/C++
密涅瓦的猫头鹰头像 密涅瓦的猫头鹰 
//搞了半天原来是可以有括号的，全排列+递归就可以了，而全排列本身又可以递归来做。
//不要忘记恢复现场就行。
#include<iostream>
using namespace std;

inline void Swap(int &a, int &b)
{
	int temp = a;
	a = b;
	b = temp;
}

bool is24(int a[], int begin, int end, double tot)
{
	if (begin==end-1) return (a[begin] == tot);
	else
	{
		bool ans = false;
		for (int i = begin; i<end; i++)
		{
			swap(a[i], a[end-1]);
			ans = ans || is24(a, begin, end - 1, tot + a[end - 1]) || is24(a, begin, end - 1, tot - a[end - 1]) || is24(a, begin, end - 1, tot * a[end - 1]) || is24(a, begin, end - 1, tot / a[end - 1]);
			swap(a[i], a[end-1]);
		}
		return ans;
	}


}

int main()
{
	int a[4];
	while (cin >> a[0] >> a[1] >> a[2]>>a[3])
	{
		if (is24(a, 0,4, 24)) cout << "true" << endl;
		else cout << "false" << endl;
	}
}

发表于 2017-07-30 14:10:58 回复(7)
Python3
Linzs头像 Linzs
只允许使用加减乘除，结果后面冒出了个要用平方根的算法

发表于 2025-02-22 09:06:48 回复(0)
revivedSuN头像 revivedSuN
将四个数字分成 A | B C D , A  B |  C D, A  B C | D，每个子部分再递归划分，然后计算所有两部分的可能结果，最终找出结果如果包含24那么有解，此外除法非整除的不能算入结果内，且被除数不能为0.不过这样不能解带分数的情况 8 3 8 3   8/(3-(8/3))。此题也没给这么严格的用例。 
#include<stdio.h> #include<vector> #include<algorithm> 


	using namespace std;





	vector<int> fn24(intnums[],inti,intj)





	{





	if(i == j)





	{





	vector<int> ret;





	ret.push_back(nums[i]);





	returnret;





	}





	vector<int> result;





	for(inti1 = i + 1; i1 <= j; i1++)





	{





	vector<int> left = fn24(nums,i,i1-1);





	vector<int> right = fn24(nums,i1,j);





	for(intki = 0; ki < left.size(); ki++)





	{





	for(intkj = 0; kj < right.size(); kj++)





	{





	result.push_back(left[ki]+right[kj]);





	result.push_back(left[ki]-right[kj]);





	result.push_back(left[ki]*right[kj]);





	if(right[kj] != 0&& left[ki]%right[kj] == 0)





	{





	result.push_back(left[ki]/right[kj]);





	}





	}





	}





	}





	returnresult;





	}





	





	intmain()





	{





	





	intnums[4];





	bool ret;





	while(scanf("%d%d%d%d",&nums[0],&nums[1],&nums[2],&nums[3]) != EOF){





	ret = false;





	sort(nums,nums+4);





	do





	{





	vector<int> result = fn24(nums,0,3);





	for(inti = 0; i < result.size(); i++)





	{





	if(result[i] == 24)





	{





	ret = true;





	break;





	}





	}





	if(ret) break;





	} while(next_permutation(nums,nums+4));





	printf( ret ? "true\n": "false\n");





	}





	return0;





	}


编辑于 2016-03-27 22:08:32 回复(2)
Python3
牛客998489638号头像 牛客998489638号
print('true') #幽默一下，可以通过18组用例
发表于 2024-01-05 15:55:20 回复(3)
C++
网小白头像 网小白
1. 关于题解中“好像”没有考虑括号的问题？
所有的括号运算，都等价于把这个括号里的式子放在最开头来算，比如 2*(3+1) 就等价于递归运算中的3+1*2，虽然表面上乘法的优先级比较高，但在实际递归中，是先算了3+1=4，然后把4放在下一个运算中，也就是再算了4*2。  所以题解要求所有的数字全排列，就是为了对所有括号的可能性进行运算。
2. 关于提交时，19/20， 9 9 7 10 一直不通过的问题？
9 9 7 10算出来应该是false，但用上面的思路一直true，测试用例中通过了19个，说明思路是没问题的。 通过一个字符数组，记录了每个答案对应的运算式子，发现9 9 7 10 对应的式子是9+10*9/7 也就是（9+10）*9/7，这整除得不到24，但由于我用了int型，会自动四舍五入成24，这就是true的由来。
发表于 2022-08-01 14:28:55 回复(0)
Java
牛客359371677号头像 牛客359371677号
一个过关90%的快速方法（亲测有效）： 
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            for (int i = 0; i < 4; i++) {
               scanner.nextInt();
            }
            System.out.println("true");
        }
    }
}


发表于 2021-12-05 18:05:47 回复(6)
Python
朝夕_头像 朝夕_ 
def point24(m,n):
  if n < 1:
    return False
  elif len(m) == 1:
      if m[0] == n:
          return True
      else:
          return False
  # 四个数的运算结果等于其中三个数的运算结果与第四个数的运算结果
  for i in range(len(m)):
      a = m[i]
      b = m[:i] + m[i+1:]
      if point24(b,n-a)&nbs***bsp;point24(b,n+a)&nbs***bsp;point24(b,n*a)&nbs***bsp;point24(b,n/a):
        return True
while True:
  try:
      c = list(map(int,input().split()))
      if point24(c,24):
        print("true")
      else:
        print("false")
  except:
      break

发表于 2020-02-21 16:47:51 回复(2)
Python3
在游泳的芭乐很胖墩墩头像 在游泳的芭乐很胖墩墩
排行榜上的方法试过了，但是2 2 7 5这个用例过不了啊
发表于 2021-09-06 21:10:31 回复(2)
Python
JeremyStar头像 JeremyStar
方法一：穷举法 
# 解题思路：
# 注意题目有2个隐藏条件：1.数字前后顺序可调整 2.不考虑运算优先级，从前到后计算就行了

import itertools

def is24():
    op = ['+', '-', '*', '/']
    # 调用方法来获取所有的排列方式，迭代取出每一种
    for nums in itertools.permutations(input().strip().split(' ')):
        a, b, c, d = nums
        # print(type(a))
        # 4个操作数，需要3个运算符，接下来进行运算符的选择(每一个位置的运算符都有4种可能)
        for i in op:
            for j in op:
                for k in op:
                    fir = eval(a + i + b)  # 注意运算结果fir为int数，需要在下一步转字符串
                    sec = eval(str(fir) + j + c)
                    if eval(str(sec) + k + d) == 24:
                        return 'true'
    else:
        return 'false'

while True:
    try:
        print(is24())
    except:
        break
方法二：递归法 
def solve(arr, item):
    if item < 1:
        return False
    if len(arr) == 1:
        return arr[0] == item
    for i in range(len(arr)):
        # u = arr[:i] + arr[i + 1:]
        u = arr.copy()
        del u[i]
        v = arr[i]
        if solve(u, item - v)&nbs***bsp;solve(u, item + v)&nbs***bsp;solve(u, item * v)&nbs***bsp;solve(u, item / v):
            return True
    return False


while True:
    try:
        num_list = list(map(int, input().split(" ")))
        if solve(num_list, 24):
            print("true")
        else:
            print("false")
    except:
        break


编辑于 2020-12-16 21:35:25 回复(1)
C/C++
牛客165493200头像 牛客165493200 
#include<stdio.h>
#include<stdbool.h>
const int target=24;
const int add=0,multiply=1,subtract=2,divide=3;

//每次从现有数中有次序的挑两个，从+-*/中挑一个，把运算结果和剩余数进入下一层递归
bool is24dian(double a[],int len){
    if(len==1&&a[0]==target) return true;
    for(int i=0;i<len;i++)
        for(int j=0;j<len;j++)
            if(i!=j){  //挑的两数不能相同
                double b[20];
                int len_b=0;
                if(len>2)  //存剩余的数，<=2就没剩余的数
                    for(int k=0;k<len;k++)
                        if(k!=i&&k!=j)
                            b[len_b++]=a[k];
                for(int k=0;k<4;k++){ //+-*/遍历一遍
                    if(k<=1&&i>j)  //+或*交换ij是同一情况，可跳过后一次
                        continue;
                    if(k==add) b[len_b++]=a[i]+a[j];
                    else if(k==multiply) b[len_b++]=a[i]*a[j];
                    else if(k==subtract) b[len_b++]=a[i]-a[j];
                    else if(k==divide){
                        if(a[j]==0) continue;
                        b[len_b++]=a[i]/a[j];
                    }
                    if(is24dian(b, len_b))
                        return true;
                    len_b--; //运算往下递归最后失败回来了，退掉本次运算结果
                }
            }
    return false;
}
int main(int argc,char *argv[]){
    int a[4];
    while(scanf("%d%d%d%d",&a[0],&a[1],&a[2],&a[3])!=EOF){
        double t[4];   //不能直接把int数组当作参数传过去，要转成double
        for(int i=0;i<4;i++)
            t[i]=a[i];
        if(is24dian(t, 4)) printf("true\n");
        else printf("false\n");
    }
    return 0;
}

发表于 2020-09-02 22:46:39 回复(1)
牛客496123859号头像 牛客496123859号
主要是穷举法，4个数字，有24中组合，3个运算符，有64个组合，一共是24*64各种组合。对这1536个情况进行计算。
1. 计算4个数字的24个组合。设计思路是计算所有可能输入的下标，排除相同的就是不同的。
2. 计算3个运算符的64种组合，思路是所有的排列组合都算，重复也算。
这里生成所有可能的方法是对每个数进行加1。
计算4个数的运算表达式，没有使用递归，直接从两个值算起，直到4个值。
写了大概3个小时。
发表于 2018-12-15 16:51:42 回复(0)
提交观点

问题信息

搜索 dfs
难度：
377条回答 45360浏览

热门推荐

通过挑战的用户

查看代码

相关试题

24点游戏算法

扫一扫，把题目装进口袋

求职之前，先上牛客

扫描二维码，进入QQ群

扫描二维码，关注牛客公众号