有n个数，使用加减乘除和括号，使得最终的结果等于m，请列出所有的可能性

问题

有n个数，使用加减乘除和括号，使得最终的结果等于m，请列出所有的可能性

Java算法

import java.util.*;

/**
 * there are some number, use + - * / and ( ), to get all the solution which can get the result target number
 */
public class Test015 {
    public static void main(String[] args) {
        print(new Test015().getResult(new int[] {3, 3, 3, 3}, 7));
    }

    public Test015() {
    }

    public Set<String> getResult(int[] nums, int target) {
        Map<Integer, Set<String>> result = func(nums, 0, nums.length - 1);
        return result.getOrDefault(target, null);
    }

    public Map<Integer, Set<String>> func (int[] nums, int start, int end) {
        // end condition
        if (start == end) {
            Map<Integer, Set<String>> result = new HashMap<>();
            result.put(nums[start], new HashSet<>(Arrays.asList(String.valueOf(nums[start]))));
            return result;
        }

        Map<Integer, Set<String>> result = new HashMap<>();
        for (int i = start; i < end; i++) {
            Map<Integer, Set<String>> left = func(nums, start, i);
            Map<Integer, Set<String>> right = func(nums, i + 1, end);
            for (Integer leftKey : left.keySet()) {
                Set<String> leftValues = left.get(leftKey);
                for (Integer rightKey : right.keySet()) {
                    Set<String> rightValues = right.get(rightKey);
                    updateResult(result, leftValues, rightValues, leftKey, rightKey, 1);
                    updateResult(result, leftValues, rightValues, leftKey, rightKey, 2);
                    updateResult(result, leftValues, rightValues, leftKey, rightKey, 3);

                    if (rightKey == 0 || leftKey % rightKey != 0) {
                        continue;
                    }
                    updateResult(result, leftValues, rightValues, leftKey, rightKey, 4);
                }
            }
        }

        return result;
    }

    private void updateResult(Map<Integer, Set<String>> result, Set<String> leftValues, Set<String> rightValues, Integer leftKey, Integer rightKey, int type) {
        int operateResult = getOperateResult(leftKey, rightKey, type);
        Set<String> v = result.getOrDefault(operateResult, new HashSet<>());
        for (String leftValue : leftValues) {
            for (String rightValue : rightValues) {
                v.add("(" + leftValue + getOperatorString(type) + rightValue + ")");
            }
        }
        result.put(operateResult, v);
    }

    private int getOperateResult(int num1, int num2, int type) {
        int result = 0;
        switch (type) {
            case 1:
                result = num1 + num2;
                break;
            case 2:
                result = num1 - num2;
                break;
            case 3:
                result = num1 * num2;
                break;
            case 4:
                result = num1 / num2;
                break;
            default:
                throw new RuntimeException("not support type" + type);
        }
        return result;
    }

    private String getOperatorString(int type) {
        String result = "";
        switch (type) {
            case 1:
                result = "+";
                break;
            case 2:
                result = "-";
                break;
            case 3:
                result = "*";
                break;
            case 4:
                result = "/";
                break;
            default:
                throw new RuntimeException("not support type" + type);
        }
        return result;
    }

    /* default */
    public static <T> void print(T t) {
        System.out.println(t);
    }
}