hud 1394 Minimum Inversion Number

给出 一个由 1  到  n - 1  组成的n 个数的序列，每次把第一个数移动到最后面会形成一个新的序列。

求出所有序列中逆序数的的最小值。

暴搜代码：

#include <stdio.h>
#include <string.h>
#include<iostream>
using namespace std;
#define N 5001

int a[N];
int b[N];

int main()
{
    int n,i,j,maxx;
    while(cin>>n)
    {
        int t = 0;
        memset(b,0,sizeof(b));
        for(i = 0; i < n; i++)
        cin>>a[i];
        for(i = 0; i < n; i++)
        {
            for(j = i +1; j < n; j++)
            if(a[i] > a[j]) b[i]++;
            t += b[i];
        }
        int min = t;
        for(i = 0; i < n; i++)
        {
            t = t- a[i] + n - 1 - a[i];//每一个新的序列都是由上一个序列得到的
            min = min > t?t:min;       //所以 t 的值每次都要更新
        }
        cout<<min<<endl;
    }
    return 0;
}

本题可用线段树 和树状数组进行优化

线段树代码：

/*
没个节点保存着，在此区间范围内的元素出现的个数。
我们要求的逆序数就是在 a  后面出现的比 a 大的数的个数，所以接受一个元素就可以查询
a +１　到　ｎ　之间的数出现的个数，他保存在区间［ａ＋１，ｎ］中，整个题目就成了，
单点更新，区间求值得线段树。
*/
#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
using namespace std;
# define inf 10000000
int sum[800100],a[50000],tag[800100],tmp;
void pushup(int root)
{
    sum[root] = sum[2*root] + sum[2*root + 1];
}

void build(int l,int r,int root)
{
    if(l == r)
    {
        sum[root] = 0;
        return ;
    }
    else
    {
        int mid = (l+r)/2;
        build(l,mid,2*root);
        build(mid+1,r,2*root+1);
        pushup(root);
    }
}
void update(int p,int l,int r,int root)
{
    if(l == r)
    {
        sum[root] += 1;
        return ;
    }
    int mid = (l+r)/2;
    if(p <= mid)update(p,l,mid,2*root);
    else update(p,mid+1,r,2*root+1);
    pushup(root);
}
void getsum(int L,int R,int l,int r,int root)
{
    if(L <= l && R >= r)
    {
        tmp += sum[root];
        return ;
    }
    int mid = (l + r)/2;
    if(L <= mid) getsum(L,R,l,mid,2*root);
    if(R > mid) getsum(L,R,mid+1,r,2*root+1);
}
int main()
{

    int n,m,i,j;
    while(scanf("%d",&n)!= EOF)
    {
        int minn = 0;
        build(1,n,1);
        for(i = 1; i <= n; i++)
        {
            scanf("%d",&a[i]);
            a[i]++;//每个点都 自加 1 ，防止出现 0
        }
        for(i = 1; i <= n; i++)
        {
            tmp = 0;
            if(a[i]+1 <= n)//大于 n ，就超出了范围
            getsum(a[i] + 1,n,1,n,1);
            minn += tmp;
            update(a[i],1,n,1);
        }
        int ans = inf;
        for(i = 1; i <= n; i++)//每个点移动到最后会导致整个序列的逆序数发生改变
        {
            minn = minn - (a[i] - 1) + n-1 - (a[i]-1);
            if(minn < ans) ans = minn;
        }
        printf("%d\n",ans);
    }
    return 0;
}

树状数组：

首先要明白树状数组的add 函数更新机制，沿着右上方向走，把经过的每一层lowbit  节点都要更新。sum  函数更新的时候沿着坐上方向走。

比如  已经接受 了3  ，那么c 【 4】 c 【 8 】 都会被更新，下一次要查询  7，会访问到  c 【 4】 ，所以 我们知道在7  前面出现的元素中有3

那么  我们可以用 7  前面出现的所有元素的个数，减去小于  7 个元素的个数就可以得到，7 前面出现的大于7的元素的个数。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
using namespace std;
# define inf 10000000
int sum[800100],a[50000],c[50000],tag[800100],n;
int lowbit(int x)
{
    return x & (-x);
}
int getsum(int x)
{
    int res = 0;
    while(x > 0)
    {
        res += c[x];
        x -= lowbit(x);
    }
    return res;
}
void add(int x,int y)
{
    while(x <= n)
    {
        c[x] += y;
        x += lowbit(x);
    }
}
int main()
{
    while(cin>>n)
    {
        int i ,minn = 0;
        memset(c,0,sizeof(c));
        for(i = 1; i <= n; i++)
        {
            cin>>a[i];
            a[i]++;
            minn += i-1 - getsum(a[i]);
            add(a[i],1);
        }
        int t = minn;
        for(i = 1; i < n; i++)
        {
            t = t - (a[i] - 1) + (n - a[i]);
            minn = minn> t?t :minn;
        }

        cout<<minn<<endl;
    }
    return 0;
}