1

#include <vector>

const int N = 200010;
int p[N];

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


class Solution {
public:
    bool validPath(int n, vector<vector<int> >& sides, int start, int end) {
        for (int i = 1; i <= n; i ++ ) p[i] = i;

        for(auto& vec : sides){
            int a = vec[0], b = vec[1];
            p[find(a)] = p[find(b)];
        }

        if(find(start) == find(end)) return true;
        return false;
    }
};

2

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>

using namespace std;

class Solution {
public:
    bool flag = false;

    float op(int a, int b, int c){
        if(c == 1) return a+b;
        if(c == 2) return a-b;
        if(c == 3) return a*b;
        if(c == 4) {
            if(b == 0) { flag = true; return 0;}
            else return a/b;
        }
        return 0;
    }

    bool judge(float a){
        if(abs(a - 24) < 0.0001) return true;
        return false;
    }

    bool compute24(vector<int>& num) {
        int len = num.size();

        for(int i=0; i<len; i++)
        for(int j=0; j<len; j++)
        for(int k=0; k<len; k++){

            if(i == j || i == k || j == k) continue;

            float ans;
            for(int c=1; c<=4; c++){
                ans = op(num[i], num[j], c);
                if(flag) {flag = false; continue;}
                for(int d=1; d<=4; d++){
                    ans = op(ans, num[k], d);
                    if(flag) {flag = false; continue;}
                    if(judge(ans)) return true;
                }

            }
        }

        return false;

    }
};