Submission #1247647

#	Time	Username	Problem	Language	Result	Execution time	Memory
1247647		CrabCNH	도로 개발 (JOI15_road_development)	C++20	100 / 100	326 ms	42368 KiB

road_development

#include <bits/stdc++.h>

#define task     "BriantheCrab"

#define int    long long
#define pii    pair <int, int>
#define fi     first
#define se     second
#define szf    sizeof
#define sz(s)  (int)((s).size())
#define all(v) (v).begin(), (v).end()

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;

using namespace std;

template <class T> void minimize (T &t, T f) {if (t > f) t = f;}
template <class T> void maximize (T &t, T f) {if (t < f) t = f;}

const int maxN = 1e5 + 5;
const int maxQ = 3e5 + 5;
const int inf = 1e18 + 7;
const int mod = 1e9 + 7;

// khong tu code thi khong kha len duoc dau

struct Query {
    int t, u, v;
};

struct DSU {
    int par[maxN], sz[maxN];
    
    inline void init (int _n) {
        for (int i = 1; i <= _n; i ++) {
            par[i] = i;
            sz[i] = 1;
        }
    }
    
    int getRoot (int u) {
        if (par[u] == u) {
            return u;
        }
        return (par[u] = getRoot (par[u]));
    }
    
    inline void merge (int u, int v) {
        u = getRoot (u);
        v = getRoot (v);
        if (u == v) {
            return;
        }
        if (sz[u] < sz[v]) {
            swap (u, v);
        }
        par[v] = u;
        sz[u] += sz[v];
        return;
    }
};

struct HLD {
    struct ST {
        int st[maxN * 4];
        int lazy[maxN * 4];
    
        ST () {
            memset (st, 0, szf (st));
            for (int i = 0; i < maxN * 4; i ++) {
                lazy[i] = -1;
            }
        };
        
        void push (int id, int l, int r) {
            if (lazy[id] != -1) {
                int mid = (l + r) >> 1;
                st[id * 2] = lazy[id] * (mid - l + 1);
                lazy[id * 2] = lazy[id];
                st[id * 2 + 1] = lazy[id] * (r - (mid + 1) + 1);
                lazy[id * 2 + 1] = lazy[id];
            }
            lazy[id] = -1;
        }
        
        void upd (int id, int l, int r, int u, int v, int val) {
            if (v < l || u > r) {
                return;
            }
            if (u <= l && r <= v) {
                st[id] = val * (r - l + 1);
                lazy[id] = val;
                return;
            }
            int mid = (l + r) >> 1;
            push (id, l, r);
            upd (id * 2, l, mid, u, v, val);
            upd (id * 2 + 1, mid + 1, r, u, v, val);
            st[id] = st[id * 2] + st[id * 2 + 1];
        }
        
        int get (int id, int l, int r, int u, int v) {
            if (v < l || r < u) {
                return 0;
            }
            if (u <= l && r <= v) {
                return st[id];
            }
            int mid = (l + r) >> 1;
            push (id, l, r);
            int tL = get (id * 2, l, mid, u, v);
            int tR = get (id * 2 + 1, mid + 1, r, u, v);
            return tL + tR;
        }
    };
    
    int n;
    int cnt = 0;
    int pos[maxN];
    int par[maxN], sz[maxN], head[maxN];
    int depth[maxN];
    vector <int> adj[maxN];
    ST T;
     
    void dfs (int u, int p) {
        sz[u] = 1;
        for (auto v : adj[u]) {
            if (v != p) {
                par[v] = u;
                depth[v] = depth[u] + 1;
                dfs (v, u);
                sz[u] += sz[v];
            }
        }
    }
     
    void build (int u, int p, int h) {
        head[u] = h;
        cnt ++;
        pos[u] = cnt;
        int nxt = 0, curmax = 0;
        for (auto v : adj[u]) {
            if (v == p) {
                continue;
            }
            if (sz[v] > curmax) {
                curmax = sz[v];
                nxt = v;
            }
        }
        
        if (nxt != 0) {
            build (nxt, u, h);
        }

        for (auto v : adj[u]) {
            if (v != nxt && v != p) {
                build (v, u, v);
            }
        }
    }
     
    inline void updPath (int u, int v, int x) {
        while (head[u] != head[v]) {
            if (depth[head[u]] < depth[head[v]]) {
                swap (u, v);
            }
            int st = pos[head[u]];
            if (par[head[u]] == 0) {
                st = pos[head[u]] + 1;
            }
            if (st <= pos[u]) {
                T.upd (1, 1, n, st, pos[u], x);
            }
            u = par[head[u]];
            if (u == 0) {
                break;
            }
        }
        if (u == 0 || v == 0) {
            return;
        }
        //cout << "cc " << u << ' ' << v << '\n';
        if (depth[u] > depth[v]) {
            swap (u, v);
        }
        if (pos[u] + 1 <= pos[v]) {
            T.upd (1, 1, n, pos[u] + 1, pos[v], x);
        }
    }
    
    inline int getPath(int u, int v) {
        int res = 0;
        if (u == 0 || v  == 0) {
            return 0;
        }
        while (head[u] != head[v]) {
            if (depth[head[u]] < depth[head[v]]) {
                swap (u, v);
            }
            int st = pos[head[u]];
            if (par[head[u]] == 0) {
                st = pos[head[u]] + 1;
            }
            if (st <= pos[u]) {
                res += T.get (1, 1, n, st, pos[u]);
            }
            u = par[head[u]];
            if (u == 0) {
                break;
            }
        }
        if (u == 0 || v == 0) {
            return 0;
        }
        if (depth[u] > depth[v]) {
            swap (u, v);
        }
        if (pos[u] + 1 <= pos[v]) {
            res += T.get (1, 1, n, pos[u] + 1, pos[v]);
        }
        return res;
    }
};

int n, q;
Query que[maxQ];
DSU dsu;
HLD L; 
vector <pii> cc;

void print () {
    cout << "debug ";
    for (auto [u, v] : cc) {
        cout << L.getPath (u, v) << ' ';
    }
    cout << '\n';
}

void solve () {
    cin >> n >> q;
    dsu.init (n);
    for (int i = 1; i <= q; i ++) {
        int t, u, v;
        cin >> t >> u >> v;
        que[i] = {t, u, v};
        if (t == 1) {
            if (dsu.getRoot (u) != dsu.getRoot (v)) {
                dsu.merge (u, v);
                L.adj[u].push_back (v);
                L.adj[v].push_back (u);
                cc.push_back ({u, v});
                //cout << u << ' ' << v << '\n';
            }
        }
    } 
    L.n = n;
    for (int i = 1; i <= n; i ++) {
        int rt = dsu.getRoot (i);
        if (i == rt) {
            //cout << "rt " << i << '\n';
            L.dfs (i, 0);
            L.build (i, 0, i);
        }
    }
    dsu.init (n);
    for (int i = 1; i <= q; i ++) {
        auto [t, u, v] = que[i];
        if (t == 1) {
            if (dsu.getRoot (u) != dsu.getRoot (v)) {
                dsu.merge (u, v);
                //cout << "add " << u << ' ' << v << '\n';
                L.updPath (u, v, 1);
                //print ();
            }
            else {
                //cout << "del " << u << ' ' << v << '\n';
                L.updPath (u, v, 0);
                //cout << "bye " << i << '\n';
                //print ();
            }
        }
        else {
            if (dsu.getRoot (u) != dsu.getRoot (v)) {
                cout << -1 << '\n';
                continue;
            }
            cout << L.getPath (u, v) << '\n';
        }
    }
    return;
}

signed main () {
    cin.tie (nullptr) -> sync_with_stdio (false);
    if (fopen (task".inp", "r")) {
        freopen (task".inp", "r", stdin);
        freopen (task".out", "w", stdout);
    }
    int t = 1;
    //cin >> t;
    while (t --) {
        solve ();
    } 
    return 0;
}
// thfv

Compilation message (stderr)

road_development.cpp: In function 'int main()':
road_development.cpp:299:17: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  299 |         freopen (task".inp", "r", stdin);
      |         ~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
road_development.cpp:300:17: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  300 |         freopen (task".out", "w", stdout);
      |         ~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~

• Subtask 1: 10 / 10
• Subtask 2: 25 / 25
• Subtask 3: 25 / 25
• Subtask 4: 25 / 25
• Subtask 5: 15 / 15