hdu 1394 Minimum Inversion Number(数据结构:线段树)

这道题用了三种方法写的

暴力、归并排序、线段树

其中以归并排序速度最快,仅需要15ms

这个题的难点在于怎样从当前排列的逆序数的到下一排列的逆序数

我开始想岔了,我的想法是把后面的元素每次向前移动,但是没有想清楚

看了别人的代码才知道怎么做

做法如下:

如果当前的排列为

4 2 1 0 3

则我们有两种移动策略,先介绍第一种

1、每次把第一个元素移至末尾

则会发现4对应后面有4个数比它小即 2 1 0 3,原因是该排列为0 - n-1的排列

对于首位置的a[i],后面必然存放0 - (a[i]-1) 即a[i]个数比当前a[i]小

所以首位置后面比它大的数为n-1-a[i]个

设当前的逆序数为ans

则把首位置的数移到末尾后,之前逆序数少了a[i]个,多了n-1-a[i]个

所以此时的ans为ans = ans - a[i] + (n-1-a[i])

由此公式我们就可以通过一个排列的逆序数求出所有排列的逆序数

2、每次把末尾元素移至第一位

同上分析,可知此时ans = ans + a[i] - (n-1-a[i])

其实这道题可以使用线段树的原因就在于用它计算区间和

我们使用一个标记数组来b[a[i]] == 1来表示a[i]已经出现

如我们输入了a[i],我们只需要统计数据中(a[i]+1) - (n-1)已出现数据的个数

也就是b[a[i]+1] - b[n-1]的区间和

即为当前a[i]对应的逆序数

输入a[i]后,我们要更新对应位置的b[a[i]] = 1

在线段树中当然不能简单的令b[a[i]] = 1而是要令线段树中a[i]出现处的b值都+1,也就是单点更新

代码如下:

1、直接暴力---296ms

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define MAXN 50050
#define LL long long
using namespace std;

int a[MAXN], b[MAXN], low[MAXN], up[MAXN];

int main(void) {
    int n;
    while(scanf("%d", &n) != EOF) {
        int ans = 0;
        int tmp;
        memset(b, 0, sizeof(b));
        for(int i=0; i<n; ++i) {
            scanf("%d", &a[i]);
            for(int j=0; j<i; ++j)
                if(a[j] > a[i])
                    ans++;
        }
//        cout << ans << endl;
        tmp = ans;
        for(int i=0; i<n; ++i) {
            tmp += (-a[i]+n-1-a[i]);
            ans = min(tmp, ans);
//            printf("tmp = %d\n", tmp);
        }
        cout << ans << endl;
    }
    return 0;
}

2、归并排序---15ms

#include <cstdio>
#include <iostream>
#include <algorithm>
#define MAXN 5010
#define LL long long
using namespace std;

int a[MAXN], b[MAXN], tmp[MAXN];
int ans;

void merge(int L, int M, int R) {
    int i, j, k;
    for(i=L, j=M+1, k=0; i<=M&&j<=R; ) {
        if(a[i] < a[j])
            tmp[k++] = a[i++];
        else {
            tmp[k++] = a[j++];
            ans += M-i+1;
        }
    } 
    while(i <= M)
        tmp[k++] = a[i++];
    while(j <= R) 
        tmp[k++] = a[j++];
    for(int i=0; i<k; ++i) {
        a[L+i] = tmp[i];
    }
}

void mergesort(int L, int R) {
    if(L < R) {
        int M = (L+R)/2;
        mergesort(L, M);
        mergesort(M+1, R);
        merge(L, M, R);
    }
}

int main(void) {
    int n;
    while(scanf("%d", &n) != EOF) {
        ans = 0;
        for(int i=0; i<n; ++i) {
            scanf("%d", &a[i]);
            b[i] = a[i];
        }
        mergesort(0, n-1);
        int tmp = ans;
        for(int i=0; i<n; ++i) {
            tmp += -b[i]+n-1-b[i];
            ans = min(ans, tmp);
        }
        cout << ans << endl;
    }
    return 0;
}

3、线段树---62ms

#include <cstdio>
#include <iostream>
#include <algorithm>
#define MAXN 5010
#define LL long long
using namespace std;

int sum[MAXN<<2], a[MAXN];

void pushUp(int rt) {
    sum[rt] = sum[rt<<1]+sum[rt<<1|1];
}

void build(int l, int r, int rt) {
    sum[rt] = 0;
    if(l == r) {
        return ;
    }
    int m = (l+r)>>1;
    build(l, m, rt<<1);
    build(m+1, r, rt<<1|1);
}

void update(int p, int add, int l, int r, int rt) {
    if(l == r) {
        sum[rt] += add;
        return ;
    }
    int m = (l+r) >> 1;
    if(p <= m) 
        update(p, add, l, m, rt<<1);
    else update(p, add, m+1, r, rt<<1|1);
    pushUp(rt);
}

int query(int L, int R, int l, int r, int rt) {
    if(L<=l && r<=R) {
        return sum[rt];
    }
    int m = (l+r) >> 1;
    int ret = 0;
    if(L <= m)
        ret += query(L, R, l, m, rt<<1);
    if(m < R) 
        ret += query(L, R, m+1, r, rt<<1|1);
    return ret;
}

int main(void) {
    int n;
    while(scanf("%d", &n) != EOF) {
        build(0, n-1, 1);
        int ans = 0;
        for(int i=0; i<n; ++i) {
            scanf("%d", &a[i]);
            ans += query(a[i], n-1, 0, n-1, 1);
            update(a[i], 1, 0, n-1, 1);
        }
        int tmp = ans;
        for(int i=0; i<n; ++i) {
            tmp += -a[i] + n-a[i]-1;
            ans = min(ans, tmp); 
        }
        cout << ans << endl;
    }
    return 0;
}