压缩变换 蓝桥杯 java

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

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

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

比如，序列(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

解题思路：

   如果暴力写的话，复杂度是n^2 ，估计只能过30%的数据。我看了下网上其他题解基本都是这么个写法。思路就是用map1记录某数字上一次出现的位置。遍历该位置到上一次出现的位置，数字出现的种类。详见代码1

 本题目的正解应该是线段树。复杂度nlogn   能过所有数据 线段树模版题  详见代码2

 

代码1（暴力）

import java.lang.reflect.Array;
import java.util.*;


public class main {
	public static void main(String[] args) {
		int n;
		Map mp1=new HashMap();
		Map mp2=new HashMap();
		Scanner cin=new Scanner(System.in);
		int a[]=new int[1008611];
		int ans[]=new int [1008611];
		n=cin.nextInt();
		for(int i=1;i<=n;i++) {
			a[i]=cin.nextInt();
			if(mp1.containsKey(a[i])) {
				int cnt=0;
				mp2.clear();
				for(int j=i-1;j>(int)mp1.get(a[i]);j--) {
					System.out.println(i+" "+mp2.get(a[j]));
					if(!mp2.containsKey(a[j])) {
						cnt++;
						mp2.put(a[j], 1);
					}

				}
				mp1.put(a[i],i);
				ans[i]=cnt;
			}
			else {
				mp1.put(a[i], i);
				ans[i]=-1*a[i];
			}
		}
		for(int i=1;i<=n;i++) {
			if(i==1) {
				System.out.print(ans[i]);
			}
			else {
				System.out.print(" "+ans[i]);
			}
		}
		
	}
}

代码2  

import java.lang.reflect.Array;
import java.util.*;


public class main {
	public static final int maxn = 1000000+5;
	
	public static int a[]=new int[maxn];
	public static int tree[]=new int[maxn*4];
		// 假设层数 M = log 2 (n - 1), 树节点数就要开2倍了
									// 循环中遍历最后一个结点的的子节点(虽然不存在) 需要 2n * 2的数组大小
	public static int n, maxpoint;

	public static void init() {
		maxpoint = 1;
		while (maxpoint < n) maxpoint <<= 1;	//比最后一个结点大的2的倍数个结点
		Arrays.fill(tree, 0);
		Arrays.fill(a, 0);

	}
	

	public static void update(int k, int addnum) {			// addnum 在出现前边时更新所有子节点 + 1， 出现后边时 所有子节点都 - 1 
		k += maxpoint - 1;						// 每个节点都当作根节点一样遍历子节点
		tree[k] += addnum;						
		while (k>0) {
			k = (k - 1) >> 1;					// 访问父节点直到根结点
			tree[k] += addnum;
		}
	}

	public static int query(int a, int b, int k, int l, int r) {
		if(a == b || (r <= a || l >= b) ) return 0; // 不符合查询条件 返回 0
		if (a <= l && r <= b) return tree[k];		// 子区域就直接返回
		else {				
			int mid = (l + r) >> 1;					
			return query(a, b, (k << 1) + 1, l, mid) + query(a, b, (k + 1) << 1 , mid, r);
		}
	}

	public static void main(String[] args) {

			int temp;
			Map mp=new HashMap();
			Scanner cin=new Scanner(System.in);
			 n=cin.nextInt();
			init();
			for (int i = 0; i < n; i++) {
				temp=cin.nextInt();
				if (mp.containsKey(temp)) {
					int pre = (int)mp.get(temp);
					a[i] = query(pre + 1, i, 0, 0, maxpoint);
					update(pre, -1);
				}
				else {
					a[i] = -temp;
				}
				mp.put(temp, i);
				update(i, 1);
			}
			for (int i = 0; i < n; i++) 
				System.out.print(a[i]+" ");
		
	
	}
}