蓝桥杯 压缩变换【第七届】【省赛】【A组】C++ 线段树

资源限制

内存限制：256.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

　　小明最近在研究压缩算法。
　　他知道，压缩的时候如果能够使得数值很小，就能通过熵编码得到较高的压缩比。
　　然而，要使数值很小是一个挑战。

　　最近，小明需要压缩一些正整数的序列，这些序列的特点是，后面出现的数字很大可能是刚出现过不久的数字。对于这种特殊的序列，小明准备对序列做一个变换来减小数字的值。

　　变换的过程如下：
　　从左到右枚举序列，每枚举到一个数字，如果这个数字没有出现过，刚将数字变换成它的相反数，如果数字出现过，则看它在原序列中最后的一次出现后面（且在当前数前面）出现了几种数字，用这个种类数替换原来的数字。

　　比如，序列(a1, a2, a3, a4, a5)=(1, 2, 2, 1, 2)在变换过程为：
　　a1: 1未出现过，所以a1变为-1；
　　a2: 2未出现过，所以a2变为-2；
　　a3: 2出现过，最后一次为原序列的a2，在a2后、a3前有0种数字，所以a3变为0；
　　a4: 1出现过，最后一次为原序列的a1，在a1后、a4前有1种数字，所以a4变为1；
　　a5: 2出现过，最后一次为原序列的a3，在a3后、a5前有1种数字，所以a5变为1。
　　现在，给出原序列，请问，按这种变换规则变换后的序列是什么。

输入格式

　　输入第一行包含一个整数n，表示序列的长度。
　　第二行包含n个正整数，表示输入序列。

输出格式

　　输出一行，包含n个数，表示变换后的序列。

　　例如，输入：
　　5
　　1 2 2 1 2

　　程序应该输出：
　　-1 -2 0 1 1

　　再例如，输入：
　　12
　　1 1 2 3 2 3 1 2 2 2 3 1

　　程序应该输出：
　　-1 0 -2 -3 1 1 2 2 0 0 2 2

数据规模和约定

　　对于30%的数据，n<=1000；
　　对于50%的数据，n<=30000；
　　对于100%的数据，1 <=n<=100000，1<=ai<=10^9


　　资源约定：
　　峰值内存消耗（含虚拟机） < 256M
　　CPU消耗 < 3000ms


　　请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

　　所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
　　注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
　　注意：主类的名字必须是：Main，否则按无效代码处理。

自己写的代码只过了几个点...

直接贴上佬们的代码及来源

AC Code

 来源

#include<stdio.h>
#include<iostream>
#include<map>
#include<string.h>
#include<algorithm>
#include<math.h>
#include<vector>

#define ll long long
using namespace std;
const int maxn=100005;

int a[maxn]; ///记录原始数据
int ans[maxn]; ///记录答案
int b[maxn];  ///这是一个01序列，某一个位置p上的位置为1，代表着a[p]这个数字最后出现的位置是p，而a[p]曾经出现的位置上都是0
int n;
map<int,int>LastIndex;
struct tree
{
    int l,r;     ///l,r左右端点
    int sum;    ///sum区间和
} t[maxn*4];

void build(int p,    int l,     int r)
{
    ///当前的节点，左子节点，右子节点
    t[p].l=l;
    t[p].r=r;
    if(l==r)   ///根节点
    {
       t[p].sum=a[r];
        return ;  ///从下往上传数据
    }
    int mid=(l+r)>>1;  ///
    build(p*2,l,mid);///建左子树
    build(p*2+1,mid+1,r);  ///建右子树
    t[p].sum=t[p*2].sum+t[p*2+1].sum;
}

void change(int p,int x,int v)//单点修改
{
    if(t[p].l==t[p].r)
    {
       t[p].sum=v;
        return ;
    }
    int mid=(t[p].l+t[p].r)>>1;
    if(x<=mid) change(p*2,x,v);
    else change(p*2+1,x,v);
    t[p].sum=t[p*2].sum+t[p*2+1].sum;
}

int ask(int p,int x,int y)
{
	int l=t[p].l;
	int r=t[p].r;
	if(x<=l&&y>=r)
	{
		return t[p].sum;
	}
	int mid=(l+r)/2;
	int ans=0;
	if(x<=mid)
	{
		ans+=ask(p*2,x,y);
	}
	if(y>mid)
	{
		ans+=ask(p*2+1,x,y);
	}
	return ans;
}
int main()
{
	LastIndex.clear();
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
	}
	build(1,1,n);

	for(int i=1;i<=n;i++)
	{
		int num=a[i];
		int  preIndex=LastIndex[num];
		if(preIndex==0)
		{
			ans[i]=-num;
			b[i]=1;
			change(1,i,1);
		}
		else
		{
			ans[i]=ask(1,preIndex+1,i-1);  ///统计两个位置之间的1的个数 ，其实就是求区间和
			b[i]=1;
			b[preIndex]=0;
			change(1,i,1);
			change(1,preIndex,0);
		}
		LastIndex[num]=i;  ///更新
	}
	for(int i=1;i<=n;i++)
	{
		printf("%d",ans[i]);
		if(i!=n) printf(" ");
	}
	printf("\n");
}

来源 

#include <bits/stdc++.h>

using namespace std;
const int maxn=100005;
typedef map<int,int> num;
int a[maxn];//输入数组
int b[maxn];//计种类数量的数组
int ans[maxn];//答案数组
num tem;
//线段树
struct node
{
    int sum,l,r;
    //int lz;
}t[maxn*4];

//void pushdown(int p)
//{
//        t[p*2].lz+=t[p].lz;
//        t[p*2+1].lz+=t[p].lz;
//        t[p*2].sum+=(t[p*2].r-t[p*2].l+1)*t[p].lz;
//        t[p*2+1].sum+=(t[p*2+1].r-t[p*2+1].l+1)*t[p].lz;
//        t[p].lz=0;
//}
void build(int p,int l,int r)
{
    t[p].l=l;
    t[p].r=r;
    //l,r也赋值
    if(l==r)
    {
        t[p].sum=b[l];
        return;
    }
    int mid=(l+r)/2;
    build(p*2,l,mid);
    build(p*2+1,mid+1,r);
    t[p].sum=t[p*2].sum+t[p*2+1].sum;
}

void change(int p,int x,int hh)
{
    if(t[p].l==t[p].r&&t[p].r==x)
    {
        //t[p].lz+=hh;
        t[p].sum=hh;
        return;
    }
    int mid=(t[p].l+t[p].r)/2;
    if(mid>=x)
        change(p*2,x,hh);
    if(mid<x)
        change(p*2+1,x,hh);
    t[p].sum=t[p*2].sum+t[p*2+1].sum;
}

int findd(int p,int x,int y)
{
    if(t[p].l>=x&&t[p].r<=y)
    {
            return t[p].sum;
    }
//    if(t[p].lz)
//        pushdown(p);
    int ans=0;
    int mid=(t[p].l+t[p].r)/2;
    if(x<=mid)
        ans+=findd(p*2,x,y);
    if(y>mid)
        ans+=findd(p*2+1,x,y);

    return ans;
}
int main()
{
   int n;
   scanf("%d",&n);
   for(int i=0;i<n;i++)
   {
       scanf("%d",&a[i]);
   }
    memset(b,0,sizeof(b));
    build(1,0,n-1);
   for(int i=0;i<n;i++)
   {

       if(tem.find(a[i])==tem.end())
       {//初次找到
          tem[a[i]]=i;
          change(1,i,1);
          ans[i]=-a[i];
          continue;
       }
       else{

            ans[i]=findd(1,tem[a[i]]+1,i-1);
            //统计个数
//          for(int j=i;j>tem[a[i]];j--)
//          {
//              ans[i]+=b[j];
//          }
            change(1,tem[a[i]],0);
            //把前面置1的改为0
           //b[tem[a[i]]]=0;
           //b[i]=1;
           change(1,i,1);
           //把现在即最近的这个位置置为1
           tem[a[i]]=i;
       }

   }
   for(int i=0;i<n;i++)
   {
       printf("%d ",ans[i]);
   }
   cout<<endl;
   return 0;
}