oj.uz

Submission #1013453

# Submission time Handle Problem Language Result Execution time Memory
1013453 2024-07-03T14:44:22 Z Ludissey Parachute rings (IOI12_rings) C++14
0 / 100
 1000 ms 155424 KB 
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define sz(a) (int)a.size()
#define all(a) a.begin(), a.end()
int n;
bool hasloop=false;
vector<vector<int>> neigh;
vector<int> visited;
vector<int> parent;
vector<int> pr;
vector<int> sz;
vector<int> crit;
vector<int> incycle;
vector<int> iscycle;
vector<int> orig;
int timer=0;
int exceptation=-1;
bool cycl=0;
int cc=0;
int c=0;
int upds=0;

int getParent(int a) { 
    if(parent[a]==a) return a;
    else return parent[a]=getParent(parent[a]); 
}

void unite(int a, int b){
    a=getParent(a); b=getParent(b);
    if(a==b) return;
    if(sz[b]>sz[a]) swap(a,b);
    sz[a]+=sz[b];
    parent[a]=b;
}

void detect_cycle(int x, int p) {
    if(visited[x]==2) return;
    if (visited[x] == 1) {
        vector<int> v;
        iscycle[x]=true;
        incycle.push_back(x);
        int cr=pr[x];
        while (cr!=x) {
            incycle.push_back(cr);
            iscycle[cr]=true;
            cr=pr[cr];
        } 
        return;
    }
    pr[x]=p;
    visited[x]=1;
    for (int to : neigh[x]) {
        if (to==p) continue;
        detect_cycle(to,x);
    }
    visited[x]=2;
}


void get_origin(int x, int p,int og) {
    if(orig[x]>=0) return;
    orig[x]=og;
    for (int to : neigh[x]) {
        if (to==p||iscycle[to]) continue;
        get_origin(to,x,orig[x]);
    }
}

void Init(signed N_) {
    n = N_;
    parent.resize(n);
    visited.resize(n,0);
    neigh.resize(n);
    orig.resize(n,-1);
    cc=0;
    c=n;
    sz.resize(n,1);
    iscycle.resize(n,0);
    pr.resize(n,-1);
    crit.resize(n,0);
    upds=0;
    for (int i = 0; i < n; i++) parent[i]=i;
}

void update_crit(int X){
    if(sz(neigh[X])==3){
        crit[neigh[X][0]]++;
        crit[neigh[X][1]]++;
        crit[neigh[X][2]]++;
        crit[X]++;
        upds++;
        c=0;
        if(crit[neigh[X][0]]==upds) c++;
        if(crit[neigh[X][1]]==upds) c++;
        if(crit[neigh[X][2]]==upds) c++;
        if(crit[X]==upds) c++;
    }else if(sz(neigh[X])>3){
        crit[X]++;
        upds++;
        c=0;
        if(crit[X]==upds) c++;
    }
}
void case1(int A, int B){ //two vertex of different sets O(1);
    unite(A,B);
    if(orig[A]>=0&&orig[B]<0) get_origin(B,A,orig[A]);
    else if(orig[B]>=0&&orig[A]<0) get_origin(A,B,orig[B]);
    update_crit(A);
    update_crit(B);
}
void case2(int A, int B){ //two vertex of same sets !! NO CYCLE !! O(N+M)
    detect_cycle(A,B);
    cycl=1;
    upds++;
    c=0;
    for (int i = 0; i < sz(incycle); i++){
        crit[incycle[i]]++;
        if(crit[incycle[i]]==upds) c++;
    } 
    visited.clear();
    visited.resize(n,0);
    for (int i = 0; i < sz(incycle); i++) get_origin(incycle[i],-1,incycle[i]);
    case1(A,B);
}
//UPD
void case3(int A, int B){ //two vertex of same sets !! CYCLE !! O(1)
    //cerr << "case 3";
    if(orig[A]<0||orig[B]<0) { upds++; return; }
    upds++;
    c=0;
    crit[orig[A]]++;
    if(crit[orig[A]]==upds) c++;
    if(orig[A]!=orig[B]) {
        crit[orig[B]]++;
        if(crit[orig[B]]==upds) c++;
    }
    update_crit(A);
    update_crit(B);
    update_crit(orig[A]);
    update_crit(orig[B]);
}
void Link(signed A, signed B) {
    neigh[A].push_back(B);
    neigh[B].push_back(A);
    if(getParent(A)==getParent(B)){
        if(cycl) case3(A,B);
        else case2(A,B);
    }else{
        case1(A,B);
    }
}

signed CountCritical() {
    return c;
}

Subtask #1
0 / 20.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 344 KB Output is correct
2 Correct 1 ms 860 KB Output is correct
3 Correct 3 ms 1000 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Correct 1 ms 860 KB Output is correct
6 Correct 2 ms 1116 KB Output is correct
7 Correct 1 ms 856 KB Output is correct
8 Incorrect 2 ms 860 KB Output isn't correct
9 Halted 0 ms 0 KB -

Subtask #2
0 / 17.0

# Verdict Execution time Memory Grader output
1 Correct 278 ms 64080 KB Output is correct
2 Correct 628 ms 98196 KB Output is correct
3 Correct 1000 ms 123620 KB Output is correct
4 Correct 806 ms 122404 KB Output is correct
5 Correct 812 ms 123972 KB Output is correct
6 Correct 966 ms 155424 KB Output is correct
7 Correct 881 ms 121936 KB Output is correct
8 Correct 711 ms 114652 KB Output is correct
9 Correct 724 ms 122312 KB Output is correct
10 Incorrect 490 ms 120308 KB Output isn't correct
11 Halted 0 ms 0 KB -

Subtask #3
0 / 18.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 344 KB Output is correct
2 Correct 1 ms 860 KB Output is correct
3 Correct 3 ms 1000 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Correct 1 ms 860 KB Output is correct
6 Correct 2 ms 1116 KB Output is correct
7 Correct 1 ms 856 KB Output is correct
8 Incorrect 2 ms 860 KB Output isn't correct
9 Halted 0 ms 0 KB -

Subtask #4
0 / 14.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 344 KB Output is correct
2 Correct 1 ms 860 KB Output is correct
3 Correct 3 ms 1000 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Correct 1 ms 860 KB Output is correct
6 Correct 2 ms 1116 KB Output is correct
7 Correct 1 ms 856 KB Output is correct
8 Incorrect 2 ms 860 KB Output isn't correct
9 Halted 0 ms 0 KB -

Subtask #5
0 / 31.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 344 KB Output is correct
2 Correct 1 ms 860 KB Output is correct
3 Correct 3 ms 1000 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Correct 1 ms 860 KB Output is correct
6 Correct 2 ms 1116 KB Output is correct
7 Correct 1 ms 856 KB Output is correct
8 Incorrect 2 ms 860 KB Output isn't correct
9 Halted 0 ms 0 KB -