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: Runtime Error)

using System;
using System.Linq;
using System.Collections.Generic;
using System.Numerics;

namespace ABC044_C
{
    class Program
    {
        private static int[] Cards;
        private static int N;
        private static int A;
        private static int[] RemainingSum;
        private static int[] RemainingCard;
        private static BigInteger[,] ProCahce;
        private static int[] Counts;

        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();
            //N = 24;
            //A = 6;
            //var values = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, };

            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();
            }
            RemainingCard = new int[51];
            for (var i = 0; i < Cards.Length; i++)
            {
                RemainingCard[i] = Cards.Skip(i).Sum();
            }

            var sw = new System.Diagnostics.Stopwatch();
            //sw.Start();
            BigInteger p = 0;
            for (var i = 1; i <= N; i++)
            {
                //Counts = new int[5];
                //var temp = Recv(0, 0, i * A, i);
                //Console.WriteLine($"Count{i}:{string.Join(",", Counts)} => {temp}");

                p += Recv(0, 0, i * A, i);
            }
            //sw.Stop();
            //Console.WriteLine($"time:{sw.ElapsedMilliseconds}");
            Console.WriteLine(p);
        }

        private static BigInteger Recv(int index, int sum, int dst, int remaining)
        {
            //if (index == 0) Console.WriteLine($"{index} {sum} {dst} {remaining}");
            //Counts[0]++;
            if (RemainingSum[remaining] < dst - sum)
            {
                //Counts[1]++;
                //Console.WriteLine($"remaining:{remaining}:{dst} {sum}");
                return 0;
            }
            if ( RemainingCard[index] < remaining)
            {
                //Counts[2]++;
                return 0;
            }

            BigInteger pattern = 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(Cards[i], remaining - 1); j++)
                {
                    var p = Recv(i + 1, sum + i * j, dst, remaining - j);
                    if (p != 0)
                    {
                        //Counts[3]++;
                        pattern += p * ProCahce[Cards[i], j];
                    }
                }
            }
            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();
    }
}