Problem:
Score: 400 points

Problem Statement

Amidakuji is a traditional method of lottery in Japan.

To make an amidakuji, we first draw W parallel vertical lines, and then draw horizontal lines that connect them. The length of each vertical line is H+1 [cm], and the endpoints of the horizontal lines must be at 1, 2, 3, ..., or H [cm] from the top of a vertical line.

A valid amidakuji is an amidakuji that satisfies the following conditions:

No two horizontal lines share an endpoint.

The two endpoints of each horizontal lines must be at the same height.

A horizontal line must connect adjacent vertical lines.

Find the number of the valid amidakuji that satisfy the following condition, modulo 1\ 000\ 000\ 007: if we trace the path from the top of the leftmost vertical line to the bottom, always following horizontal lines when we encounter them, we reach the bottom of the K-th vertical line from the left.

For example, in the following amidakuji, we will reach the bottom of the fourth vertical line from the left.

Constraints

H is an integer between 1 and 100 (inclusive).

W is an integer between 1 and 8 (inclusive).

K is an integer between 1 and W (inclusive).

Input

Input is given from Standard Input in the following format:

H W K

Output

Print the number of the amidakuji that satisfy the condition, modulo 1\ 000\ 000\ 007.

Sample Input 1

1 3 2

Sample Output 1

1

Only the following one amidakuji satisfies the condition:

Sample Input 2

1 3 1

Sample Output 2

2

Only the following two amidakuji satisfy the condition:

Sample Input 3

2 3 3

Sample Output 3

1

Only the following one amidakuji satisfies the condition:

Sample Input 4

2 3 1

Sample Output 4

5

Only the following five amidakuji satisfy the condition:

Sample Input 5

7 1 1

Sample Output 5

1

As there is only one vertical line, we cannot draw any horizontal lines. Thus, there is only one amidakuji that satisfies the condition: the amidakuji with no horizontal lines.

Sample Input 6

15 8 5

Sample Output 6

437760187

Be sure to print the answer modulo 1\ 000\ 000\ 007.

Solution in C# (Mono 4.6.2.0) (judge verdict: Time Limit Exceeded)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ProconExpt181108
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] sl = Console.ReadLine().Split(' ');
            int H = int.Parse(sl[0]);
            int W = int.Parse(sl[1]);
            int K = int.Parse(sl[2]);

            //CalcAmida(2, 3, 1);
            CalcAmida(H, W, K);

            Console.ReadLine();

        }

        static void CalcAmida(int H,int W, int K)
        {
            Amida ami = new Amida(H, W, K);

            ulong lTotal = ami.CalcTotal();
            
            Console.WriteLine(lTotal % 1000000007);
        }


        
    }

    class Amida
    {
        int H;
        int W;
        int K;

        int PlaMax;
        int MinusMax;
        int ZeroMax;
        int[] aiPattern;

        ulong[] aiFibon;

        public Amida(int a_H, int a_W, int a_K)
        {
            H = a_H;
            W = a_W;
            K = a_K;
            aiPattern = new int[H];

            //フィボナッチ数列を計算しておく
            aiFibon = new ulong[W];
            aiFibon[0] = 1;
            if (W > 1) aiFibon[1] = 2;

            for (int i = 2; i < W; i++)
            {
                aiFibon[i] = aiFibon[i-1] + aiFibon[i-2];
            }
        }

        public ulong CalcTotal()
        {
            ulong lTotal = 0;

            for (int iPla = K - 1; iPla <= (H + K - 1) / 2; iPla++)
            {
                PlaMax = iPla;
                MinusMax = iPla - K + 1;
                ZeroMax = H - PlaMax - MinusMax;

                lTotal += CalcPatterns(0,0,0,0);
            }

            return lTotal;
        }

        ulong CalcPatterns(int PlaCur, int MinusCur, int ZeroCur, int iCurIdx)
        {

            if (iCurIdx == aiPattern.Length)
            {
                return CalcCurrentPattern();
            }

            ulong lCalc = 0;

            if (PlaCur < PlaMax && PlaCur - MinusCur < W - 1)
            {
                aiPattern[iCurIdx] = 1;
                lCalc += CalcPatterns(PlaCur + 1, MinusCur, ZeroCur, iCurIdx + 1);
            }
            if (MinusCur < MinusMax && PlaCur - MinusCur > 0)
            {
                aiPattern[iCurIdx] = -1;
                lCalc += CalcPatterns(PlaCur, MinusCur+1, ZeroCur, iCurIdx + 1);
            }
            if (ZeroCur < ZeroMax)
            {
                aiPattern[iCurIdx] = 0;
                lCalc += CalcPatterns(PlaCur, MinusCur, ZeroCur + 1, iCurIdx + 1);
            }

            return lCalc % 1000000007;
        }

        ulong CalcCurrentPattern()
        {
            ulong lCalc = 1;
            int iPos = 0;

            for (int iRow = 0; iRow < aiPattern.Length ; iRow++)
            {
                int iLeft = aiPattern[iRow] == -1 ? iPos - 2 : iPos - 1;
                if (iLeft < 0) iLeft = 0;
                int iRight = aiPattern[iRow] == 1 ? (W - iPos - 3) : (W - iPos - 2);
                if (iRight < 0) iRight = 0;

                lCalc *= aiFibon[iLeft];
                lCalc *= aiFibon[iRight];

                iPos += aiPattern[iRow];
            }

            return lCalc;
        }

        
    }

}