扑克牌四则运算

from itertools import permutations
while 1:
    try:
        nums = list(map(int, input().split()))
        m = int(input())
        sta = False
        def dfs(nums, i, temp):
            if i == len(nums)-1:
                if eval(temp) == m:
                    global sta
                    sta = True
                return
            dfs(nums, i+1, temp+'+%d'%nums[i+1])
            dfs(nums, i+1, temp+'-%d'%nums[i+1])
            dfs(nums, i+1, temp+'*%d'%nums[i+1])
            dfs(nums, i+1, temp+'//%d'%nums[i+1])

        for ls in permutations(nums):
            dfs(ls, 0, 'nums[0]')
            if sta:
                break
        if sta:
            print('1')
        else:
            print('0')
    except EOFError:
        break

""""
DFS 对扑克顺序深搜，每种选择夹带4种情况运算符
暴力枚举应该也可以，扑克顺序4*3*2*1，运算符4*4*4，
"""


def dfs(ss, a, vis, m, step):
    for i in range(len(a)):
        if not vis[i]:
            continue
        vis[i] = False
        s = ss + a[i]
        if step == 3:
            if eval(s) == m:
                return True
            else:
                vis[i] = True
                continue
        res = dfs(s + '+', a, vis, m, step + 1) or dfs(s + '-', a, vis, m, step + 1) or \
              dfs(s + '*', a, vis, m, step + 1) or dfs(s + '//', a, vis, m, step + 1)
        vis[i] = True
        if res: return True
    return False


if __name__ == "__main__":
    a = input().strip().split()
    m = int(input())
    vis = [True] * len(a)
    ans = dfs("", a, vis, m, 0)
    print(1 if ans else 0)

	

#include <bits/stdc++.h>
using namespace std;

int m;
set<int> S{0,1,2,3};
bool DFS(int *a, int p, int t){
    if(S.empty())
        return p+t==m;
    vector<int> v(S.begin(), S.end());
    for(int i=0;i<v.size();i++){
        int x = v[i];
        S.erase(x);
        if(DFS(a, a[x], p+t))
            return true;
        if(DFS(a, -a[x], p+t))
            return true;
        if(DFS(a, p*a[x], t))
            return true;
        if(DFS(a, p/a[x], t))
            return true;
        S.insert(x);
    }
    return false;
}

int main(){
    int a[4];
    for(int i=0;i<4;i++)
        cin>>a[i];
    cin>>m;
    cout<<DFS(a, 0, 0)<<endl;
}

import java.util.*;

// 注意：可以任意改变扑克牌的顺序, 其实就是考虑了括号的、所有情况的
// 🍓
// 回溯：初始4张牌, 任取2张进行+-*/, 结果放回, 变3张牌,下一层..直至仅剩1张

public class Main {
    private static boolean find = false; // 找到一种

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        List<Integer> nums = new ArrayList<>();
        for (int i = 0; i < 4; i++) nums.add(in.nextInt());
        int m = in.nextInt();
        backtrack(nums, m);
        System.out.print(find ? 1 : 0);
    }

    // 回溯
    private static void backtrack(List<Integer> nums, int target) {
        if (find || nums.size() == 1) { // 出口
            if (!find && nums.get(0) == target) find = true;
            return;
        }

        for (int i = 0; i < nums.size() && !find; i++) {
            for (int j = 0; j < nums.size() && !find; j++) {
                if (i == j) continue;
                Integer x = nums.get(i), y = nums.get(j);  // 任取两个数
                int res = -1;
                for (int k = 0; k <= 3; k++) { // +-*/ 四种
                    if (k == 0) res = x + y;
                    else if (k == 1) res = x - y;
                    else if (k == 2) res = x * y;
                    else if (y != 0) res = x / y;
                    List<Integer> numsCopy = new ArrayList<>(nums);
                    numsCopy.remove(x);
                    numsCopy.remove(y);
                    numsCopy.add(res);
                    backtrack(numsCopy, target);  // 4 * 11 / 3 -9 = 23
                }
            }
        }
    }
}

# 深度优先
from itertools import permutations
data=[i for i in input().split()]
target=int(input())
find=0
def rec(index,res):
    global find
    if len(res)==2*n-1:
        if eval("".join(res))==target&nbs***bsp;find:
            find=1
            return
        else:
            return
    for i in ["+","-","*","//"]:
            res.append(i)
            res.append(cur[index])
            rec(index+1,res)
            res[:]=res[:-2] 
n=len(data)
for cur in permutations(data):
    if not find:
        rec(1,[cur[0]])
    else:
        break
print(find)

#include <iostream>
#include <sstream>
#include <climits>
#include <vector>
#include <string>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <stack>
#include <queue>
#include <stdio.h>

using namespace std;

bool dfs(const vector<int>& nums, unordered_set<int>& s, int p, int pp, int M) {
	if (s.empty()) return (p + pp) == M;
    vector<int> v(s.begin(), s.end());
	for (auto i: v) {
        s.erase(i);
		if (dfs(nums, s, nums[i], p + pp, M)) return true;
		if (dfs(nums, s, -nums[i], p + pp, M)) return true;
		if (dfs(nums, s, p * nums[i], pp, M)) return true;
		if (dfs(nums, s, p / nums[i], pp, M)) return true;
        s.insert(i);
	}
	return false;
}

void solve(const vector<int>& nums, int M) {
    unordered_set<int> s{0, 1, 2, 3};
	bool res = dfs(nums, s, 0, 0, M);
	cout << (res ? 1 : 0) << endl;
}

int main() {
	vector<int> nums(4, 0);
	for (int i = 0; i < 4; ++i) {
		cin >> nums[i];
	}
	int M;
	cin >> M;
	solve(nums, M);
    return 0;
}

arr = list(map(int, input().split(" ")))
target = int(input())

expressions = []

def dfs(i, s):
	if(i == 4):
		expressions.append(s)
		return
	stemp = str(arr[i])
	dfs(i + 1, s + "+" + stemp)
	dfs(i + 1, s + "-" + stemp)
	dfs(i + 1, s + "*" + stemp)
	dfs(i + 1, s + "//" + stemp)

def solve():
	s = str(arr[0])
	expressions.clear()
	dfs(1, s)
	flag = True
	for e in expressions:
		if(eval(e) == target):
			return True
	return False

def Prim(i):
	if i == 4:
		if solve():
			return True
		else:
			return False
	k = i
	while k < 4:
		arr[k], arr[i] = arr[i], arr[k]
		if Prim(i + 1):
			return True
		arr[k], arr[i] = arr[i], arr[k]
		k += 1
	return False
	
if Prim(0):
	print("1")
else:
	print("0")

# -*- coding: utf-8 -*-
"""
Created on Mon Apr  1 00:54:31 2019
@author: Administrator
"""
data = [int (i) for i in input().split()]
m = int(input())
def f(n1,n2,op):
    if op=="+":
        return n1+n2
    elif op=="-":
        return n1-n2
    elif op=="*":
        return n1*n2
    elif op=="/":
        if n2 == 0:
            return -999999
        return n1//n2
def cal(data):
    flag = True 
    while flag:
        flag = False
        for i in range(len(data)):
            if data[i] in ["*","/"]:
#                print(data[i])
                data = data[0:i-1] + [f(data[i-1],data[i+1],data[i])] + data[i+2:]
                flag = True
                break          
    while len(data)>1:
        for i in range(len(data)):
            if data[i] in ["+","-"]:
                data = data[0:i-1] + [f(data[i-1],data[i+1],data[i])] + data[i+2:]
                break
#                print(data)
    return data[0]
        
#print(cal([1,"+",2,"-",5]))
flag = 0
def A(data):
    if len(data)==1:
        return [data]
    else:
        finalRes = []
        for i in range(len(data)):
            newData = data[0:i]+data[i+1:]
            res = A(newData)
            for j in range(len(res)):
                res[j].insert(0,data[i])
            finalRes.extend(res)
        return finalRes          
            
for op1 in ["+","-","*","/"]:
    for op2 in ["+","-","*","/"]:
        for op3 in ["+","-","*","/"]:
            for nums in A(data):
                res = cal([nums[0],op1,nums[1],op2,nums[2],op3,nums[3]])
                if res == m:
                    flag = 1
print(flag)