小美的朋友关系

#include <iostream>
#include <bits/stdc++.h>
using namespace std;

unordered_map<int,int>fa;
map<pair<int,int>,bool>mp;
vector<vector<int>>b;

int find(int x){
    if(x==fa[x])return x;
    else return fa[x] = find(fa[x]);
}

void combine(int x, int y){
    int fx = find(x), fy = find(y);
    fa[fx] = fy;
}

int main() {
    int n,m,q;
    cin>>n>>m>>q;
    b.resize(q+1);
    for(int i=0; i<m; i++){
        int x,y;
        cin>>x>>y;
        fa[x] = x, fa[y] = y;
        if(x>y)swap(x,y);
        mp.insert({{x,y},true});
    }
    for(int i=1; i<=q; i++){
        b[i].resize(3);
        cin>>b[i][0]>>b[i][1]>>b[i][2];
        if(b[i][1]>b[i][2])swap(b[i][1],b[i][2]);
        if(b[i][0]==1 && mp.count({b[i][1],b[i][2]}))mp[{b[i][1],b[i][2]}] = false;
    }
    for(auto &it:mp){
        auto [x,y] = it.first;
        if(it.second)combine(x, y);
    }
    stack<string>ans;
    for(int i=q; i>=1; i--){
        int fx = find(b[i][1]), fy = find(b[i][2]);
        if(b[i][0]==2){
            if(fx && fx==fy)ans.push("Yes");
            else ans.push("No");
        }else{
            if(mp.count({b[i][1],b[i][2]})) fa[fx] = fy;
        }
    }
    while(ans.size()){
        cout<<ans.top()<<endl;
        ans.pop();
    }
    return 0;
}

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

public class Main {
	static BufferedReader bf = new BufferedReader(new InputStreamReader(System.in),65535);
	static StreamTokenizer st = new StreamTokenizer(bf);
	static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
	static int n,m,maxn=200005,inf = 0x3f3f3f3f;
	static long ans=0,mod=(int)1e9+7,INF=(long)2e18;
	public static void main(String[]args) throws IOException{
		new Task().main();
		pw.flush();
	}
	
	static int I() throws IOException{
		st.nextToken();
		return (int)st.nval;
	}

	static class Task{
		void main()throws IOException{
			int t=1;
			//t=sc.nextI();
			while(t-->0) solve();
		}
		
		int []p = new int [maxn];
		Map<Integer,Integer> id = new HashMap<>();
		Set<Long> edge = new HashSet<>();
		Set<Long> del = new HashSet<>();
		Vector<int[]> ask = new Vector<>();
		
		void add(int u,int v) {
			int uu=find(u),vv=find(v);
			if(uu!=vv) p[uu]=vv;
		}
		
		private int find(int v) {
			// TODO Auto-generated method stub
			if(p[v]==v) return v;
			return p[v]=find(p[v]);
		}

		private void solve() throws IOException {
			n=sc.nextI();m=sc.nextI();int q=sc.nextI();
			int tot=0;
			for(int i=1;i<maxn;i++) p[i]=i;
			for(int i=1;i<=m;i++) {
				int u=sc.nextI(),v=sc.nextI();
				if(!id.containsKey(u)) id.put(u, ++tot);
				if(!id.containsKey(v)) id.put(v, ++tot);
				u=id.get(u);v=id.get(v);
				if(u>v) {
					int t=u;u=v;v=t;
				}
				edge.add(1L*u*maxn+v);
			}
			for(int i=1;i<=q;i++) {
				int op=sc.nextI(),u=sc.nextI(),v=sc.nextI();
				if(!id.containsKey(u)) id.put(u, ++tot);
				if(!id.containsKey(v)) id.put(v, ++tot);
				u=id.get(u);v=id.get(v);
				if(u>v) {
					int t=u;u=v;v=t;
				}
				ask.add(new int [] {op,u,v});
				if(op==1) del.add(1L*u*maxn+v);
			}
			for(long x:edge) {
				if(del.contains(x)) continue;
				int u = (int)(x/maxn),v=(int)(x%maxn);
				add(u,v);
			}
			Vector<Integer> ans = new Vector<>();
			for(int i=q-1;i>=0;i--) {
				int[] qu = ask.get(i);
				int op = qu[0],u=qu[1],v=qu[2];
				if(op==2) {
					if(find(u)!=find(v)) ans.add(0);
					else ans.add(1);
				}
				else {
					if(edge.contains(1L*u*maxn+v))add(u,v);
				}
			}
			for(int i=ans.size()-1;i>=0;i--) {
				pw.println(ans.get(i)==1?"Yes":"No");
			}
		}
	}
	
	static class Input {
		Input(InputStream in) { this.in = in; } InputStream in;
		byte[] bb = new byte[1 << 15]; int i, n;
		byte getc() {
			if (i == n) {
				i = n = 0;
				try { n = in.read(bb); } catch (IOException e) {}
			}
			return i < n ? bb[i++] : 0;
		}
		int nextI() {
			byte c = 0; while (c <= ' ') c = getc();
			int f=1;
			int a = 0; while (c > ' ') { if(c=='-') {f=-1;c = getc();continue;}a = a * 10 + c - '0'; c = getc(); }
			return a*f;
		}
		long nextL() {
			byte c = 0; while (c <= ' ') c = getc();
			int f=1;
			long a = 0; while (c > ' ') { if(c=='-') {f=-1;c = getc();continue;}a = a * 10 + c - '0'; c = getc(); }
			return a*f;
		}
		byte[] cc = new byte[1 << 7];
		String next() {
			byte c = 0; while (c <= ' ') c = getc();
			int k = 0;
			while (c > ' ') {
				if (k == cc.length) cc = Arrays.copyOf(cc, cc.length << 1);
				cc[k++] = c; c = getc();
			}
			return new String(cc, 0, k);
		}
	}
	static Input sc = new Input(System.in);
	static String S() throws IOException {
		String res=bf.readLine();
		while(res.equals("")) res = bf.readLine();
		return res;
	}
}

#include <bits/stdc++.h>
using namespace std;
using PII = pair<int, int>;
unordered_map<int, int> p;

int find(int x){
    if(p[x] != x) p[x] = find(p[x]);
    return p[x];
}
void merge(int u, int v){
    p[find(u)] = find(v);
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, m, q;
    cin >> n >> m >> q;
    set<PII> friends;
    for(int i = 0; i < m; ++i){
        int u, v;
        cin >> u >> v;
        if(u > v) swap(u, v);
        p[u] = u, p[v] = v;
        friends.insert({u, v});
    }
    vector<tuple<int, int, int>> que;
    set<tuple<int, int, int>> del;
    for(int i = 0; i < q; ++i){
        int op, u, v;
        cin >> op >> u >> v;
        if(u > v) swap(u, v);
        p[u] = u, p[v] = v;
        que.push_back({op, u, v});
        del.insert({op, u, v});
    }
    for(auto [u, v]: friends){
        tuple<int, int, int> x = {1, u, v};
        if(del.count(x)) continue;
        merge(u, v);
    }
    vector<int> ans;
    for(int i = q - 1; i >= 0; --i){
        auto [op, u, v] = que[i];
        if(op == 1 && friends.count({u, v})){
            merge(u, v);
        }else if(op == 2){
            u = find(u), v = find(v);
            ans.push_back(u == v);
        }
    }
    reverse(ans.begin(), ans.end());
    for(int ok: ans) cout << (ok ? "Yes" : "No") << '\n';
    return 0;
}

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int n = in.nextInt();
            int m = in.nextInt();
            int q = in.nextInt();

            long MOD = 1000000001;
            Set<Long> edgesSet = new HashSet<>();
            while (m-- > 0) {
                int node1 = in.nextInt();
                int node2 = in.nextInt();
                edgesSet.add(node1 * MOD + node2);
            }
            int[][] ops = new int[q][3];
            while (q-- > 0) {
                ops[q][0] = in.nextInt();
                ops[q][1] = in.nextInt();
                ops[q][2] = in.nextInt();
                if (ops[q][0] == 1) {
                    long edgeNum1 = ops[q][1] * MOD + ops[q][2];
                    long edgeNum2 = ops[q][2] * MOD + ops[q][1];
                    if (edgesSet.contains(edgeNum1)) {
                        edgesSet.remove(edgeNum1);
                    } else if (edgesSet.contains(edgeNum2)) {
                        edgesSet.remove(edgeNum2);
                    } else {
                        ops[q][0] = 3;
                    }
                }
            }

            UnionFind uf = new UnionFind(n);
            for (long edge: edgesSet) {
                int a = (int) (edge / MOD);
                int b = (int) (edge % MOD);
                uf.union(a - 1, b - 1);
            }
            List<Boolean> list = new ArrayList<>();
            for (int[] op: ops) {
                if (op[0] == 1) {
                    uf.union(op[1] - 1, op[2] - 1);
                } else if (op[0] == 2) {
                    list.add(uf.find(op[1] - 1) == uf.find(op[2] - 1));
                }
            }
            for (int i = list.size() - 1; i >= 0; i--) {
                String output = list.get(i)? "Yes": "No";
                System.out.println(output);
            }
        }
    }

    static class UnionFind {
        Map<Integer, Integer> repre;
        Map<Integer, Integer> rank;

        public UnionFind(int n) {
            repre = new HashMap<>();
            rank = new HashMap<>();
        }

        public int find(int x) {
            int xParent = repre.getOrDefault(x, x);
            if (xParent != x) {
                repre.put(x, find(xParent));
            }
            return repre.getOrDefault(x, x);
        }

        public void union(int x, int y) {
            int rootX = find(x), rootY = find(y);
            if (rootX == rootY) return;
            int xRank = rank.getOrDefault(rootX, 0);
            int yRank = rank.getOrDefault(rootY, 0);
            if (xRank < yRank) {
                repre.put(rootX, rootY);
            } else if (xRank > yRank) {
                repre.put(rootY, rootX);
            } else {
                repre.put(rootX, rootY);
                rank.put(rootY, yRank + 1);
            }
        }
    }
}

#include <bits/stdc++.h>
using namespace std;

const int N = 1e5+10;
unordered_set<string> start_edge, res_edge;
unordered_map<string, int> first_delet; // 维护第一次删除边的位置
int n, q, m;
unordered_map<int,int> p;
stack<string> query; 

struct Op {
    int op;
    int u;
    int v;
}ops[N];

int find(int x)
{
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

pair<int,int> get_edges(string s) {
    pair<int,int> res;
    for (int i = 0; i < s.size(); i ++) {
        if (s[i] == ',') {
            res.first = stoi(s.substr(0,i));
            res.second = stoi(s.substr(i+1));
            break;
        }
    }
    return res;
}
int main() {
    cin >> n >> m >> q;
    while (m --) {
        int u, v;
        cin >> u >> v;
        if (u > v) {
            int tmp = u;
            u = v;
            v = tmp;
        }
        p[u] = u;
        p[v] = v;
        string entry = to_string(u) + "," + to_string(v);
        start_edge.insert(entry);
        res_edge.insert(entry);
    }
    for (int i = 1; i <= q; i ++) {
        int op, u , v;
        cin >> op >> u >> v;
        if (u > v) {
            int tmp = u;
            u = v;
            v = tmp;
        }
        ops[i] = {op, u, v};
        if (op == 1) {
            // 淡忘
            string entry = to_string(u) + "," + to_string(v);
            if (res_edge.find(entry) != res_edge.end())
            {
                res_edge.erase(entry); // 删掉这条边
                first_delet[entry] = i; // 也是第一次删除的
            }
        }
    }
    // 构造最终的并查集
    // for (int i = 1; i <= n; i ++) p[i] = i;
    
    for (auto & node : res_edge) {
        // 解析这个字符串得到两条边
        auto edges = get_edges(node);
        int u = edges.first, v = edges.second;
        int a = find(u), b = find(v);
        if (a != b) {
            p[a] = b;
        }
    }
    
    // 从后往前查询，结果保留在栈中
    for (int i = q; i >= 1; i --) {
        int op = ops[i].op, u = ops[i].u, v = ops[i].v;
        if (u > v) {
            int tmp = u;
            u = v;
            v = tmp;
        }
        if (op == 2) {
            // 查询
            int a = find(u), b = find(v);
            if (a != b || a == 0) query.push("No");
            else query.push("Yes");
        } else {
            // 先看有没有这条边
            string entry = to_string(u) + "," + to_string(v);
            if (first_delet.find(entry) != first_delet.end() && first_delet[entry] == i) {
                // 删除过这条边，而且是在这个位置被删除的, 要把这条边加进去
                int a = find(u), b = find(v);
                if (a != b) {
                    p[a] = b;
                }
            } 
        }
    }
    while (!query.empty()) {
        cout << query.top() << "\n";
        query.pop();
    }
    return 0;
    
}

package main

import (
	"bufio"
	"fmt"
	"os"
)

type oper struct {
	op, a, b int
}

type bian struct {
	a, b int
}

func main() {
	var n, m, q int
	fmt.Scan(&n, &m, &q)
	pre := make(map[int]int)
	
	friend := make(map[int64]*bian, m)
	del := make(map[int64]bool, q)
	ops := make([]*oper, 0, q)
	in := bufio.NewReader(os.Stdin)
	for i := 0; i < m; i++ {
		var u, v int
		fmt.Fscan(in, &u, &v)
        pre[u] = u
		pre[v] = v
		friend[makeKey(u, v)] = &bian{u, v}
	}

	for i := 0; i < q; i++ {
		var op, a, b int
		fmt.Fscan(in, &op, &a, &b)
		if op == 1 {
			del[makeKey(a, b)] = true
		}
		ops = append(ops, &oper{op, a, b})
	}

	for _, b := range friend {
		ba, bb := b.a, b.b
		if !del[makeKey(ba, bb)] {
			join(pre, ba, bb)
		}
	}

	ans := make([]bool, 0, q)
	for i := len(ops) - 1; i >= 0; i-- {
		op := ops[i]
		if op.op == 1 && friend[makeKey(op.a, op.b)] != nil {
			join(pre, op.a, op.b)
		} else if op.op == 2 {
			if find(pre, op.a) == find(pre, op.b) {
				ans = append(ans, true)
			} else {
				ans = append(ans, false)
			}
		}
	}

	for i := len(ans) - 1; i >= 0; i-- {
		if ans[i] {
			fmt.Println("Yes")
		} else {
			fmt.Println("No")
		}
	}

}

func find(p map[int]int, a int) int {
    // 可能有不在初始化map的节点进行操作
    //===============
    if p[a] == 0{
        p[a] = a
    }
    //===============
	if p[a] != a {
		p[a] = find(p, p[a])
	}
	return p[a]
}

func join(p map[int]int, a, b int) {
	pa, pb := find(p, a), find(p, b)
	if pa != pb {
		p[pb] = pa
	}
}

func makeKey(a, b int) int64 {
	if a > b {
		return int64(a)<<32 | int64(b)
	}
	return int64(b)<<32 | int64(a)
}

#include "bits/stdc++.h"

const int N = 3e5 + 10;
const int M = 1010;
typedef long long ll;
using namespace std;
#define TEST int t; cin >> t; while(t--) solve();
#define endl '\n'
#define yes cout << "YES" << endl
#define no cout << "NO" << endl
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
typedef pair<int, ll> pil;
int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;

int n, a[N], q, m;
int p[N], f[N];


int find(int x) {
    return p[x] == x ? p[x] : p[x] = find(p[x]);
}

int select(vector<int>& v, int k) {
    int l = 0, r = v.size() - 1;
    while (l < r) {
        int mid = l + r >> 1;
        if (v[mid] < k) l = mid + 1;
        else r = mid;
    }
    if (v[l] != k) return -1;
    return l;
}


void solve() {
    cin >> n >> m >> q;
    int u, v, op;
    vector<pii> tmp;
    vector<int> alls;
    map<pii, int> mp;
    while (m--) {
        cin >> u >> v;
        int st = min(u, v), ed = max(u, v);
        alls.emplace_back(st);
        alls.emplace_back(ed);
        tmp.emplace_back(st, ed);
        mp[pii(st, ed)]++;
    }
    sort(alls.begin(), alls.end());
    alls.erase(unique(alls.begin(), alls.end()), alls.end());
    for (int i = 0; i < N; i++) p[i] = i;
    
    vector<vector<int>> ops;
    for (int i = 0; i < q; i++) {
        cin >> op >> u >> v;
        int st = min(u, v), ed = max(u, v);
        ops.emplace_back(vector<int>{op, st, ed});
        if (op == 1) {
            if (mp.find(pii(st, ed)) != mp.end()) {
                if (mp[pii(st, ed)] <= 0) continue;
                mp[pii(st, ed)]--;
                f[i] = 1;
            }
        }
    }
    
    for (auto& [k, v] : mp) {
        if (v <= 0) continue;
        u = k.first; v = k.second;
        int p1 = find(select(alls, u)), p2 = find(select(alls, v));
        p[p1] = p2;
    }
    
    stack<string> ans;
    for (int i = q - 1; i >= 0; i--) {
        u = ops[i][1]; v = ops[i][2];
        int st = min(u, v), ed = max(u, v);
        if (ops[i][0] == 1 && f[i]) {
            int p1 = find(select(alls, st)), p2 = find(select(alls, ed));
            p[p1] = p2;
        }
        if (ops[i][0] == 2) {
            int idx1 = select(alls, st), idx2 = select(alls, ed);
            if (idx1 == -1 || idx2 == -1) ans.push("No");
            else {
                int p1 = find(idx1), p2 = find(idx2);
                if (p1 == p2) ans.push("Yes");
                else ans.push("No");
            }
        }
    }
    while (ans.size()) {
        cout << ans.top() << endl;
        ans.pop();
    }
}


int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    //TEST
    solve();
    return 0;
}

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

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws Exception {
        //快速输入
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        
        StringBuilder build = new StringBuilder();
        String line = null;
        String[] s = in.readLine().split(" ");
        int n = Integer.valueOf(s[0]);
        int m = Integer.valueOf(s[1]);
        int q = Integer.valueOf(s[2]);
        //采用map来构建并查集，避免爆内存
        Map<Integer, Integer> map = new HashMap<>(2 * m);
        //存储唯一关系组 一个long可存储一组关系
        Set<Long> set = new HashSet<>(2 * m);

        for (int i = 0; i < m + q; i++) {
            build.append(in.readLine());
            build.append(" ");
        }
        in.close();
        StringTokenizer token = new StringTokenizer(build.toString());
        for (int i = 0; i < m; i++) {
            int a = Integer.valueOf(token.nextToken());
            int b = Integer.valueOf(token.nextToken());
            set.add(getId(a, b));
        }
        int[][] ts = new int[q][4];
        for (int i = 0; i < q; i++) {
            int f = Integer.valueOf(token.nextToken());
            int a = Integer.valueOf(token.nextToken());
            int b = Integer.valueOf(token.nextToken());
            ts[i][0] = f;
            ts[i][1] = a;
            ts[i][2] = b;
            if (f == 1) {
                long c = getId(a, b);
                if (set.remove(c)) {
                    ts[i][3] = 1;
                }
            }
        }
         long mod = Integer.MAX_VALUE;
        for (long l : set) {       
            int a = (int)(l & mod);
            int b = (int)((l >> 32) & mod);
            int pa = getP(map, a);
            int pb = getP(map, b);
            map.put(pa, pb);
        }
        build = new StringBuilder();
        for (int i = q - 1; i >= 0; i--) {
            int f = ts[i][0];
            int a = ts[i][1];
            int b = ts[i][2];      
            if (f == 1) {            
                if (ts[i][3] == 1) {
                int pa = getP(map, a);
                int pb = getP(map, b);
                map.put(pa, pb);
                }
                continue;
            }
            int pa = getP(map, a);
            int pb = getP(map, b);
            String sm = (pa == pb) ? "Yes" : "No";
            build.insert(0, '\n');
            build.insert(0, sm);
        }
        //快速输出
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
        writer.write(build.toString());
        writer.flush();
    }

    public static int getP(Map<Integer, Integer> map, int i) {
        
        if (!map.containsKey(i)) {
            map.put(i, i);
            return i;
        }
        int p = map.get(i);
        if (p != i) {
            p = getP(map, p);
            map.put(i, p);
        }
        return p;
    }

    public static long getId(int a, int b) {
            //排序去重
        if (a < b) {
            int mid = b;
            b = a;
            a = mid;
        }
        long r = a;
        r = r << 32;
        r = r | b;
        return r;
    }

}

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	in, out := bufio.NewReader(os.Stdin), bufio.NewWriter(os.Stdout)
	defer out.Flush()
	var n, m, q, op, u, v int
	type record struct {
		op, u, v int
	}
	fmt.Fscan(in, &n, &m, &q)
	type fr struct {
		u, v int
	}
	frs := map[fr]struct{}{}
	for i := 0; i < m; i++ {
		fmt.Fscan(in, &u, &v)
		if u > v {
			u, v = v, u
		}
		frs[fr{u, v}] = struct{}{}
	}
	qs := make([]record, q)
	removedEdges := map[fr]struct{}{}
	for ; q > 0; q-- {
		fmt.Fscan(in, &op, &u, &v)
		qs[q-1] = record{op, u, v}
		if op == 1 {
			if u > v {
				u, v = v, u
			}
			removedEdges[fr{u, v}] = struct{}{}
		}
	}
	// 初始化并查集
	fa := map[int]int{}
	sz := map[int]int{}
	var find func(int) int
	find = func(x int) int {
		if _, ok := fa[x]; !ok {
			// 初始化
			fa[x] = x
			sz[x] = 1
		}
		if x != fa[x] {
			fa[x] = find(fa[x])
		}
		return fa[x]
	}
	union := func(i, j int) {
		x, y := find(i), find(j)
		if x == y {
			return
		}
		if sz[x] > sz[y] {
			x, y = y, x
		}
		sz[y] += sz[x]
		fa[x] = y
	}
	same := func(i, j int) bool {
		x, y := find(i), find(j)
		return x == y
	}
	for k, _ := range frs {
		if _, ok := removedEdges[k]; !ok {
			union(k.u, k.v)
		}
	}
	ans := make([]bool, 0)
	for _, qq := range qs {
		op, u, v = qq.op, qq.u, qq.v
		if op == 2 {
			// 查询
			ans = append(ans, same(u, v))
		} else {
			// 原本存在再加入
			if u > v {
				u, v = v, u
			}
			if _, ok := frs[fr{u, v}]; ok {
				union(u, v)
			}
		}
	}
	for i := len(ans) - 1; i >= 0; i-- {
		if ans[i] {
			fmt.Fprintln(out, "Yes")
		} else {
			fmt.Fprintln(out, "No")
		}
	}
}

func max(a, b int) int {
	if a < b {
		return b
	}
	return a
}
func min(a, b int) int {
	if a > b {
		return b
	}
	return a
}

1. 朋友的朋友可以介绍，所以要使用并查集；因为连通图不具备快速查询弱关系的能力。
2. 关系不断地删除，并查集不能处理删除问题，所以用反向并查集。先确定最终状态，再倒过来应用操作，淡忘关系变成建立关系。
3. 由于是10^9，所以需要使用哈希表。

struct dsu {
  unordered_map<ULL, ULL> fa;

  ULL find(ULL x) {
    auto it = fa.find(x);
    if (it == fa.end()) {
      fa[x] = x;
      return x;
    }
    return it->second == x ? x : (fa[x] = find(it->second));
  }

  void unite(ULL x, ULL y) {
    x = find(x);
    y = find(y);
    fa[y] = x;
  }

  bool isUnited(ULL x, ULL y) {
    return find(x) == find(y);
  }
};

int main() {
  ULL n;
  int m, q;
  cin >> n >> m >> q;
  map<pair<ULL, ULL>, int> relations;
  ULL u, v;
  for (int i = 0; i < m; i++) {
    cin >> u >> v;
    if (u > v) swap(u ,v);
    relations[{u, v}]++;
  }
  
  vector<tuple<int, ULL, ULL>>ops;
  ULL op;
  for (int i = 0; i < q; i++) {
    cin >> op >> u >> v;
    ops.push_back({op, u, v});
    if (u > v) swap(u, v);
    if (op == 1) relations[{u, v}]--;
  }

  dsu dset;
  for (auto& [key, val]: relations) {
    if (val > 0) {
      dset.unite(key.first, key.second);
    }
  }

  stack<bool> res;
  for (int i = q-1; i >= 0; i--) {
    auto& [op, u, v] = ops[i];
    if (op == 2) {
      res.push(dset.isUnited(u, v));
    } else if (op == 1) {
      if (u > v) swap(u, v);
      relations[{u, v}]++;
      if (relations[{u, v}] == 1) dset.unite(u, v);
    }
  }
  while (!res.empty()) {
    cout << (res.top() ? "Yes" : "No") << endl;
    res.pop();
  }

  return 0;
}