Problem:
Score : 300 points

Problem Statement

Tak has N cards. On the i-th (1 \leq i \leq N) card is written an integer x_i.
He is selecting one or more cards from these N cards, so that the average of the integers written on the selected cards is exactly A.
In how many ways can he make his selection?

Constraints

1 \leq N \leq 50

1 \leq A \leq 50

1 \leq x_i \leq 50

N,\,A,\,x_i are integers.

Partial Score

200 points will be awarded for passing the test set satisfying 1 \leq N \leq 16.

Input

The input is given from Standard Input in the following format:

N A
x_1 x_2 ... x_N

Output

Print the number of ways to select cards such that the average of the written integers is exactly A.

Sample Input 1

4 8
7 9 8 9

Sample Output 1

5

The following are the 5 ways to select cards such that the average is 8:

Select the 3-rd card.

Select the 1-st and 2-nd cards.

Select the 1-st and 4-th cards.

Select the 1-st, 2-nd and 3-rd cards.

Select the 1-st, 3-rd and 4-th cards.

Sample Input 2

3 8
6 6 9

Sample Output 2

0

Sample Input 3

8 5
3 6 2 8 7 6 5 9

Sample Output 3

19

Sample Input 4

33 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3

Sample Output 4

8589934591

The answer may not fit into a 32-bit integer.

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

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

#define rep(i, n) REP(i, 0, n)
#define REP(i, k, n) for(int i = (int)k; i < (int)n; i++)
#define rrep(i, n) RREP(i, 0, n)
#define RREP(i, k, n) for(int i = (int)n-1; i > (int)k-1; i--)
#define mmax(start, end) *max_element(start, end)
#define mmin(start, end) *min_element(start, end)
#define ALL(x) (x).begin(), (x).end()
#define debug(x) cerr << #x << " " << x << endl;

typedef long long ll;

int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int dx8[8] = {-1, -1, -1, 0, 0, 1, 1, 1};
int dy8[8] = {-1, 0, 1, -1, 1, -1, 0, 1};

int N, A;
int x[51];
long long dp[51][51][2600];

int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);

    cin >> N >> A;
    REP(i,1,N+1) cin >> x[i];

    // int X = max(*max_element(x+1,x+N+1), A);

    dp[0][0][0] = 1;
    REP(xi,1,N+1) {
        rep(ch_n,xi+1) {
            rep(sum,2501) {
                if(sum<x[xi])
                    dp[xi][ch_n][sum] = dp[xi-1][ch_n][sum];
                else if(ch_n>=1)
                    dp[xi][ch_n][sum] = dp[xi-1][ch_n][sum] + dp[xi-1][ch_n-1][sum-x[xi]];
            }
        }
    }
    // rep(xi,N) {
    //     rep(ch_n,N) {
    //         rep(sum,2500) {
    //             if(dp[xi][ch_n][sum]) {
    //                 dp[xi+1][ch_n][sum] += dp[xi][ch_n][sum];
    //                 dp[xi+1][ch_n+1][sum+x[xi+1]] += dp[xi][ch_n][sum];
    //             }
    //         }
    //     }
    // }

    // rep(i,N+1) {
    //     cout << i << ":" << endl;
    //     rep(j,N+1) {
    //         rep(k,25) {
    //             cout << dp[i][j][k] << " ";
    //         } cout << endl;
    //     } cout << endl << endl;
    // }

    ll ans = 0;
    REP(ch_n,1,N+1)
        ans += dp[N][ch_n][A*ch_n];

    cout << ans << endl;
}