poj3761

Bubble Sort
Time Limit: 1000MS Memory Limit: 65536K
Total Submissions: 2708 Accepted: 922
Description

Bubble sort is a simple sorting algorithm. It works by repeatedly stepping through the list to be sorted, comparing each pair of adjacent items and swapping them if they are in the wrong order. The pass through the list is repeated until no swaps are needed, which indicates that the list is sorted. The algorithm gets its name from the way smaller elements “bubble” to the top of the list. Because it only uses comparisons to operate on elements, it is a comparison sort.
­­­­­­­­­­ Wikipedia

Bubble Sort is a very simple sorting algorithm which runs in O(n2) time. Each round, we start from the beginning of the list, compare each adjacent pair of items in turn, swapping the items if necessary. Repeat the pass through the list, until no swaps are done. Assume that after exactly T rounds, the array is already in the ascending order, then we say that T is the number of Bubble Sort Rounds of this array. Below is an example: Let us take an array of numbers “5 1 4 2 8”, then we sort the array using Bubble Sort as follow:

First Round:
( 5 1 4 2 8 ) -> ( 1 5 4 2 8 ), Compares the first two elements, and swaps them.
( 1 5 4 2 8 ) -> ( 1 4 5 2 8 ), Swap since 5 > 4
( 1 4 5 2 8 ) -> ( 1 4 2 5 8 ), Swap since 5 > 2
( 1 4 2 5 8 ) -> ( 1 4 2 5 8 ), since these elements are already in order (8 > 5), algorithm does not swap them.
Second Round:
( 1 4 2 5 8 ) -> ( 1 4 2 5 8 )
( 1 4 2 5 8 ) -> ( 1 2 4 5 8 ), Swap since 4 > 2
( 1 2 4 5 8 ) -> ( 1 2 4 5 8 )
( 1 2 4 5 8 ) -> ( 1 2 4 5 8 )

After T = 2 rounds, the array is already sorted, hence we say that the number of Bubble Sort Rounds of this array is equal to 2.

ZX learns Bubble Sort in an algorithm class and his teacher leaves him a problem as homework. The teacher gives ZX an array A with N distinct numbers which is already sorted in ascending order and he tells ZX that this array is obtained after exactly K rounds of Bubble sort. The problem is: How many initial arrays there may be from which we can obtain the array A after exactly K rounds of Bubble Sort? The result may be very large, so you only need to output the answer mod 20100713. 　

Input

The input may contain several cases.
The first line contains an integer T (T ≤ 100,000), indicating the number of test cases.
Then T lines of test cases follow. For each line, it contains two integers N and K (1 ≤ N ≤ 1,000,000, 0 ≤ K ≤ N - 1) where N is the size of array and K is the number of Bubble Sort Rounds.
Output

For each line, output an integer which is the number of initial arrays mod 20100713.

Sample Input

3
3 0
3 1
3 2
Sample Output

1
3
2
Hint

Suppose the ordered array is {a, b, c} (a < b < c). For the 6 possible initial arrays:
{a, b, c}, {a, c, b}, {b, a, c}, {b, c, a}, {c, a, b}, {c, b, a},
we can get that:
{a, b, c}: already sorted, no bubble sort needed.
{a, c, b}, {b, a, c}, {c, a, b}: we need 1 round of Bubble Sort.
{b, c, a}, {c, b, a}: we need 2 rounds of Bubble Sort.
　
题意：给出一个长度为n的序列，要求进行k次冒泡排序使得最终结果为有序的序列的排列数。

思路：
对于前[1,n-k]个元素，他们可能通过1，2，…，k次冒泡排序才能够有序（每次冒泡排序使得逆序数减少1）。而对于最后的k个元素，他们并不需要k步才能到达有序，相反，在k步前就已经到达有序状态,所以最后k个随便排列就好，反正需要的冒泡次数不会超过k。
设f(n)为进行不超过n次冒泡排序到达最终的有序状态的排列数目。则ans=f(n)-f(n-1)=(k+1)^(n-k) * (k!)-(k)^(n-k)*(k!)

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
ll n,k;
const ll MOD=20100713;
ll fac[1000007];
void init()
{
    fac[0]=1;
    for(int i=1;i<=1000001;i++)
    {
        fac[i]=fac[i-1]*i;
        fac[i]%=MOD;
    }
}
ll  pow(ll a,ll b)
{
    ll res=1;
    while(b)
    {
        if(b&1)
        {
            res=(long long )res*a%MOD;
        }
        a=(long long )a*a%MOD;
        b/=2;
    }
    return res;
}

int main()
{
    init();
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%lld%lld",&n,&k);
    printf("%lld\n",((fac[k]*(pow(k+1,n-k)%MOD-pow(k,n-k)%MOD+MOD)%MOD+MOD)%MOD+MOD)%MOD);

//a
    }

    return 0;
}