Submission #570639

#	Time	Username	Problem	Language	Result	Execution time	Memory
570639		doowey	Keys (IOI21_keys)	C++17	0 / 100	12 ms	21460 KiB

keys

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

#define fi first
#define se second
#define mp make_pair


const int N = (int)3e5 + 1;

int par[N];
vector<pii> T[N];
int col[N];
vector<int> vv[N];

int fin(int x){
    if(par[x] == x) return x;
    return par[x]=fin(par[x]);
}

void merge(int u, int v){
    u=fin(u);
    v=fin(v);
    if(u == v) return;
    par[u] = v;
}

bool vis[N];
bool has_key[N];
vector<int> nex[N];

vector<pii> unite;
vector<int> cols;
vector<int> nodes;

void clean(int a, int b){
    unite.push_back(mp(a, b));
    for(auto p : cols){
        has_key[p] = false;
        nex[p].clear();
    }
    cols.clear();
    nodes.clear();
}



void travel(int node){
    if(vis[node]) return;
    queue<int> lis;
    vis[node] = true;
    int init = node;
    while(!lis.empty()){

        node = lis.front();
        nodes.push_back(node);
        lis.pop();
        if(!has_key[col[node]]){
            cols.push_back(col[node]);
        }
        has_key[col[node]] = true;
        for(auto p : nex[col[node]]){
            if(vis[p]) continue;
            if(fin(p) != fin(node)){
                clean(node, p);
                return;
            }
        }
        nex[col[node]].clear();
        for(auto x : T[node]){
            if(vis[x.fi]) continue;
            if(has_key[x.se]){
                if(fin(x.fi) != fin(node)){
                    clean(node, x.fi);
                    return;
                }
                vis[x.fi]=true;
                lis.push(x.fi);
            }
            else{
                cols.push_back(x.se);
                nex[x.se].push_back(x.fi);
            }
        }
    }
    init=fin(init);
    vv[init]=nodes;

    for(auto p : cols){
        has_key[p] = false;
        nex[p].clear();
    }
    cols.clear();
    nodes.clear();
}



vector<int> find_reachable(vector<int> r, vector<int> u, vector<int> v, vector<int> c) {
    int m = u.size();
    int n = r.size();
    for(int i = 0 ; i < n; i ++ ){
        par[i] = i;
        col[i] = r[i];
    }
    for(int i = 0 ; i < m ; i ++ ){
        T[u[i]].push_back(mp(v[i], c[i]));
        T[v[i]].push_back(mp(u[i], c[i]));
    }
    bool changes = true;
    while(changes){
        changes = false;
        for(int i = 0 ; i < n; i ++ ){
            if(vis[i]) continue;
            if(par[i] == i){
                travel(i);
            }
        }
        for(auto x : unite){
            if(fin(x.fi) != fin(x.se)){
                merge(x.fi, x.se);
                changes = true;
            }
        }
        unite.clear();
        for(int i = 0 ; i < n; i ++ ){
            vis[i]=false;
        }
    }
    vector<int> ans(n);
    int reach = n + 1;
    vector<int> smol;
    int go;
    for(int i = 0 ; i < n; i ++ ){
        if(par[i] == i){
            travel(i);
            go = fin(i);
            if(vv[go].size() < reach){
                reach = vv[go].size();
                smol = vv[go];
            }
            else if(vv[go].size() == reach){
                for(auto x : vv[go]){
                    smol.push_back(x);
                }
            }
        }
    }
    for(auto x : smol){
        ans[x] = 1;
    }
    return ans;
}

Compilation message (stderr)

keys.cpp: In function 'std::vector<int> find_reachable(std::vector<int>, std::vector<int>, std::vector<int>, std::vector<int>)':
keys.cpp:142:30: warning: comparison of integer expressions of different signedness: 'std::vector<int>::size_type' {aka 'long unsigned int'} and 'int' [-Wsign-compare]
  142 |             if(vv[go].size() < reach){
      |                ~~~~~~~~~~~~~~^~~~~~~
keys.cpp:146:35: warning: comparison of integer expressions of different signedness: 'std::vector<int>::size_type' {aka 'long unsigned int'} and 'int' [-Wsign-compare]
  146 |             else if(vv[go].size() == reach){
      |                     ~~~~~~~~~~~~~~^~~~~~~~

• Subtask 1: 0 / 9
• Subtask 2: 0 / 11
• Subtask 3: 0 / 17
• Subtask 4: 0 / 30
• Subtask 5: 0 / 33