Problem:
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

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[0] + A[2].

Solution in C# (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;

namespace Aoj.ALDS.Chapter5A
{
    class Program
    {
        public static List<int> ns;
        public static List<int> ms;
        public static int n;
        public static int q;
        public static Dictionary<int, bool>[] dp;

        // ??\????????????????????°??§??´????????????????????°?????????
        // public static bool Solve(int current, int answer, int i)
        // {
        //     if (current == answer)
        //         return true;

        //     if (i == n)
        //         return false;

        //     return Solve(current, answer, i + 1) || Solve(current + ns[i], answer, i + 1);
        // }

        // public static void Main()
        // {
        //     // Console.SetIn(new System.IO.StreamReader("Aoj/AlgorithmsAndDataStructures/Input/05_Recursion_A_01.txt"));
        //     // var sw = new Stopwatch();
        //     // sw.Start();

        //     n = int.Parse(Console.ReadLine());
        //     ns = Array.ConvertAll(Console.ReadLine().Split(' '), int.Parse).ToList();

        //     q = int.Parse(Console.ReadLine());
        //     ms = Array.ConvertAll(Console.ReadLine().Split(' '), int.Parse).ToList();

        //     for (int i = 0; i < q; i++)
        //     {
        //         bool result = Solve(0, ms[i], 0);
        //         Console.WriteLine(result ? "yes" : "no");
        //     }

        //     // Console.WriteLine("{0}ms", sw.ElapsedMilliseconds);
        // }

        // ??\?????????????¨??????????????????§??????
        public static bool Solve(int current, int answer, int i)
        {
            if (dp[i].ContainsKey(current))
                return dp[i][current];
            
            if (current == answer)
                dp[i][current] = true;
            else if (i == n)
                dp[i][current] = false;
            else if (Solve(current, answer, i + 1))
                dp[i][current] = true;
            else if (Solve(current + ns[i], answer, i + 1))
                dp[i][current] = true;
            else
                dp[i][current] = false;

            return dp[i][current];
        }

        public static void Main()
        {
            // Console.SetIn(new System.IO.StreamReader("Aoj/AlgorithmsAndDataStructures/Input/05_Recursion_A_01.txt"));
            // var sw = new Stopwatch();
            // sw.Start();

            n = int.Parse(Console.ReadLine());
            ns = Array.ConvertAll(Console.ReadLine().Split(' '), int.Parse).ToList();

            q = int.Parse(Console.ReadLine());
            ms = Array.ConvertAll(Console.ReadLine().Split(' '), int.Parse).ToList();

            // 0 ~ n???(n+1)??????????´????????????????????????¨?????¨?????????????????????????????¨?????????
            dp = new Dictionary<int, bool>[n + 1];
            for (int i = 0; i <= n; i++)
            {
                dp[i] = new Dictionary<int, bool>();
            }

            for (int i = 0; i < q; i++)
            {
                for (int j = 0; j <= n; j++)
                {
                    dp[j].Clear();
                }

                bool result = Solve(0, ms[i], 0);
                Console.WriteLine(result ? "yes" : "no");
            }

            // Console.WriteLine("{0}ms", sw.ElapsedMilliseconds);
        }
    }
}