The first topic of AOJ's divide-and-conquer recursion is:

# Exhaustive Search

Write a program which reads a sequence A of n elements and an integer M, and outputs "yes" if you can make M by adding elements in A, otherwise "no". You can use an element only once.

You are given the sequence A and q questions where each question contains Mi.

## Input

In the first line n is given. In the second line, n integers are given. In the third line q is given. Then, in the fourth line, q integers (Mi) are given.

## Output

For each question Mi, print yes or no.

## Constraints

• n ≤ 20
• q ≤ 200
• 1 ≤ elements in A ≤ 2000
• 1 ≤ Mi ≤ 2000

## Sample Input 1

```5
1 5 7 10 21
8
2 4 17 8 22 21 100 35
```

## Sample Output 1

```no
no
yes
yes
yes
yes
no
no```

It is obvious that the idea of dividing and conquering recursion, without looking at notes at the beginning, can not be done for two days or A, mainly exhaustion is not complete, and the termination conditions of recursion are relatively vague.

Look at notes:

## Notes

You can solve this problem by a Burte Force approach. Suppose solve(p, t) is a function which checkes whether you can make t by selecting elements after p-th element (inclusive). Then you can recursively call the following functions:

solve(0, M)
solve(1, M-{sum created from elements before 1st element})
solve(2, M-{sum created from elements before 2nd element})
...

The recursive function has two choices: you selected p-th element and not. So, you can check solve(p+1, t-A[p]) and solve(p+1, t) in solve(p, t) to check the all combinations.

For example, the following figure shows that 8 can be made by A + A. As soon as you see, it turns out that this is how to determine the recursive condition. By subtracting the listed cases and judging whether the recursive termination is zero or not, it's very simple to think of (I'm still too busy).

Look at my codes:

```#include <iostream>
using namespace std;
int n;

bool slove(int *A,int k, int m){
if(m==0)
return true;
if(m<0||k==n)
return false;
return slove(A,k+1,m-A[k])||slove(A, k+1, m);

}

int main(){

//	int n;
cin>>n;
int A[n];
for(int i=0;i<n;i++)
cin>>A[i];

int q;
cin>>q;
int M[q];
for(int i=0;i<q;i++){
cin>>M[i];
if((slove(A, 0, M[i]))==true)
cout<<"yes"<<endl;
else
cout<<"no"<<endl;
}

return 0;
}```