Submission #301880

#	Time	Username	Problem	Language	Result	Execution time	Memory
301880		Nnandi	Werewolf (IOI18_werewolf)	C++14	49 / 100	1321 ms	79596 KiB

werewolf

#include "werewolf.h"
#include<bits/stdc++.h>

using namespace std;

const int maxn = 200005;
int tab_min[maxn][22], tab_max[maxn][22];
vector<int> graf[maxn];

bool volte_s[maxn], volte_e[maxn];

void reset(int n) {
    for(int i=0;i<n;i++) {
        volte_s[i] = false;
        volte_e[i] = false;
    }
}

void bejar_s(int start, int l) { //minimum l
    if(start < l) return;
    volte_s[start] = true;
    for(int s:graf[start]) {
        if(!volte_s[s] && l <= s)  {
            bejar_s(s,l);
        }
    }
}

void bejar_e(int start, int r) { //maximum r
    if(r < start) return;
    volte_e[start] = true;
    for(int s:graf[start]) {
        if(!volte_e[s] && s <= r)  {
            bejar_e(s,r);
        }
    }
}

void sorrend(int start, int from, vector<int> &v) {
    v.push_back(start);
    for(int s:graf[start]) {
        if(s != from) {
            sorrend(s,start,v);
        }
    }
    return;
}

int get_max(int u, int v) {
    if(u > v) swap(u,v);
    int dist = v - u + 1;
    int p = (int)log2(dist);
    return max(tab_max[u][p],tab_max[v-(1<<p)+1][p]);
}

int get_min(int u, int v) {
    if(u > v) swap(u,v);
    int dist = v - u + 1;
    int p = (int)log2(dist);
    return min(tab_min[u][p],tab_min[v-(1<<p)+1][p]);
}

vector<int> check_validity(int N, vector<int> X, vector<int> Y,
                                vector<int> S, vector<int> E,
                                vector<int> L, vector<int> R) {
      int q = S.size();
      int m = X.size();
      int n = N;
      vector<int> answer(q,0);
      vector<int> d(n,0);
      for(int i=0;i<m;i++) {
            graf[X[i]].push_back(Y[i]);
            graf[Y[i]].push_back(X[i]);
            d[X[i]]++;
            d[Y[i]]++;
      }

      if(m == n-1 && n > 3000 ) {
            int it = 0;
            for(int i=0;i<n;i++) {
                if(d[i] == 1) it = i;
            }
            vector<int> v;
            vector<int> hely(n);
            sorrend(it,it,v);

            for(int i=0;i<n;i++) {
                hely[v[i]] = i;
                tab_min[i][0] = v[i];
                tab_max[i][0] = v[i];
            }
            for(int j=1;j<22;j++) {
                for(int i=0;i<n;i++) {
                    tab_min[i][j] = min(tab_min[i][j-1],tab_min[min(n-1,i + (1<<(j-1)))][j-1]);
                    tab_max[i][j] = max(tab_max[i][j-1],tab_max[min(n-1,i + (1<<(j-1)))][j-1]);
                }
            }

            //return answer;

            for(int i=0;i<q;i++) {
                int b1 = hely[S[i]];
                int b2 = hely[E[i]];
                int l = L[i];
                int r = R[i];
                if(b1 < b2) {
                    while(b1 < b2) {
                        int mid = (b1 + b2) / 2;
                        int mini = get_min(hely[S[i]],mid);
                        int maxi = get_max(mid,hely[E[i]]);
                        if(mini < l) {
                            b2 = mid;
                        }
                        else if(r < maxi) {
                            b1 = mid + 1;
                        }
                        else {
                            b1 = mid;
                            b2 = mid;
                        }
                    }
                }
                else {
                    while(b1 > b2) {
                        int mid = (b1 + b2) / 2;
                        int mini = get_min(hely[S[i]],mid);
                        int maxi = get_max(mid,hely[E[i]]);
                        if(mini < l) {
                            b2 = mid+1;
                        }
                        else if(r < maxi) {
                            b1 = mid;
                        }
                        else {
                            b1 = mid;
                            b2 = mid;
                        }
                    }
                }
                int mini = get_min(hely[S[i]],b1);
                int maxi = get_max(b1,hely[E[i]]);
                answer[i] = (l <= mini && maxi <= r ? 1 : 0);
            }

            return answer;
      }

      for(int i=0;i<q;i++) {
        reset(n);
        bejar_s(S[i],L[i]);
        bejar_e(E[i],R[i]);
        for(int j=0;j<n;j++) {
            if(volte_e[j] && volte_s[j]) {
                answer[i] = 1;
            }
        }
      }
      return answer;
}

• Subtask 1: 7 / 7
• Subtask 2: 8 / 8
• Subtask 3: 34 / 34
• Subtask 4: 0 / 51