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# (Mono 4.6.2.0) (judge verdict: Time Limit Exceeded)

using System;
using System.Linq;
using System.Numerics;

namespace AtCoder.ABC044
{
    class ProblemC
    {
        private static int[] Cards;
        private static int N;
        private static int A;
        private static int[] RemainingSum;
        private static BigInteger[,] ProCahce;

        static void Main()
        {
            var fraction = new BigInteger[51];
            fraction[0] = 1;
            for (var i = 1; i < fraction.Length; i++)
            {
                fraction[i] = fraction[i - 1] * i;
            }
            ProCahce = new BigInteger[51, 51];
            for (var i = 1; i < ProCahce.GetLength(0); i++)
            {
                for (var j = 1; j <= i; j++)
                {
                    ProCahce[i, j] = fraction[i] / fraction[j] / fraction[i - j];
                }
            }

            var na = ReadIntArray();
            N = na[0];
            A = na[1];
            var values = ReadIntArray();
            Cards = new int[51];
            for (var i = 0; i < Cards.Length; i++)
            {
                Cards[i] = values.Count(v => v == i);
            }

            RemainingSum = new int[N + 1];
            values = values.OrderByDescending(v => v).ToArray();
            for (var i = 1; i <= N; i++)
            {
                RemainingSum[i] = values.Take(i).Sum();
            }

            BigInteger p = 0;
            for (var i = 1; i <= N; i++)
            {
                //Console.WriteLine($"{i}=>{Recv(0, 0, i * A, i)}");
                p += Recv(0, 0, i * A, i);
            }
            Console.WriteLine(p);
        }

        private static BigInteger Recv(int index, int sum, int dst, int remaining)
        {
            BigInteger pattern = 0;
            if (RemainingSum[remaining] < dst - sum)
            {
                //Console.WriteLine($"remaining:{remaining}:{dst} {sum}");
                return 0;
            }
            for (var i = index; i < Cards.Length; i++)
            {
                if (Cards[i] == 0) continue;


                if (Cards[i] >= remaining && sum + i * remaining == dst)
                {
                    pattern += ProCahce[Cards[i], remaining];
                }
                for (var j = 1; j <= Math.Min(Math.Min(Cards[i], remaining - 1), (dst - sum) / i); j++)
                {
                    var pro = ProCahce[Cards[i], j];
                    var p = Recv(i + 1, sum + i * j, dst, remaining - j);
                    pattern += p * pro;
                }
            }
            return pattern;
        }


        public static string ReadLine() => Console.ReadLine();

        public static int ReadInt() => int.Parse(ReadLine());

        public static int[] ReadIntArray() => ReadLine().Split(' ').Select(v => int.Parse(v)).ToArray();
    }
}