51NOD--1020 逆序排列--动态规划求逆序排列数+归并排序求逆序数

1020 逆序排列

1. 2.0 秒
2.  
3. 131,072.0 KB
4.  
5. 40 分
6.  
7. 4级题

在一个排列中，如果一对数的前后位置与大小顺序相反，即前面的数大于后面的数，那么它们就称为一个逆序。一个排列中逆序的总数就称为这个排列的逆序数。

如2 4 3 1中，2 1，4 3，4 1，3 1是逆序，逆序数是4。

1-n的全排列中，逆序数最小为0（正序），最大为n*(n-1) / 2（倒序）

给出2个数n和k，求1-n的全排列中，逆序数为k的排列有多少种？

例如：n = 4 k = 3。

1 2 3 4的排列中逆序为3的共有6个，分别是：

1 4 3 2

2 3 4 1

2 4 1 3

3 1 4 2

3 2 1 4

4 1 2 3

 

由于逆序排列的数量非常大，因此只需计算并输出该数 Mod 10^9 + 7的结果就可以了。

 收起

输入

第1行：一个数T，表示后面用作输入测试的数的数量。（1 <= T <= 10000)
第2 - T + 1行：每行2个数n，k。中间用空格分隔。（2 <= n <= 1000, 0 <= k <= 20000)

输出

共T行，对应逆序排列的数量 Mod (10^9 + 7)

输入样例

1
4 3

输出样例

6

dpij表示1-i个数中j个逆序数的排列总数。那么在前i-1个数中插入一个数i，那么多出来的逆序对数可能为0,1,2，...，i-1。最多是i-1。那么dp[i][j]=dp[i-1][j]+dp[i-1][j-1]+dp[i-1][j-2]+...+dp[i-1][j-(i-1)]。接着推出另一个公式，dp[i][j-1]=dp[i-1][j-1]+dp[i-1][j-1-1]+...+dp[i-1][j-1-(i-1)]。两个式子相减，得出转移方程。

dp[i][j]=(dp[i][j-1]+dp[i-1][j])%mod;
            if(j>=i)
                dp[i][j]=((dp[i][j]-dp[i-1][j-i])%mod+mod)%mod;

#include<bits/stdc++.h>
using namespace std;
const int mod=1e9+7;
#define maxn 100000+66
int dp[1006][20006];
int main()
{
    int t;
    scanf("%d",&t);
    for(int i=1; i<=1000; i++)
        dp[i][0]=1;
    for(int i=2; i<=1000; i++)
    {
        for(int j=1; j<=20000&&j<=i*(i+1)/2; j++)
        {
            dp[i][j]=(dp[i][j-1]+dp[i-1][j])%mod;
            if(j>=i)
                dp[i][j]=((dp[i][j]-dp[i-1][j-i])%mod+mod)%mod;
        }
    }
    while(t--)
    {
        int n,m;
        scanf("%d%d",&n,&m); 
        //1-n序列m逆序数的排列数
        printf("%d\n",dp[n][m]);
    }
    return 0;
}

归并排序求一个序列的逆序数

#include <bits/stdc++.h>

using namespace std;

long long int cnt;
int a[104000];
int *b;
void Merge(int a[], int low, int mid, int high);
void Merge_sort(int a[], int low, int high);//归并排序

int main()
{
    int n, i;
    scanf("%d", &n);
    for(i = 0; i < n; i++)
        scanf("%d", &a[i]);
    b = new int[n];
    cnt = 0;
    Merge_sort(a, 0, n-1);
    delete[] b;
    printf("%lld\n", cnt);
    return 0;
}
void Merge_sort(int a[], int low, int high)
{
    int mid;
    if(low < high)
    {
        mid = (low + high)/2;
        Merge_sort(a, low, mid);
        Merge_sort(a, mid+1, high);
        Merge(a, low, mid, high);
    }
}
void Merge(int a[], int low, int mid, int high) //可类比两组有序链表的归并，思想基本一样
{
    int i = low;
    int j = mid + 1;
    int k = 0;
    //int *b = new int[high-low+1];///动态申请内存
    while(i <= mid && j <= high)
    {
        if(a[i] <= a[j])
            b[k++] = a[i++];
        else
        {
            b[k++] = a[j++];
            cnt += (mid - i + 1);
//归并两组有序数据，当a[i] > a[j], 则在区间[i, mid]的数据全部大于a[j],此时对于a[j]的逆序数为(mid - i + 1)
        }
    }
    while(i <= mid)
    {
        b[k++] = a[i++];
    }
    while(j <= high)
    {
        b[k++] = a[j++];
    }
    for(k = 0, i = low; i <= high; i++, k++)
    {
        a[i] = b[k];
    }
}