多排列的最大逆序数问题

[题目]

题目链接:Minimum Inversion Number

[分析]

首先介绍一下逆序数的概念:在一个排列中,如果一对数的前后位置与大小顺序相反,即前面的数大于后面的数,那么它们就称为一个逆序。一个排列中逆序的总数就称为这个排列的逆序数。逆序数为偶数的排列称为偶排列;逆序数为奇数的排列称为奇排列。如2431中,21,43,41,31是逆序,逆序数是4,为偶排列。

应用线段树数据结构,将复杂度降到 O(nlogn) ,首先求初始状态下的逆序数。在构造完线段树后(见下面程序中的build()函数),根据输入的数据x,累加区间[x,n](也即已经输入的并且比x大的数的个数)的和,然后更新对应叶节点的值,由0变为1,表示这个数已经输入,并递归更新父节点(等于左右儿子节点值得和)。

在求出初始状态下的逆序数num后,在每次将第一个数移动到最后的过程中,逆序数的变化有一下递推公式:

num=numinput[i]+(ninput[i]1)

其中num为初始状态下的逆序数,input为输入的数组,n为输入数据的总数。

AC的代码如下:

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

#define MAX 5010
int tree[MAX<<2];
int input[MAX];

void build(int l, int r, int rt){
    if(l == r){
        tree[rt] = 0;
        return;
    }
    int m = (l+r)/2;
    build(l,m,rt<<1);
    build(m+1,r,(rt<<1)+1);
    tree[rt] = 0;
}

void update(int p, int l, int r, int rt){
    if(l == r){
        tree[rt]=1;
        return;
    }
    int m = (l+r)/2;
    if(p<=m)
        update(p,l,m,rt<<1);
    else
        update(p,m+1,r,(rt<<1)+1);
    tree[rt] = tree[rt<<1] + tree[(rt<<1)+1];
}

int getSum(int L, int R, int l, int r, int rt){
    if(L<=l && r <=R)
        return tree[rt];
    int ret = 0;
    int m = (l+r)/2;
    if(L<=m)
        ret += getSum(L,R,l,m,rt<<1);
    if(R>m)
        ret += getSum(L,R,m+1,r,(rt<<1)+1);
    return ret;
}

int main(){
    freopen("in.txt","r",stdin);
    int n;
    while(scanf("%d",&n) != EOF){
        memset(tree,0,sizeof(tree));
        int ans = 0;
        for(int i=0; i<n; i++){
            scanf("%d",&input[i]);
            ans += getSum(input[i]+1,n,1,n,1);
            update(input[i]+1,1,n,1);
        }
        int num = ans;
        for(int i=0; i<n-1; i++){
            num = num-input[i]+(n-input[i]-1);
            if(num < ans)
                ans = num;
        }
        cout<<ans<<endl;
    }
    return 0;
} 

使用树状数组数据结构会更加方便,AC代码如下:

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

#define MAX 5010
int tree[MAX<<2];
int input[MAX];
int n;

int lowbit(int x){
    return x&(-x);
} 

void update(int i){
    while(i<=n){
        tree[i]++;
        i += lowbit(i);
    }
}

int getSum(int i){
    int s=0;
    while(i>0){
        s += tree[i];
        i -= lowbit(i);
    }
    return s;
}

int main(){
    freopen("in.txt","r",stdin);
    while(scanf("%d",&n) != EOF){
        memset(tree,0,sizeof(tree));
        int ans = 0;
        for(int i=0; i<n; i++){
            scanf("%d",&input[i]);
            ans = ans + getSum(n) - getSum(input[i]+1);
            update(input[i]+1);
        }
        int num = ans;
        for(int i=0; i<n-1; i++){
            num = num-input[i]+(n-input[i]-1);
            if(num < ans)
                ans = num;
        }
        cout<<ans<<endl;
    }
    return 0;
} 
### 逆序数的概念 在一个排列中,如果一对元素的位置顺序与其数值大小相反,则这对元素构成一个逆序。例如,在排列 `263451` 中存在个逆序对 `(2,1)`、`(6,3)`、`(6,4)` 等等[^4]。 对于由 `1,2,...,n` 构成的所有 `n!` 个排列而言: - **最小的逆序数** 是 `0`,对应于升序排列 `1,2,...,n`; - **最大逆序数** 是 `n(n−1)/2`,对应于降序排列 `n,n−1,...,2,1`。 逆序数反映了给定排列相对于自然有序状态下的混乱程度,即逆序数越大表示该排列距离标准升序排列越远。 ### 解决方法及其算法实现 为了高效地计算逆序数,可以采用基于归并排序的方法来解决问题。这种方法不仅能够有效地完成排序操作,还能顺便统计出所有的逆序数量。具体做法如下所示: #### 归并排序求解逆序数的核心思想 通过分治策略将待处理的数据集不断分割为更小的部分直到单个元素为止,随后逐步合并这些部分的同时记录下每一步产生的新逆序关系。由于每次合并过程中只涉及相邻两个已排序区间内的比较,故可以在 O(log n) 层次上保持线性的扫描效率 O(n),从而使得整体时间复杂度达到最优水平 O(n log n)[^3]。 以下是 Python 实现的一个例子: ```python def merge_and_count_split_inv(B, C): i = j = inversions = 0 sorted_list = [] while i < len(B) and j < len(C): if B[i] <= C[j]: sorted_list.append(B[i]) i += 1 else: sorted_list.append(C[j]) j += 1 inversions += len(B) - i sorted_list.extend(B[i:]) sorted_list.extend(C[j:]) return sorted_list, inversions def sort_and_count(A): global num num = 0 def _sort_and_count_recursive(A): nonlocal num if len(A) == 1: return A, 0 mid = len(A) // 2 left_sorted, x = _sort_and_count_recursive(A[:mid]) right_sorted, y = _sort_and_count_recursive(A[mid:]) merged_array, z = merge_and_count_split_inv(left_sorted, right_sorted) num = num + x + y + z return merged_array, num _, total_inversions = _sort_and_count_recursive(A) return total_inversions if __name__ == "__main__": array = [2, 6, 3, 4, 5, 1] print(f"The number of inversion is {sort_and_count(array)}") ``` 上述代码实现了利用归并排序过程中的分裂阶段来进行逆序数统计的功能。每当右侧列表中的某个元素被提前加入到最终的结果集中时,意味着左侧剩余未处理的所有元素都构成了新的逆序对[^1]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值