oj.uz

Submission #729638

# Submission time Handle Problem Language Result Execution time Memory
729638 2023-04-24T10:07:50 Z t6twotwo Werewolf (IOI18_werewolf) C++17
15 / 100
 4000 ms 72180 KB 
#include "werewolf.h"
#include <bits/stdc++.h>
using namespace std;
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 M = X.size();
    int Q = S.size();
    vector<vector<int>> adj(N);
    for (int i = 0; i < M; i++) {
        adj[X[i]].push_back(Y[i]);
        adj[Y[i]].push_back(X[i]);
    }
    if (N <= 3000 && M <= 6000 && Q <= 3000) {
        vector<int> p(N);
        function<int(int)> find = [&](int x) {
            return x == p[x] ? x : p[x] = find(p[x]);
        };
        vector<vector<int>> s(N);
        auto unite = [&](int x, int y) {
            x = find(x);
            y = find(y);
            if (x == y) {
                return;
            }
            if (s[x].size() > s[y].size()) {
                swap(x, y);
            }
            for (int z : s[x]) {
                p[z] = y;
                s[y].push_back(z);
            }
        };
        for (int i = 0; i < N; i++) {
            p[i] = i;
            s[i] = {i};
        }
        vector hi(N, vector<int>(N, -1));
        for (int x = N - 1; x >= 0; x--) {
            hi[x][x] = x;
            for (int y : adj[x]) {
                if (y < x || find(x) == find(y)) {
                    continue;
                }
                for (int u : s[find(x)]) {
                    for (int v : s[find(y)]) {
                        hi[u][v] = x;
                        hi[v][u] = x;
                    }
                }
                unite(x, y);
            }
        }
        for (int i = 0; i < N; i++) {
            p[i] = i;
            s[i] = {i};
        }
        vector lo(N, vector<int>(N, -1));
        for (int x = 0; x < N; x++) {
            lo[x][x] = x;
            for (int y : adj[x]) {
                if (y > x || find(x) == find(y)) {
                    continue;
                }
                for (int u : s[find(x)]) {
                    for (int v : s[find(y)]) {
                        lo[u][v] = x;
                        lo[v][u] = x;
                    }
                }
                unite(x, y);
            }
        }
        vector<int> ans(Q);
        for (int i = 0; i < Q; i++) {
            for (int j = L[i]; j <= R[i]; j++) {
                if (hi[S[i]][j] >= L[i] && lo[j][E[i]] <= R[i]) {
                    ans[i] = 1;
                }
            }
        }
        return ans;
    } else {
        vector<int> A;
        for (int i = 0; i < N; i++) {
            if (adj[i].size() == 1) {
                A.push_back(i);
                A.push_back(adj[i][0]);
                break;
            }
        }
        while (A.size() < N) {
            int x = A[A.size() - 2];
            int y = A[A.size() - 1];
            A.push_back(adj[y][0] ^ adj[y][1] ^ x);
        }
        // vector<int> lg(N + 1);
        // for (int i = 2; i <= N; i++) {
        //     lg[i] = lg[i / 2] + 1;
        // }
        int lg = __lg(N);
        vector smin(N, vector<int>(lg + 1));
        vector smax(N, vector<int>(lg + 1));
        for (int i = 0; i < N; i++) {
            smin[i][0] = A[i];
            smax[i][0] = A[i];
        }
        for (int j = 0; j < lg; j++) {
            for (int i = 0; i + (2 << j) <= N; i++) {
                smin[i][j + 1] = min(smin[i][j], smin[i + (1 << j)][j]);
                smax[i][j + 1] = max(smax[i][j], smax[i + (1 << j)][j]);
            }
        }
        auto qmin = [&](int l, int r) {
            if (l == r) {
                return N;
            }
            int k = __lg(r - l);
            return min(smin[l][k], smin[r - (1 << k)][k]);
        };
        auto qmax = [&](int l, int r) {
            if (l == r) {
                return -1;
            }
            int k = __lg(r - l);
            return max(smax[l][k], smax[r - (1 << k)][k]);
        };
        vector<int> B(N);
        for (int i = 0; i < N; i++) {
            B[A[i]] = i;
        }
        vector<int> ans(Q);
        for (int i = 0; i < Q; i++) {
            if (S[i] < L[i] || E[i] > R[i]) {
                continue;
            }
            int x = B[S[i]], u = -1;
            int y = B[E[i]], v = -1;
            if (x < y) {
                u = x; assert(A[u] >= L[i]);
                while (u + 1 <= y && A[u + 1] >= L[i]) {
                    u++;
                }
                v = y; assert(A[v] <= R[i]);
                while (v - 1 >= x && A[v - 1] <= R[i]) {
                    v--;
                }
            } else {
                u = y; assert(A[u] <= R[i]);
                while (u + 1 <= x && A[u + 1] <= R[i]) {
                    u++;
                }
                v = x; assert(A[v] >= L[i]);
                while (v - 1 >= y && A[v - 1] >= L[i]) {
                    v--;
                }
            }
            if (v <= u) {
                ans[i] = 1;
            }
        }
        return ans;
    }
}

Compilation message

werewolf.cpp: In function 'std::vector<int> check_validity(int, std::vector<int>, std::vector<int>, std::vector<int>, std::vector<int>, std::vector<int>, std::vector<int>)':
werewolf.cpp:90:25: warning: comparison of integer expressions of different signedness: 'std::vector<int>::size_type' {aka 'long unsigned int'} and 'int' [-Wsign-compare]
   90 |         while (A.size() < N) {
      |                ~~~~~~~~~^~~
werewolf.cpp:112:14: warning: variable 'qmin' set but not used [-Wunused-but-set-variable]
  112 |         auto qmin = [&](int l, int r) {
      |              ^~~~
werewolf.cpp:119:14: warning: variable 'qmax' set but not used [-Wunused-but-set-variable]
  119 |         auto qmax = [&](int l, int r) {
      |              ^~~~

Subtask #1
7.0 / 7.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 340 KB Output is correct
2 Correct 1 ms 340 KB Output is correct
3 Correct 0 ms 212 KB Output is correct
4 Correct 1 ms 212 KB Output is correct
5 Correct 1 ms 340 KB Output is correct
6 Correct 1 ms 340 KB Output is correct
7 Correct 1 ms 340 KB Output is correct
8 Correct 1 ms 340 KB Output is correct
9 Correct 1 ms 340 KB Output is correct

Subtask #2
8.0 / 8.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 340 KB Output is correct
2 Correct 1 ms 340 KB Output is correct
3 Correct 0 ms 212 KB Output is correct
4 Correct 1 ms 212 KB Output is correct
5 Correct 1 ms 340 KB Output is correct
6 Correct 1 ms 340 KB Output is correct
7 Correct 1 ms 340 KB Output is correct
8 Correct 1 ms 340 KB Output is correct
9 Correct 1 ms 340 KB Output is correct
10 Correct 224 ms 71508 KB Output is correct
11 Correct 184 ms 71464 KB Output is correct
12 Correct 155 ms 71504 KB Output is correct
13 Correct 149 ms 71476 KB Output is correct
14 Correct 131 ms 71548 KB Output is correct
15 Correct 180 ms 71552 KB Output is correct

Subtask #3
0 / 34.0

# Verdict Execution time Memory Grader output
1 Correct 340 ms 63736 KB Output is correct
2 Execution timed out 4019 ms 72180 KB Time limit exceeded
3 Halted 0 ms 0 KB -

Subtask #4
0 / 51.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 340 KB Output is correct
2 Correct 1 ms 340 KB Output is correct
3 Correct 0 ms 212 KB Output is correct
4 Correct 1 ms 212 KB Output is correct
5 Correct 1 ms 340 KB Output is correct
6 Correct 1 ms 340 KB Output is correct
7 Correct 1 ms 340 KB Output is correct
8 Correct 1 ms 340 KB Output is correct
9 Correct 1 ms 340 KB Output is correct
10 Correct 224 ms 71508 KB Output is correct
11 Correct 184 ms 71464 KB Output is correct
12 Correct 155 ms 71504 KB Output is correct
13 Correct 149 ms 71476 KB Output is correct
14 Correct 131 ms 71548 KB Output is correct
15 Correct 180 ms 71552 KB Output is correct
16 Correct 340 ms 63736 KB Output is correct
17 Execution timed out 4019 ms 72180 KB Time limit exceeded
18 Halted 0 ms 0 KB -