QOJ.ac

QOJ

ID	Problem	Submitter	Result	Time	Memory	Language	File size	Submit time	Judge time
#343732	#8056. Travel 2	ucup-team045	AC ✓	410ms	265156kb	C++20	2.6kb	2024-03-02 22:44:39	2024-04-09 18:26:41

Judging History

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

[2024-04-09 18:26:41]
管理员手动重测该提交记录

测评结果：AC
用时：410ms
内存：265156kb

查看

[2024-03-02 22:44:39]
评测

测评结果：100
用时：370ms
内存：265760kb

查看

[2024-03-02 22:44:39]
提交

answer

#include<iostream>
#include<cstring>
#include<vector>
#include<set>
#include<map>
#include<algorithm>
#include<queue>
using namespace std;
using LL = long long;

int main(){

// #ifdef LOCAL
//     freopen("data.in", "r", stdin);
//     freopen("data.out", "w", stdout);
// #endif

    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);

    int T;
    cin >> T;
    while(T--){

        auto ask = [&](int x) -> pair<int, int> {
            cout << "> " << x << endl;
            int t1, t2;
            cin >> t1 >> t2;
            return {t1, t2};
        };

        set<pair<int, int> > s;
        map<pair<int, int>, int> ids;
        vector<vector<int> > g(2);

        vector<int> st(2, 1), ds(2);
        auto dfs = [&](auto &&dfs, int id) -> void {
            queue<int> q;
            vector<int> pre(st.size());
            vector<int> d(st.size(), -1);
            q.push(id);
            d[id] = 0;
            int x = -1;
            while(!q.empty()){
                int t = q.front();
                q.pop();
                if (st[t] <= ds[t]){
                    x = t;
                    break;
                }
                for(auto j : g[t]){
                    if (d[j] == -1){
                        d[j] = d[t] + 1;
                        pre[j] = t;
                        q.push(j);
                    }
                }
            }
            if (x != -1){
                int t = x;
                vector<int> path{t};
                while(t != id){
                    t = pre[t];
                    path.push_back(t);
                }
                reverse(path.begin(), path.end());
                for(int i = 0; i + 1 < path.size(); i++){
                    int u = path[i], v = path[i + 1];
                    ask(ids[{u, v}]);
                }
                auto [t1, t2] = ask(st[x]);
                if (t1 > int(st.size()) - 1){
                    st.resize(t1 + 1, 1);
                    ds.resize(t1 + 1, 1);
                    g.resize(t1 + 1);
                }
                ds[t1] = t2;
                ids[{x, t1}] = st[x];
                st[x] += 1;
                if (!s.contains(minmax(x, t1))){
                    s.insert(minmax(x, t1));
                    g[x].push_back(t1);
                    g[t1].push_back(x);
                }
                dfs(dfs, t1);
            }
        };

        int id;
        cin >> id >> ds[1];
        
        dfs(dfs, id);
        cout << "! ";
        for(auto [x, y] : s) cout << x << ' ' << y << ' ';
        cout << endl;
        string str;
        cin >> str;
    }

}

Source code, Language: C++20

Details

Tip: Click on the bar to expand more detailed information

Test #1:

score: 100

Accepted

time: 1ms

memory: 3588kb

input:

2
1 1
2 1
1 1
Correct
1 3
2 2
1 3
3 1
1 3
4 2
1 3
2 2
4 2
2 2
Correct

output:

> 1
> 1
! 1 2 
> 1
> 1
> 2
> 1
> 3
> 1
> 1
> 2
> 2
! 1 2 1 3 1 4 2 4

result:

ok correct! (2 test cases)

Test #2:

score: 0

Accepted

time: 150ms

memory: 3680kb

input:

output:

> 1
> 1
> 2
> 1
> 3
> 1
> 4
> 1
> 5
> 1
> 6
> 1
> 7
> 1
> 8
> 1
> 9
> 1
> 1
> 2
> 2
> 2
> 3
> 2
> 4
> 3
> 2
> 4
> 2
> 5
> 2
> 2
> 3
> 3
> 4
> 6
> 4
> 7
> 3
> 2
> 4
> 3
> 3
> 4
> 5
> 4
> 5
> 5
> 3
> 6
> 5
> 5
> 6
> 5
> 3
> 6
> 7
> 7
> 4
> 6
> 5
> 8
> 6
> 7
> 4
> 8
> 7
> 2
> 8
> 5
> 9
> 6
> 2
> 8
> 7
...

result:

ok correct! (1000 test cases)

Test #3:

score: 0

Accepted

time: 166ms

memory: 3876kb

input:

output:

> 1
> 1
> 2
> 1
> 3
> 1
> 4
> 1
> 5
> 1
> 6
> 1
> 7
> 1
> 8
> 1
> 9
> 1
> 10
> 1
> 11
> 1
> 12
> 1
> 13
> 1
> 14
> 1
> 15
> 1
> 16
> 1
> 17
> 1
> 18
> 1
> 19
> 1
> 1
> 2
> 2
> 3
> 2
> 2
> 3
> 2
> 4
> 2
> 5
> 4
> 2
> 2
> 3
> 3
> 2
> 2
> 2
> 3
> 3
> 4
> 4
> 4
> 3
> 2
> 4
> 2
> 2
> 3
> 5
> 3
> 2
> 4
> ...

result:

ok correct! (500 test cases)

Test #4:

score: 0

Accepted

time: 182ms

memory: 5284kb

input:

output:

> 1
> 1
> 2
> 1
> 3
> 1
> 4
> 1
> 5
> 1
> 6
> 1
> 7
> 1
> 8
> 1
> 9
> 1
> 10
> 1
> 11
> 1
> 12
> 1
> 13
> 1
> 14
> 1
> 15
> 1
> 16
> 1
> 17
> 1
> 18
> 1
> 19
> 1
> 20
> 1
> 21
> 1
> 22
> 1
> 23
> 1
> 24
> 1
> 25
> 1
> 26
> 1
> 27
> 1
> 28
> 1
> 29
> 1
> 30
> 1
> 31
> 1
> 32
> 1
> 33
> 1
> 34
> 1
> 3...

result:

ok correct! (100 test cases)

Test #5:

score: 0

Accepted

time: 283ms

memory: 75664kb

input:

output:

> 1
> 1
> 2
> 1
> 3
> 1
> 4
> 1
> 5
> 1
> 6
> 1
> 7
> 1
> 8
> 1
> 9
> 1
> 10
> 1
> 11
> 1
> 12
> 1
> 13
> 1
> 14
> 1
> 15
> 1
> 16
> 1
> 17
> 1
> 18
> 1
> 19
> 1
> 20
> 1
> 21
> 1
> 22
> 1
> 23
> 1
> 24
> 1
> 25
> 1
> 26
> 1
> 27
> 1
> 28
> 1
> 29
> 1
> 30
> 1
> 31
> 1
> 32
> 1
> 33
> 1
> 34
> 1
> 3...

result:

ok correct! (10 test cases)

Test #6:

score: 0

Accepted

time: 410ms

memory: 182628kb

input:

output:

> 1
> 1
> 2
> 1
> 3
> 1
> 4
> 1
> 5
> 1
> 6
> 1
> 7
> 1
> 8
> 1
> 9
> 1
> 10
> 1
> 11
> 1
> 12
> 1
> 13
> 1
> 14
> 1
> 15
> 1
> 16
> 1
> 17
> 1
> 18
> 1
> 19
> 1
> 20
> 1
> 21
> 1
> 22
> 1
> 23
> 1
> 24
> 1
> 25
> 1
> 26
> 1
> 27
> 1
> 28
> 1
> 29
> 1
> 30
> 1
> 31
> 1
> 32
> 1
> 33
> 1
> 34
> 1
> 3...

result:

ok correct! (4 test cases)

Test #7:

score: 0

Accepted

time: 263ms

memory: 58144kb

input:

output:

> 1
> 1
> 2
> 1
> 3
> 1
> 4
> 1
> 5
> 1
> 6
> 1
> 7
> 1
> 8
> 1
> 9
> 1
> 10
> 1
> 11
> 1
> 12
> 1
> 13
> 1
> 14
> 1
> 15
> 1
> 16
> 1
> 17
> 1
> 18
> 1
> 19
> 1
> 20
> 1
> 21
> 1
> 22
> 1
> 23
> 1
> 24
> 1
> 25
> 1
> 26
> 1
> 27
> 1
> 28
> 1
> 29
> 1
> 30
> 1
> 31
> 1
> 32
> 1
> 33
> 1
> 34
> 1
> 3...

result:

ok correct! (4 test cases)

Test #8:

score: 0

Accepted

time: 173ms

memory: 265156kb

input:

output:

> 1
> 1
> 2
> 1
> 3
> 1
> 4
> 1
> 5
> 1
> 6
> 1
> 7
> 1
> 8
> 1
> 9
> 1
> 10
> 1
> 11
> 1
> 12
> 1
> 13
> 1
> 14
> 1
> 15
> 1
> 16
> 1
> 17
> 1
> 18
> 1
> 19
> 1
> 20
> 1
> 21
> 1
> 22
> 1
> 23
> 1
> 24
> 1
> 25
> 1
> 26
> 1
> 27
> 1
> 28
> 1
> 29
> 1
> 30
> 1
> 31
> 1
> 32
> 1
> 33
> 1
> 34
> 1
> 3...

result:

ok correct! (4 test cases)

Test #9:

score: 0

Accepted

time: 131ms

memory: 186800kb

input:

output:

> 1
> 1
> 2
> 1
> 3
> 1
> 4
> 1
> 5
> 1
> 6
> 1
> 7
> 1
> 8
> 1
> 9
> 1
> 10
> 1
> 11
> 1
> 12
> 1
> 13
> 1
> 14
> 1
> 15
> 1
> 16
> 1
> 17
> 1
> 18
> 1
> 19
> 1
> 20
> 1
> 21
> 1
> 22
> 1
> 23
> 1
> 24
> 1
> 25
> 1
> 26
> 1
> 27
> 1
> 28
> 1
> 29
> 1
> 30
> 1
> 31
> 1
> 32
> 1
> 33
> 1
> 34
> 1
> 3...

result:

ok correct! (4 test cases)

Extra Test:

score: 0

Extra Test Passed