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 numberb has a secret lab, the entry is forbidden. However, you already are in the mood and decide to make k consecutive trips in the lift.
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 in your notepad.
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 (109 + 7).
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).
Print a single integer — the remainder after dividing the sought number of sequences by 1000000007 (109 + 7).
5 2 4 1
2
5 2 4 2
2
5 3 4 1
0
#include <bits/stdc++.h>
#define maxn 5005
#define MOD 1000000007
using namespace std;
typedef long long ll;
ll dp[2][maxn];
int n, a, b, k;
int main(){
// freopen("in.txt", "r", stdin);
scanf("%d%d%d%d", &n, &a, &b, &k);
int e = 0;
dp[0][a] = 1;
while(k--){
memset(dp[e^1], 0, sizeof(dp[e^1]));
for(int i = 1; i <= n; i++){
if(dp[e][i] && abs(i-b) != 1){
int l, r;
if(i > b){
l = b + 1;
r = min(n,(i-b)+i-1);
if(i == n)
r = n - 1;
}
else{
r = b - 1;
l = max(1, i-(b-i)+1);
if(i == 1)
l = i + 1;
}
if(i < l || i > r){
(dp[e^1][l] += dp[e][i]) %= MOD;
((dp[e^1][r+1] -= dp[e][i]) += MOD) %= MOD;
}
else{
(dp[e^1][l] += dp[e][i]) %= MOD;
((dp[e^1][i] -= dp[e][i]) += MOD) %= MOD;
((dp[e^1][i+1] += dp[e][i]) += MOD) %= MOD;
((dp[e^1][r+1] -= dp[e][i]) += MOD) %= MOD;
}
}
}
e ^= 1;
for(int i = 1; i <= n; i++)
(dp[e][i] += dp[e][i-1]) %= MOD;
}
ll ans = 0;
for(int i = 1; i <= n; i++){
(ans += dp[e][i]) %= MOD;
}
printf("%I64d\n", ans);
return 0;
}