Submission #427791

# Submission time Handle Problem Language Result Execution time Memory
427791 2021-06-14T22:58:34 Z Odavey Regions (IOI09_regions) C++17
45 / 100
8000 ms 35604 KB
//
// ~oisín~ C++ Template
//

#include                <bits/stdc++.h>
#define MX_N            200005
#define mp              make_pair
#define mod7            1000000007
#define modpi           314159
#define PI              3.141592653589793238
#define pb              push_back
#define FastIO          ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define All(a)          a.begin(),a.end()
#define fi              first
#define se              second
#define ll              long long int
#define ull             unsigned long long int

int kx[8]  =            {+2, +2, -2, -2, +1, +1, -1, -1};
int ky[8]  =            {+1, -1, +1, -1, +2, -2, +2, -2};
int d9x[9] =            {+1, +1, +1, +0, +0, +0, -1, -1, -1};
int d9y[9] =            {+1, +0, -1, +1, +0, -1, +1, +0, -1};
int dx4[4] =            {+0, +0, +1, -1};
int dy4[4] =            {+1, -1, +0, +0};

ll gcd(ull a, ull b){
    return (a==0)?b:gcd(b%a,a);
}

ll lcm(ull a, ull b){
    return a*(b/gcd(a,b));
}

const long long INF = 1e18;

using namespace std;

int N, R, Q;
int H[MX_N], p[MX_N];
vector<int> adj[MX_N], r[25001];
vector<pair<int, bool> > ord;
map<int, int> cache[25001];

void dfs(int at){
    ord.pb({at, 0});
    r[H[at]].pb((int)ord.size()-1);
    for(int to : adj[at]){
        if(p[at] == to){
            continue;
        }
        dfs(to);
    }
    ord.pb({at, 1});
    r[H[at]].pb((int)ord.size()-1);
}

int main(){
    cin >> N >> R >> Q;
//    int c = sqrt(N);
    int c = 1000000000;
    cin >> H[0];
    --H[0];
    for(int i=1;i<N;++i){
        cin >> p[i] >> H[i];
        --p[i], --H[i];
        adj[p[i]].pb(i);
    }
    dfs(0);

    for(int j=0;j<R;++j){
        if((int)r[j].size() >= c){
            for(int i=0;i<R;++i){
                if(i == j){
                    continue;
                }
                int x = 0, y = 0;
                int cur;
                if(r[i][0] < r[j][0]){
                    cur = r[i][0];
                    ++x;
                }else{
                    cur = r[j][0];
                    ++y;
                }
                int cntA = 0, cntB = 0;
                int ans = 0;
                while(true){
                    auto P = ord[cur];
                    if(H[P.fi] == i){
                        if(P.se == 0){
                            ++cntA;
                        }else{
                            --cntA;
                        }
                    }else{
                        if(P.se == 0){
                            ++cntB;
                            ans += cntA;
                        }else{
                            --cntB;
                        }
                    }
                    if(x >= (int)r[i].size() && y >= (int)r[j].size()){
                        break;
                    }else if(x >= (int)r[i].size()){
                        cur = r[j][y];
                        ++y;
                    }else if(y >= (int)r[j].size()){
                        cur = r[i][x];
                        ++x;
                    }else{
                        if(r[i][x] < r[j][y]){
                            cur = r[i][x];
                            ++x;
                        }else{
                            cur = r[j][y];
                            ++y;
                        }
                    }
                }
                cache[i][j] = ans;
            }
        }
    }

    for(int i=0;i<R;++i){
        if((int)r[i].size() >= c){
            for(int j=0;j<R;++j){
                if(i == j){
                    continue;
                }
                int x = 0, y = 0;
                int cur;
                if(r[i][0] < r[j][0]){
                    cur = r[i][0];
                    ++x;
                }else{
                    cur = r[j][0];
                    ++y;
                }
                int cntA = 0, cntB = 0;
                int ans = 0;
                while(true){
                    auto P = ord[cur];
                    if(H[P.fi] == i){
                        if(P.se == 0){
                            ++cntA;
                        }else{
                            --cntA;
                        }
                    }else{
                        if(P.se == 0){
                            ++cntB;
                            ans += cntA;
                        }else{
                            --cntB;
                        }
                    }
                    if(x == (int)r[i].size() && y == (int)r[j].size()){
                        break;
                    }else if(x == (int)r[i].size()){
                        cur = r[j][y];
                        ++y;
                    }else if(y == (int)r[j].size()){
                        cur = r[i][x];
                        ++x;
                    }else{
                        if(r[i][x] < r[j][y]){
                            cur = r[i][x];
                            ++x;
                        }else{
                            cur = r[j][y];
                            ++y;
                        }
                    }
                }
                cache[i][j] = ans;
            }
        }
    }

    while(Q--){
        int r1, r2;
        cin >> r1 >> r2;
        --r1, --r2;
        if((int)r[r1].size() >= c || (int)r[r2].size() >= c){
            cout << cache[r1][r2] << endl;
            cout.flush();
        }else{
            vector<int> tmp;
            for(auto P : r[r1]){
                tmp.pb(P);
            }
            for(auto P : r[r2]){
                tmp.pb(P);
            }
            sort(All(tmp));
            int cntA = 0, cntB = 0;
            int ans = 0;
            for(auto ii : tmp){
                auto P = ord[ii];
                if(H[P.fi] == r1){
                    if(P.se == 0){
                        ++cntA;
                    }else{
                        --cntA;
                    }
                }else{
                    if(P.se == 0){
                        ++cntB;
                        ans += cntA;
                    }else{
                        --cntB;
                    }
                }
            }
            cout << ans << endl;
            cout.flush();

//            int x = 0, y = 0;
//            int cur;
//            if(r[r1][0] < r[r2][0]){
//                cur = r[r1][0];
//                ++x;
//            }else{
//                cur = r[r2][0];
//                ++y;
//            }
//            int cntA = 0, cntB = 0;
//            int ans = 0;
//            while(true){
//                auto P = ord[cur];
//                if(H[P.fi] == r1){
//                    if(P.se == 0){
//                        ++cntA;
//                    }else{
//                        --cntA;
//                    }
//                }else{
//                    if(P.se == 0){
//                        ++cntB;
//                        ans += cntA;
//                    }else{
//                        --cntB;
//                    }
//                }
//                if(x == (int)r[r1].size() && y == (int)r[r2].size()){
//                    break;
//                }else if(x == (int)r[r1].size()){
//                    cur = r[r2][y];
//                    ++y;
//                }else if(y == (int)r[r2].size()){
//                    cur = r[r1][x];
//                    ++x;
//                }else{
//                    if(r[r1][x] < r[r2][y]){
//                        cur = r[r1][x];
//                        ++x;
//                    }else{
//                        cur = r[r2][y];
//                        ++y;
//                    }
//                }
//            }
//            cout << ans << endl;
//            cout.flush();
        }
    }
}
# Verdict Execution time Memory Grader output
1 Correct 4 ms 6728 KB Output is correct
2 Correct 5 ms 6728 KB Output is correct
3 Correct 6 ms 6696 KB Output is correct
4 Correct 11 ms 6728 KB Output is correct
5 Correct 14 ms 6728 KB Output is correct
6 Correct 41 ms 6856 KB Output is correct
7 Correct 43 ms 6856 KB Output is correct
8 Correct 42 ms 6844 KB Output is correct
9 Correct 103 ms 7548 KB Output is correct
10 Correct 123 ms 7496 KB Output is correct
11 Correct 170 ms 7752 KB Output is correct
12 Correct 245 ms 8644 KB Output is correct
13 Correct 378 ms 7996 KB Output is correct
14 Correct 619 ms 8664 KB Output is correct
15 Correct 859 ms 12984 KB Output is correct
# Verdict Execution time Memory Grader output
1 Execution timed out 8029 ms 13528 KB Time limit exceeded
2 Execution timed out 8064 ms 11796 KB Time limit exceeded
3 Execution timed out 8035 ms 15892 KB Time limit exceeded
4 Correct 448 ms 8756 KB Output is correct
5 Correct 707 ms 11608 KB Output is correct
6 Correct 3769 ms 10372 KB Output is correct
7 Correct 4051 ms 12392 KB Output is correct
8 Correct 4374 ms 18996 KB Output is correct
9 Correct 5847 ms 19752 KB Output is correct
10 Execution timed out 8061 ms 26556 KB Time limit exceeded
11 Execution timed out 8037 ms 18004 KB Time limit exceeded
12 Execution timed out 8021 ms 20432 KB Time limit exceeded
13 Execution timed out 8044 ms 21040 KB Time limit exceeded
14 Execution timed out 8034 ms 20492 KB Time limit exceeded
15 Execution timed out 8064 ms 26024 KB Time limit exceeded
16 Execution timed out 8042 ms 35604 KB Time limit exceeded
17 Execution timed out 8077 ms 33572 KB Time limit exceeded