Problem:
ビーカー

いろいろな容量のビーカーが与えられています。はじめに、その中の一番容量の大きなビーカーを一個選び、蛇口から水をいっぱいになるまで注ぎます。つぎに、次のルールにしたがいながら、ビーカーの水を他のビーカーに移し替えていきます。

ビーカーに入っている水は,残さずにすべて他のビーカーに移さなければならない。ただし、一個のビーカーに水を全部移せないときは、複数のビーカーに分けて移してもよい。

ビーカーに水を入れるとき、いっぱいになるまで水を注がなければならない。また、水をこぼしてはならない。

複数のビーカーから同じビーカーに一度に水を注いではならない。

同じビーカーには一度しか水を注いではならない。

このルールにしたがったとき、ビーカーの個数 n と各ビーカーの容量を入力とし、すべてのビーカーに水を注ぐことができるかどうかを判定して出力するプログラムを作成してください。すべてのビーカーに水を注ぐことができるときは YES (半角英大文字)、できないときは NO (半角英大文字) を出力してください。

Input

複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。各データセットは以下の形式で与えられます。

n
c1 c2 ... cn

1 行目にビーカーの個数 n (1 ≤ n ≤ 50) が与えられます。２行目に i 番目のビーカーの容量を表す整数 ci (1 ≤ ci ≤ 100) が与えられます。

データセットの数は 105 を超えません。

Output

データセット毎に判定結果を１行に出力します。

Sample Input

10
11 2 23 4 2 12 8 5 2 10
8
2 1 3 11 2 3 1 4
9
5 9 1 2 4 8 17 1 8
8
3 38 9 4 18 14 19 5
1
1
0

Output for the Sample Input

YES
YES
YES
NO
YES

Solution in C++ (judge verdict: Memory Limit Exceeded)

#include <iostream>
#include <sstream>
#include <vector>
#include <list>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <algorithm>
#include <numeric>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
using namespace std;

typedef long long LL;
typedef set <LL> SET;

const int size = 51;

int B[size];
bool U[size];
bool F[size];
int n;
SET V[size];

bool dist( int a, int v, int s );
bool solve();

bool dist( int a, int v, int s ) {
    LL S = 0, T = 1;
    for ( int i = 0; i < s; ++ i ) {
        if ( F[i] ) S += T;
        T <<= 1;
    }
    if ( V[s].count( S ) ) return false;
    V[s].insert( S );
    for ( int i = a-1; i >= 0; -- i ) {
        if ( U[i] ) continue;
        if ( B[i] == v ) {
            F[i] = true;
            U[i] = true;
            bool flag = true;
            for ( int j = 0; j < n; ++ j ) {
                if ( ! U[j] ) flag = false;
            }
            if ( flag ) {
                return true;
            } else {
                if ( solve() ) {
                    return true;
                } else {
                    F[i] = false;
                    U[i] = false;
                }
            }
        } else if ( B[i] < v ) {
            F[i] = true;
            U[i] = true;
            if ( dist( i, v - B[i], s ) ) {
                return true;
            } else {
                F[i] = false;
                U[i] = false;
            }
        }
    }
    return false;
}

bool solve() {
    for ( int i = n - 1; i >= 0; -- i ) {
        if ( ! F[i] ) continue;
        F[i] = false;
        LL S = 0, T = 1;
        for ( int j = 0; j < i; ++ j ) {
            if ( F[j] ) S += T;
            T <<= 1;
        }
        if ( ! V[i].count( S ) && dist( i, B[i], i ) ) return true;
        F[i] = true;
    }
    return false;
}

int main() {
    while ( cin >> n && n ) {
        for ( int i = 0; i < n; ++ i ) {
            U[i] = false;
            F[i] = false;
            V[i].clear();
        }
        
        for ( int i = 0; i < n; ++ i ) cin >> B[i];
        sort( B, B + n );
        U[n-1] = F[n-1] = true;
        if ( n == 1 ) {
            cout << "YES" << endl;
        } else {
            cout << ( solve() ? "YES" : "NO" ) << endl;
        }
    }
    return 0;
}