蓝桥杯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

代码

import java.util.HashMap;  
import java.util.Map;  
import java.util.Scanner;  
  
public class Main {  
    static Map<Integer, Integer> map = new HashMap<>();  
  
    static int[] arr;  
  
    static int[] ans;  
  
    static int[] pos;  
  
    static Node[] nodes;  
  
    public static void main(String[] args) {  
        //初始化  
        Scanner scanner = new Scanner(System.in);  
        int n = scanner.nextInt();
        //因为线段树不是满二叉树 所以不能只开2倍空间  
        nodes = new Node[n * 4];  
        arr = new int[n]; pos = new int[n]; ans = new int[n];  
        //建树  
        build(0, n - 1, 0);  
        //填表+更新  
        for (int i = 0; i < n; i++) {  
            arr[i] = scanner.nextInt();  
            Integer pre = map.get(arr[i]);  
  
            if (pre == null) {  
                ans[i] = -arr[i];  
                pos[i] = 1;  
                update(i, 1, 0);  
            } else {  
                ans[i] = query(pre + 1, i - 1, 0);  
                pos[pre] = 0;  
                pos[i] = 1;
                //x~pre区间的和减少1  
                update(pre, -1, 0);
                //x~i区间的和增加1  
                update(i, 1, 0);  
            }  
            map.put(arr[i], i);  
        }  
        //输出结果  
        for (int i = 0; i < n; i++) {  
            System.out.print(ans[i] + " ");  
        }  
    }  
    static void update(int i, int val, int index) {  
        nodes[index].sum += val;  
        if (nodes[index].l == nodes[index].r) return;  
        int mid = (nodes[index].l + nodes[index].r) / 2;  
        if (i <= mid)  
            update(i, val, index * 2 + 1);  
        else  
            update(i, val, index * 2 + 2);  
    }  
    static void build(int l, int r, int index) {  
        nodes[index] = new Node(l, r);  
        if (l == r) {  
            nodes[index].sum = 0;  
        } else {  
            int mid = (l + r) / 2;  
            build(l, mid, index * 2 + 1);  
            build(mid + 1, r, index * 2 + 2);  
            nodes[index].sum = nodes[index * 2 + 1].sum + nodes[index * 2 + 2].sum;  
        }  
    }  
    static int query(int l, int r, int index){  
        if (l <= nodes[index].l && r >= nodes[index].r)  
            return nodes[index].sum;  
        int mid = (nodes[index].l + nodes[index].r) / 2, ans = 0;  
        if (l <= mid) ans += query(l, r, index * 2 + 1);  
        if (r > mid) ans += query(l, r, index * 2 + 2);  
        return ans;  
    }  
}  
  
class Node{  
    int l, r, sum;  
  
    public Node(int l, int r) {  
        this.l = l;  
        this.r = r;  
    }  
}

题解

我们不用被压缩变换这个词唬住, 直接按题目要求来就行
读题后发现该题的难点在于当填到y下标时 需要统计 (l, r)区间不同数字的个数
用数组模拟(l,r)区间, l r为下标, 如果在l r区间内该位置有不重复的数, 该位置值就为1 反之则为0
则统计(l, r) 区间的和 就可得出答案

//模拟一遍 读取一个数后 进行下一行的操作
1 2 2 1 2
pos[0] = 1;
pos[1] = 1;
pos[2] = 1;pos[0] = 0; 统计 (2,1)区间的和 即0
pos[3] = 1;pos[0] = 0; 统计 (1,2)区间的和 即1
pos[4] = 1;pos[2] = 0;统计 (3,3)区间的和 即1

统计区间的和我们很容易联想到线段树 推荐看这篇学习
具体代码参上

好的!本次分享到这就结束了
如果对铁汁你有帮助的话，记得点赞👍+收藏⭐️+关注➕
我在这先行拜谢了：）

参考文章:
第七届蓝桥杯 Java A—— 压缩变换