Given a list of integers in order, return and expression with parenthesis, addition, or multiplication that result in a target value or return “impossible” if not possible
E.g.
input [2, 3, 4], target=20
Output: “(2+3)\*4”
This problem can be solved using a backtracking approach. We will try all possible combinations of operators (+, *) and parentheses to form an expression. Here is a Python solution for the problem:

```
def expression(nums, target):
    def dfs(i, path, value, last):
        if i == len(nums):
            if value == target:
                return path
            else:
                return None
        for j in range(i, len(nums)):
            if j == i:
                curr = nums[j]
            else:
                curr = last * 10 + nums[j]
            add = dfs(j + 1, path + '+' + str(curr), value + curr, curr)
            if add:
                return add
            mul = dfs(j + 1, path + '*' + str(curr), value - last + last * curr, curr)
            if mul:
                return mul
        return None

    res = dfs(0, '', 0, 0)
    if res:
        return res
    else:
        return "impossible"

print(expression([2, 3, 4], 20))  # Output: "2+3*4"
print(expression([1, 2, 3], 7))  # Output: "1+2*3"
print(expression([1, 2, 3], 10))  # Output: "impossible"
```

This solution tries all possible combinations of operators and parentheses
 To solve this problem, you can use a recursive approach with memoization to store the results of subproblems. The basic idea is to try all possible ways of combining the numbers using addition and multiplication, and return the expression that results in the target value.

Here's a possible implementation in Python:

```python
def expression_tree(nums, target, memo={}):
    if (tuple(nums), target) in memo:
        return memo[(tuple(nums), target)]
    if not nums:
        return "impossible"
    if len(nums) == 1:
        if nums[0] == target:
            return str(nums[0])
        else:
            return "impossible"
    for i in range(1, len(nums)):
        left_nums = nums[:i]
        right_nums = nums[i:]
        left_val = expression_tree(left_nums, 0, memo)
        right_val = expression_tree(right_nums, target - nums[i], memo)
        if left_val != "impossible" and right_val != "impossible":
            memo[(tuple(nums), target)] = "({} + {})*{}".format(left_val, num