hud 1394 Minimum Inversion Number

最新推荐文章于 2024-08-01 16:18:03 发布

原创最新推荐文章于 2024-08-01 16:18:03 发布 · 506 阅读

0 ·

CC 4.0 BY-SA版权

树状数组专栏收录该内容

17 篇文章

订阅专栏

本文探讨了如何使用线段树和树状数组来解决序列逆序数最小值的问题，并通过优化实现更高效的算法。包括详细解释和代码实现。

给出一个由 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;
}