NYOJ-117/atcoder ARC 75-E - Meaningful Mean 求逆序数。 树状数组存模板！（原模板已更正）

求逆序数

时间限制： 2000 ms  |  内存限制： 65535 KB

难度： 5

 题意：中文题。

本来用权值线段树写的，但nyoj判题机3s能当1s用，成功TLE。

之前写过一个树状数组求逆序数的板子，今天发现有点点小问题，于是删除了，以这篇作为新的总结！

对之前被误导的表示深深的歉意。

树状数组：注意离散化

const int N=1e6+10;
inline int sc()
{
    char c;
    int ret=0;
    if(c=getchar(),c==EOF) return 0;
    while(c!='-'&&(c<'0'||c>'9')) c=getchar();
    ret=(c=='-')?0:(c-'0');
    while(c=getchar(),c>='0'&&c<='9') ret=ret*10+(c-'0');
    return ret;
}
int n,a[N],b[N],ha[N],sum[N];
int lowbit(int x)
{
    return x&(-x);
}
void update(int i,int x,int n)
{
    while(i<=n)
    {
        sum[i]+=x;
        i+=lowbit(i);
    }
}
ll getsum(int i)
{
    ll ans=0;
    while(i)
    {
        ans+=sum[i];
        i-=lowbit(i);
    }
    return ans;
}
void getB(int n)
{
    for(int i=n; i>=1; i--)
    {
        b[i]=getsum(a[i]-1);
        update(a[i],1,n);
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        memset(sum,0,sizeof(sum));
        scanf("%d",&n);
        for(int i=1; i<=n; i++) a[i]=sc(),ha[i]=a[i];
        sort(ha+1,ha+n+1);
        int k=unique(ha+1,ha+n+1)-ha-1;
        for(int i=1; i<=n; i++) a[i]=lower_bound(ha+1,ha+k+1,a[i])-ha;
        getB(n);
        ll ans=0;
        for(int i=1; i<=n; i++) ans+=b[i];
        printf("%lld\n",ans);
    }
    return 0;
}

权值线段树写法：

const int N=1e6+10;
int n,nn,A[N],ha[N];
inline int sc()
{
    char c;
    int ret=0;
    if(c=getchar(),c==EOF) return 0;
    while(c!='-'&&(c<'0'||c>'9')) c=getchar();
    ret=(c=='-')?0:(c-'0');
    while(c=getchar(),c>='0'&&c<='9') ret=ret*10+(c-'0');
    return ret;
}
struct node
{
    int l,r,x;
}a[N<<2];
void build(int l,int r,int k)
{
    a[k].l=l,a[k].r=r,a[k].x=0;
    if(l==r) return ;
    int mid=(l+r)/2;
    build(l,mid,2*k);
    build(mid+1,r,2*k+1);
}
void update(int id,int k)
{
    if(a[k].l==id&&a[k].r==id)
    {
        a[k].x++;
        return ;
    }
    int mid=(a[k].l+a[k].r)/2;
    if(id<=mid) update(id,2*k);
    else update(id,2*k+1);
    a[k].x=a[k*2].x+a[k*2+1].x;
}
int query(int l,int r,int k)
{
    if(l>r) return 0;
    if(l<=a[k].l&&a[k].r<=r) return a[k].x;
    int mid=(a[k].l+a[k].r)/2;
    if(r<=mid ) return query(l,r,2*k);
    else if(l>mid) return query(l,r,2*k+1);
    return query(l,mid,2*k)+query(mid+1,r,2*k+1);
}
void init()
{
    sort(ha+1,ha+n+1);
    nn=unique(ha+1,ha+n+1)-ha-1;
    build(1,nn,1);
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(int i=1;i<=n;i++) A[i]=sc(),ha[i]=A[i];
        init();
        ll ans=0;
        for(int i=1;i<=n;i++)
        {
            int pos=lower_bound(ha+1,ha+nn+1,A[i])-ha;
            ans+=query(pos+1,nn,1);
            update(pos,1);
        }
        printf("%lld\n",ans);
    }
    return 0;
}

当然，归并排序的代码量和复杂度和这个基本差不多，方法很有，适合就好。

附上nyoj此题排行第一代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int tr[500003];
inline int readint(){
	int res=0;
	char c = getchar();
	while (c>'9' || c<'0')
		c=getchar();
	while (c>='0' && c<='9'){
		res = res*10 + c-'0';
		c=getchar();
	}
	return res;
}
long long msort(int *arr, int n){
	int t, i , j;
	long long ret=0;
	int *tr2;
	if (n==1)
		return 0;
	if (n==2){
		if (arr[0]<=arr[1])
			return 0;
		t = arr[0]; arr[0] = arr[1]; arr[1]=t;
		return 1;
	}
	t = n/2;
	ret+= msort(arr, t);
	tr2 = arr+t;
	ret+= msort(tr2, n-t);
	memcpy(tr, arr, t*sizeof(arr[0]));

	for (i=0, j=0; i!=t && j!=n-t; ){
		if (tr[i] <= tr2[j]){
			arr[i+j] = tr[i];
			i++;
		} else{
			arr[i+j] = tr2[j];
			j++;
			ret+=t-i;
		}
	}
	for (; i!=t; i++)
		arr[i+j] = tr[i];
	return ret;
}
int main(){
	int arr[1000002];
	int T, N, i;
	scanf("%d",&T);
	while (T--){
		scanf("%d",&N);
		for (i=0; i<N; i++)	arr[i]=readint();
		printf("%Ld\n", msort(arr, N));
	}
	return 0;
}

                                       

                           

                 AtCoder Regular Contest 075

                                                 E - Meaningful Mean  重新整理了一下，重新写一篇题解。

题意：给你n个数，求有多少个区间的平均值不小于p。

看起来毫无思路，不过把每个数减去p后相当于求有多少个区间的和不小于0，而区间和又可以用两个前缀和相减得到，这样与0比较相当于比较两个前缀和的大小关系，这样就相当于转化成了逆序数问题，倒着来遍历就行了 ，注意数据范围。

const int N=1e6+10;
inline int sc()
{
    char c;
    int ret=0;
    if(c=getchar(),c==EOF) return 0;
    while(c!='-'&&(c<'0'||c>'9')) c=getchar();
    ret=(c=='-')?0:(c-'0');
    while(c=getchar(),c>='0'&&c<='9') ret=ret*10+(c-'0');
    return ret;
}
int n;
ll p,a[N],b[N],ha[N],sum[N];
int lowbit(int x)
{
    return x&(-x);
}
void update(int i,int x,int n)
{
    while(i<=n)
    {
        sum[i]+=x;
        i+=lowbit(i);
    }
}
ll getsum(int i)
{
    ll ans=0;
    while(i)
    {
        ans+=sum[i];
        i-=lowbit(i);
    }
    return ans;
}
void getB(int n)
{
    for(int i=1; i<=n; i++)//求i的左边有多少个数小于等于a[i]
    {
        b[i]=getsum(a[i]);
        update(a[i],1,n);
    }
}
int main()
{
   while(~scanf("%d%lld",&n,&p))
   {
        memset(sum,0,sizeof(sum));
        a[0]=0;
        ll ans=0;
        for(int i=1; i<=n; i++)
        {
            a[i]=sc();
            a[i]-=p;
            a[i]+=a[i-1];
            if(a[i]>=0) ans++;
            ha[i]=a[i];
        }
        sort(ha+1,ha+n+1);
        int k=unique(ha+1,ha+n+1)-ha-1;
        for(int i=1; i<=n; i++) a[i]=lower_bound(ha+1,ha+k+1,a[i])-ha;
        getB(n);
        for(int i=1; i<=n; i++) ans+=b[i];
        printf("%lld\n",ans);
    }
    return 0;
}