QOJ.ac

QOJ

IDProblemSubmitterResultTimeMemoryLanguageFile sizeSubmit timeJudge time
#389992#5110. Splitstream0_GB_RAM#TL 12ms14460kbC++232.3kb2024-04-14 23:23:362024-04-14 23:23:37

Judging History

你现在查看的是最新测评结果

  • [2024-04-14 23:23:37]
  • 评测
  • 测评结果:TL
  • 用时:12ms
  • 内存:14460kb
  • [2024-04-14 23:23:36]
  • 提交

answer

#include <bits/stdc++.h>
using namespace std;

using ll=long long;
#define int ll
#define rep(i,a,b) for(int i=a;i<(b);++i)
#define all(x) begin(x),end(x)
#define sz(x) (int)((x).size())
using pii=pair<int,int>;
using vi=vector<int>;
#define fi first
#define se second
#define pb push_back

signed main() {
	cin.tie(0)->sync_with_stdio(0);
    cin.exceptions(cin.failbit);
    int m, n, q;
    cin >> m >> n >> q;
    vector<array<int, 3>> gates(2*n + 2);
    vector<vector<int>> before(n*2+2);
    vector<int> ord, vis(2*n+2, 1), len(2*n+2);
    vis[1] = 0;
    for(int i = 0; i < n; i++) {
        char c; int x, y, z;
        cin >> c >> x >> y >> z;
        vis[x] = vis[y] = vis[z] = 0;
        if(c == 'S') {
            gates[y] = {0, x, 0};
            gates[z] = {1, x, 0};
            before[y].push_back(x);
            before[z].push_back(x);
        } else {
            gates[z] = {2, x, y};
            before[z].push_back(x);
            before[z].push_back(y);
        }
    }

    auto dfs = [&](auto self, int v) -> void {
        if(vis[v]) return;
        for(auto i : before[v]) self(self, i);
        ord.push_back(v);
    };
    for(int i = 0; i < vis.size(); i++) if(!vis[i])
            dfs(dfs, i);

    len[1] = m;
    for(auto i : ord) if(i > 1) {
        if(gates[i][0] < 2) {
            len[i] = (len[gates[i][1]] + 1 - gates[i][0]) / 2;
        } else {
            len[i] = len[gates[i][1]] + len[gates[i][2]];
        }
    }

    for(int g, k, i = 0; i < q; i++) {
        cin >> g >> k; k--;
        if(k >= len[g]) cout << "none\n";
        else {
            while(g != 1) {
                if(gates[g][0] < 2) {
                    k = 2 * k + gates[g][0];
                    g = gates[g][1];
                } else {
                    int sh = min(len[gates[g][1]], len[gates[g][2]]);
                    if(k < 2*sh) {
                        g = gates[g][1 + (k & 1)];
                        k /= 2;
                    } else {
                        k -= sh;
                        if(len[gates[g][1]] != sh)
                            g = gates[g][1];
                        else
                            g = gates[g][2];

                    }
                }
            }cout << 1+k << '\n';
        }
    }
}

Details

Tip: Click on the bar to expand more detailed information

Test #1:

score: 100
Accepted
time: 0ms
memory: 3584kb

input:

5 8 26
M 8 9 13
S 2 4 5
S 1 2 3
M 6 5 8
S 4 9 10
S 10 14 15
S 3 6 7
S 7 11 12
2 3
2 4
3 2
3 3
4 2
4 3
5 1
5 2
6 1
6 2
7 1
7 2
8 2
8 3
9 1
9 2
10 1
10 2
11 1
11 2
12 1
13 3
13 4
14 1
14 2
15 1

output:

5
none
4
none
5
none
3
none
2
none
4
none
3
none
1
none
5
none
4
none
none
3
none
5
none
none

result:

ok 26 lines

Test #2:

score: 0
Accepted
time: 2ms
memory: 6796kb

input:

1000000000 8191 1000
S 1 2 3
S 2 4 5
S 3 6 7
S 4 8 9
S 5 10 11
S 6 12 13
S 7 14 15
S 8 16 17
S 9 18 19
S 10 20 21
S 11 22 23
S 12 24 25
S 13 26 27
S 14 28 29
S 15 30 31
S 16 32 33
S 17 34 35
S 18 36 37
S 19 38 39
S 20 40 41
S 21 42 43
S 22 44 45
S 23 46 47
S 24 48 49
S 25 50 51
S 26 52 53
S 27 54 55...

output:

1
3
999999999
499999999
333333331
999999997
499999997
333333329
2
4
1000000000
500000000
333333332
999999998
499999998
333333330
1
5
999999997
499999997
333333329
999999993
499999993
333333325
3
7
999999999
499999999
333333331
999999995
499999995
333333327
2
6
999999998
499999998
333333330
999999994...

result:

ok 1000 lines

Test #3:

score: 0
Accepted
time: 12ms
memory: 14460kb

input:

1000000000 8190 1000
S 1 2 3
M 8193 8194 8192
S 2 4 5
M 8195 8196 8193
S 3 6 7
M 8197 8198 8194
S 4 8 9
M 8199 8200 8195
S 5 10 11
M 8201 8202 8196
S 6 12 13
M 8203 8204 8197
S 7 14 15
M 8205 8206 8198
S 8 16 17
M 8207 8208 8199
S 9 18 19
M 8209 8210 8200
S 10 20 21
M 8211 8212 8201
S 11 22 23
M 821...

output:

1
2
1000000000
500000000
333333333
999999999
499999999
333333332
1
1
3
3
999999999
999999999
499999999
499999999
333333331
333333331
999999997
999999997
499999997
499999997
333333329
333333329
2
2
4
4
1000000000
1000000000
500000000
500000000
333333332
333333332
999999998
999999998
499999998
4999999...

result:

ok 1000 lines

Test #4:

score: -100
Time Limit Exceeded

input:

1000000000 10000 1000
S 1 2 3
S 2 4 5
S 4 6 7
S 6 8 9
S 8 10 11
S 10 12 13
S 12 14 15
S 14 16 17
S 16 18 19
S 18 20 21
S 20 22 23
S 22 24 25
S 24 26 27
S 26 28 29
S 28 30 31
S 30 32 33
S 32 34 35
S 34 36 37
S 36 38 39
S 38 40 41
S 40 42 43
S 42 44 45
S 44 46 47
S 46 48 49
S 48 50 51
S 50 52 53
S 52 ...

output:


result: