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: Accepted)

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace AtCoder.ABC113.D
{
    class Program
    {
        static void Main()
        {
            var sc = new Scanner();
            var H = sc.Nextint();
            var W = sc.Nextint();
            var K = sc.Nextint() - 1;
            var mod = (long) 1e9 + 7;

            var modPatterns = new long[H, W];
            for (int i = H - 1; i >= 0; i--)
            {
                for (int j = 0; j < W; j++)
                {
                    if (i == H - 1)
                    {
                        if (j == K)
                        {
                            modPatterns[i, j] = NumOfPatterns(W, j);
                        }
                        else if (Math.Abs(j - K) == 1)
                        {
                            modPatterns[i, j] = NumOfPatterns(W, j, K);
                        }
                    }
                    else
                    {
                        modPatterns[i, j] = (NumOfPatterns(W, j)) * modPatterns[i + 1, j];
                        if (j != 0) modPatterns[i, j] += NumOfPatterns(W, j, j - 1) * modPatterns[i + 1, j - 1];
                        if (j != W - 1) modPatterns[i, j] += NumOfPatterns(W, j, j + 1) * modPatterns[i + 1, j + 1];
                    }
                    modPatterns[i, j] %= mod;
                }
            }
            if (modPatterns[0, 0] == 0) modPatterns[0, 0] = 1;
            Console.WriteLine(modPatterns[0, 0]);
        }

        static long NumOfPatterns(int w, int a, int b = -1)
        {
            if (b == -1) return Count(a) * Count(w - a - 1);
            else return Count(Math.Min(a, b)) * Count(w - Math.Max(a, b) - 1);
        }
        static long Count(int num)
        {
            return FibonacciSequence().Take(num + 2).Last();
        }

        public static IEnumerable<long> FibonacciSequence()
        {
            var a = 0L;
            var b = 1L;
            while (true)
            {
                yield return a;
                yield return b;
                a += b;
                b += a;
            }
        }
    }

    class Scanner
    {
        string[] s;
        long i;

        char[] cs = new char[] { ' ' };

        public Scanner()
        {
            s = new string[0];
            i = 0;
        }

        public string Next()
        {
            if (i < s.Length) return s[i++];
            string st = Console.ReadLine();
            while (st == "") st = Console.ReadLine();
            s = st.Split(cs, StringSplitOptions.RemoveEmptyEntries);
            if (s.Length == 0) return Next();
            i = 0;
            return s[i++];
        }

        public int Nextint()
        {
            return int.Parse(Next());
        }
        public int[] Arrayint(int N, int add = 0)
        {
            int[] Array = new int[N];
            for (int i = 0; i < N; i++)
            {
                Array[i] = Nextint() + add;
            }
            return Array;
        }

        public long NextLong()
        {
            return long.Parse(Next());
        }

        public long[] ArrayLong(int N, long add = 0)
        {
            long[] Array = new long[N];
            for (long i = 0; i < N; i++)
            {
                Array[i] = NextLong() + add;
            }
            return Array;
        }

        public double NextDouble()
        {
            return double.Parse(Next());
        }

        public double[] ArrayDouble(long N, double add = 0)
        {
            double[] Array = new double[N];
            for (long i = 0; i < N; i++)
            {
                Array[i] = NextDouble() + add;
            }
            return Array;
        }

        public decimal NextDecimal()
        {
            return decimal.Parse(Next());
        }

        public decimal[] ArrayDecimal(long N, decimal add = 0)
        {
            decimal[] Array = new decimal[N];
            for (long i = 0; i < N; i++)
            {
                Array[i] = NextDecimal();
            }
            return Array;
        }
    }
}