Codeforces Round #274 (Div. 1)——C. Riding in a Lift

C. Riding in a Lift

time limit per test

memory limit per test

input

output

Imagine that you are in a building that has exactly n floors. You can move between the floors in a lift. Let's number the floors from bottom to top with integers from 1 to n. Now you're on the floor number a. You are very bored, so you want to take the lift. Floor number b has a secret lab, the entry is forbidden. However, you already are in the mood and decide to make k

Let us suppose that at the moment you are on the floor number x (initially, you were on floor a). For another trip between floors you choose some floor with number y (y ≠ x) and the lift travels to this floor. As you cannot visit floor b with the secret lab, you decided that the distance from the current floor x to the chosen y must be strictly less than the distance from the current floor x to floor b with the secret lab. Formally, it means that the following inequation must fulfill: |x - y| < |x - b|. After the lift successfully transports you to floor y, you write down number y

Your task is to find the number of distinct number sequences that you could have written in the notebook as the result of k trips in the lift. As the sought number of trips can be rather large, find the remainder after dividing the number by 1000000007 (10⁹ + 7).

Input

The first line of the input contains four space-separated integers n, a, b, k (2 ≤ n ≤ 5000, 1 ≤ k ≤ 5000, 1 ≤ a, b ≤ n, a ≠ b).

Output

Print a single integer — the remainder after dividing the sought number of sequences by 1000000007 (10⁹ + 7).

Sample test(s)

Input

5 2 4 1

Output

2

Input

5 2 4 2

Output

2

Input

5 3 4 1

Output

0

Note

Two sequences p₁, p₂, ..., p_k and q₁, q₂, ..., q_k are distinct, if there is such integer j (1 ≤ j ≤ k), that p_j ≠ q_j.

Notes to the samples:

1. In the first sample after the first trip you are either on floor 1, or on floor 3, because |1 - 2| < |2 - 4| and |3 - 2| < |2 - 4|.
2. In the second sample there are two possible sequences: (1, 2); (1, 3). You cannot choose floor 3
3. In the third sample there are no sought sequences, because you cannot choose the floor for the first trip.

dp[i][j] 表示走了i次，当前在j的方案数

复杂度O(n^3)，利用前缀和来降低复杂度，最后复杂度是O(n^2)

#include <map>
#include <set>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int mod = 1000000007;
const int N = 5010;
__int64 sum[N];
__int64 dp[N][N];

int main()
{
	int n, a, b, k;
	while (~scanf("%d%d%d%d", &n, &a, &b, &k))
	{
		memset (dp, 0, sizeof(dp));
		dp[0][a] = 1;
		for (int i = 1; i <= k; i++)
		{
			memset (sum, 0, sizeof(sum));
			for (int j = 1; j <= n; j++)
			{
				sum[j] = sum[j - 1] + dp[i - 1][j];
				sum[j] %= mod;
			}
			for (int j = 1; j <= n; j++)
			{
				if (j == b)
				{
					continue;
				}
				if (j < b)
				{
					int t = (j + b) >> 1;
					if (t - j >= b - t)
					{
						t--;
					}
					dp[i][j] = sum[t] - dp[i - 1][j];
					dp[i][j] %= mod;
				}
				else
				{
					int t = (j + b) >> 1;
					if (j - t >= t - b)
					{
						t++;
					}
					dp[i][j] = sum[n] - sum[t - 1] - dp[i - 1][j];
					dp[i][j] %= mod;
				}
				if (dp[i][j] < 0)
				{
					dp[i][j] += mod;
					dp[i][j] %= mod;
				}
			}
		}
		__int64 ans = 0;
		for (int i = 1; i <= n; i++)
		{
			ans += dp[k][i];
			ans %= mod;
		}
		printf("%I64d\n", ans);
	}
	return 0;
}