蓝桥杯2016年压缩变换

小明最近在研究压缩算法。

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

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

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

比如，序列（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，序列表示的长度
第二行所有游戏Ñ个正整数，表示输入序列。

输出格式：
输出一行，包含ñ个数，表示变换后的序列。

例如，输入：
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

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class 压缩变换 {
static Map <Integer,Integer> lastIndex =new HashMap<Integer,Integer>();
static int []b;
static SegTree root;
static int n;
static int[] data;
static int[] ans;
public static void main(String arg[]) {
Scanner sc=new Scanner(System.in);
n=sc.nextInt();
data=new int[n];
ans=new int[n];//存放答案
b= new int [n];//存放0 1
root=buildSegTree(0,n-1);//初始化树

for(int i=0;i<n;i++) {
int num=sc.nextInt();
data[i]=num;
//如果没出现过，则变为-1；
if(lastIndex.get(num)==null) {
ans[i]=-num;
b[i]=1;
update(root,i,1);
}
else {
int index=lastIndex.get(num);
ans[i]=query(root,index+1,i-1);
b[index]=0;
b[i]=1;
update(root,index,-1);	//原来的出现的区间和减1
update(root,i,1);	//现在的下标的区间和加1
}

lastIndex.put(num,i);

}

for(int j=0;j<n;j++) {
System.out.print(ans[j]+" ");
}

}

//查询区间和是多少
private static int query(SegTree tree,int l,int r) {

if(l<=tree.l&&r>=tree.r) {
return tree.sum;
}
int mid=(tree.l+tree.r)/2;
int ans=0;
if(l<=mid) {
ans+=query(tree.lson,l,r);
}
if(r>mid) {
ans+=query(tree.rson,l,r);
}
return ans;
}

//初始化树状数组
private static SegTree buildSegTree(int l,int r) {
SegTree tree=new SegTree(l,r);

if(l==r) {
tree.sum=b[l];
return tree;
}

int mid=(l+r)/2;

tree.lson=buildSegTree(l,mid);
tree.rson=buildSegTree(mid+1,r);
tree.sum=tree.lson.sum+tree.rson.sum;
return tree;

}

//每次更新b之后，相应的更新tree
private static void update(SegTree tree,int p,int i) {
if(tree==null)
return;

tree.sum+=i;
int l=tree.l;
int r=tree.r;

int mid=(l+r)/2;

if(p<=mid) {

update(tree.lson,p,i);

}
else if(p>mid) {

update(tree.rson,p,i);

}

}
static class SegTree {
int l,r;//左右区间
int sum;//和
SegTree lson;//左子树
SegTree rson;//右子树
public SegTree(int l,int r) {
this.l=l;
this.r=r;
}
}

}

思路
这里的优化性能的方法是树状数组
并且将检查种类的问题转换为求两个索引之间区间和的问题。
首先第一次出现一个数字之后，数组b会将这个数字对应的下标里面的值设为1，当再次出现的时候，将再次出现的的设为1，之前的改为0，这样如果求两个索引之间的数字的种类数时，只需对两个索引之间的区间进行求和。
树状数组最初初始化时与b中的元素保持一致，它保存的是在不同区间（0，n-1）（二分区间将树伸展向下）的和，当b改变时，树状数组也进行update函数进行更新数值。
lastIndex是一个map,它的key是数字，value是这个数字上一次出现的下标。每次要及时更新数字的最近的上一次出现的下标位置。

注意在查询区间和的时候，在对左右子树进行递归查询的时候，参数左右区间的下标可以一直是最初的l和r,虽然这样看起来区间超过，但是并不影响出口的判断，大于当前树的区间时会返回当前树的sum和。