Problem:
Score : 600 points

Problem Statement

Given are a sequence of N positive integers A_1, A_2, \ldots, A_N and another positive integer S.

For a non-empty subset T of the set \{1, 2, \ldots , N \}, let us define f(T) as follows:

f(T) is the number of different non-empty subsets \{x_1, x_2, \ldots , x_k \} of T such that A_{x_1}+A_{x_2}+\cdots +A_{x_k} = S.

Find the sum of f(T) over all 2^N-1 subsets T of \{1, 2, \ldots , N \}. Since the sum can be enormous, print it modulo 998244353.

Constraints

All values in input are integers.

1 \leq N \leq 3000

1 \leq S \leq 3000

1 \leq A_i \leq 3000

Input

Input is given from Standard Input in the following format:

N S
A_1 A_2 ... A_N

Output

Print the sum of f(T) modulo 998244353.

Sample Input 1

3 4
2 2 4

Sample Output 1

6

For each T, the value of f(T) is shown below. The sum of these values is 6.

f(\{1\}) = 0

f(\{2\}) = 0

f(\{3\}) = 1 (One subset \{3\} satisfies the condition.)

f(\{1, 2\}) = 1 (\{1, 2\})

f(\{2, 3\}) = 1 (\{3\})

f(\{1, 3\}) = 1 (\{3\})

f(\{1, 2, 3\}) = 2 (\{1, 2\}, \{3\})

Sample Input 2

5 8
9 9 9 9 9

Sample Output 2

0

Sample Input 3

10 10
3 1 4 1 5 9 2 6 5 3

Sample Output 3

3296

Solution in C++ (GCC 9.2.1) (judge verdict: Wrong Answer)

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef unsigned long long ull;

class ModInt{
public:
    ModInt(){
        x = 0;
    }
    ModInt(int v){
        x = (((v % mod) + mod) % mod);
    }
    ModInt(long long v){
        x = (((v % mod) + mod) % mod);
    }
    ModInt(unsigned long long v){
        x = (((v % mod) + mod) % mod);
    }

    ModInt operator-() const {return ModInt(-x);}
    ModInt& operator+=(const ModInt& a){
        x = (x + a.x) % mod;
        return *this;
    }
    ModInt& operator-=(const ModInt& a){
        x = (x + mod - a.x) % mod;
        return *this;
    }
    ModInt& operator*=(const ModInt& a){
        x = (x * a.x) % mod;
        return *this;
    }
    ModInt operator+(const ModInt& a) const{
        ModInt res(*this);
        res += a;
        return res;
    }
    ModInt operator-(const ModInt& a) const{
        ModInt res(*this);
        res -= a;
        return res;
    }
    ModInt operator*(const ModInt& a) const{
        ModInt res(*this);
        res *= a;
        return res;
    }
    ModInt power(long long a) const{
        if(a == 0) return 1;
        auto b = power(a >> 1);
        b *= b;
        if(a & 1) b *= *this;
        return b;
    }
    ModInt inverse() const{
        return power(mod - 2);
    }
    ModInt& operator/=(const ModInt& a){
        (*this) *= a.inverse();
        return *this;
    }
    ModInt operator/(const ModInt& a)const{
        ModInt res(*this);
        res /= a;
        return res;
    }
    friend ostream& operator<<(ostream& os, const ModInt& a){
        os << a.x;
        return os;
    }

    static ModInt add(long long a, long long b){
        ModInt res(a);
        res += b;
        return res;
    }

    static long long get_mod(){ return mod;}

private:
    static const long long mod = 998244353;
    long long x;
};

int main()
{
    int N, S;
    cin >> N >> S;
    vector<int> A(N);
    for(int i=0;i<N;i++){
        cin >> A[i];
    }
    sort(A.begin(), A.end());
    vector<map<int, int>> dp(S+1, map<int, int>());
    dp[0][0] = 1;
    for(int i=0; i<N; i++){
        for(int j=S; j>=0; j--){
            if(j + A[i] > S) continue;
            for(auto m : dp[j]){
                auto k = m.first;
                if(dp[j+A[i]].count(k+1)==0) dp[j+A[i]][k+1] = 0;
                dp[j+A[i]][k+1] += dp[j][k];
            }
        }
    }
    ModInt res(0);
    for(auto m : dp[S]){
        auto k = m.first;
        res += ModInt(2).power(N-k) * dp[S][k];
    }
    cout << res << endl;

    return 0;
}