【算法】美团2024年春招第一场笔试【技术】- Q4小美的朋友关系【反向并查集+离散化】

题目

小美认为，在人际交往中，但是随着时间的流逝，朋友的关系也是会慢慢变淡的，最终朋友关系就淡忘了。
现在初始有一些朋友关系，存在一些事件会导致两个人淡忘了他们的朋友关系。小美想知道某一时刻中，某两人是否可以通过朋友介绍互相认识？
事件共有 2 种：
1 u v：代表编号 u 的人和编号 v 的人淡忘了他们的朋友关系。
2 u v：代表小美查询编号 u 的人和编号 v 的人是否能通过朋友介绍互相认识。

注：介绍可以有多层，比如 2 号把 1 号介绍给 3 号，然后 3 号再把 1 号介绍给 4 号，这样 1 号和 4 号就认识了。

时间限制：C/C++ 1秒，其他语言2秒

空间限制：C/C++ 256M，其他语言512M

输入描述：

输出描述：

对于每次 2 号操作，输出一行字符串代表查询的答案。如果编号 u 的人和编号 v 的人能通过朋友介绍互相认识，则输出"Yes"。否则输出"No"。

示例1

输入例子：

5 3 5
1 2
2 3
4 5
1 1 5
2 1 3
2 1 4
1 1 2
2 1 3

输出例子：

Yes
No
No

例子说明：

第一次事件，1 号和 5 号本来就不是朋友，所以无事发生。
第二次事件是询问，1 号和 3 号可以通过 2 号的介绍认识。
第三次事件是询问，显然 1 号和 4 号无法互相认识。
第四次事件，1 号和 2 号淡忘了。
第五次事件，此时 1 号无法再经过 2 号和 3 号互相认识了。

思路

反向并查集+离散化

q正向遍历事件列表是删除边，反向就是增加边。

n为1e9，需要离散化处理。

注意点：

1. scanner会超时，需要用到Buffer流

2. 删除边可能失败，因为不存在这条边。需要标记哪些1事件会导致边被remove

import java.io.*;
import java.util.*;

class Q {
    public int op;
    public int u;
    public int v;

    public Q(int op, int u, int v) {
        this.op = op;
        this.u = u;
        this.v = v;
    }
}

class Main {

    static Scanner scanner = new Scanner(System.in);

    static StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

    static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

    public static int I() throws IOException {
        st.nextToken();
        return (int) st.nval;
    }

    public static void main(String[] args) throws IOException {
        int t = 1;
        while (t-- > 0) solve();
        pw.flush();
    }

    static Map<Integer,Integer> parent = new HashMap<>();

    public static int find(int x) {
        Integer paren = parent.get(x);
        if (x == paren) {
            return x;
        } else {
            parent.put(paren,find(paren));
            return parent.get(paren);
        }
    }

    public static void un(int a, int b) {
        parent.put(find(a),find(b));
    }


    public static void solve() throws IOException {
        int n = I();
        int m = I();
        int q = I();
        boolean[] bit = new boolean[q + 1];
        boolean[] remove = new boolean[q + 1];
        Set<String> set = new HashSet<>();
        for (int i = 0; i < m; i++) {
            int u = I();
            int v = I();
            parent.put(u,u);
            parent.put(v,v);
            set.add(u + "#" + v);
        }
        List<Q> qList = new ArrayList<>();
        for (int i = 0; i < q; i++) {
            int op = I();
            int u = I();
            int v = I();
            parent.put(u,u);
            parent.put(v,v);
            qList.add(new Q(op, u, v));
            if (op == 1) {
                String s1 = u + "#" + v;
                String s2 = v + "#" + u;
                if (set.remove(s1) || set.remove(s2)) {
                    remove[i] = true;
                }
            }
        }
        for (String s : set) {
            String[] split = s.split("#");
            int u = Integer.parseInt(split[0]);
            int v = Integer.parseInt(split[1]);
            un(u, v);
        }


        for (int i = q - 1; i >= 0; i--) {
            Q q1 = qList.get(i);
            if (q1.op == 1) {
                if (remove[i]) {
                    un(q1.u, q1.v);
                }
            } else {
                bit[i] = find(q1.u) == find(q1.v);
            }
        }
        for (int i = 0; i < q; i++) {
            if (qList.get(i).op == 2) {
                pw.println(bit[i] ? "Yes" : "No");
            }
        }
    }
}