Problem: cf1639_h
Difficulty: medium
Categories: graph, greedy
Time limit: 5000 ms, memory limit: 256 MB

All problems in this contest share the same statement, the only difference is the test your solution runs on. For further information on scoring please refer to "Scoring" section of the statement.

This is an interactive problem.

Imagine you are a treasure hunter, a very skillful one. One day you came across an ancient map which could help you to become rich. The map shows multiple forestry roads, and at each junction there is a treasure. So, you start your journey hoping to retrieve all the hidden treasures, but you don't know yet that there is a wicked wizard standing against you and craving to tangle up these roads and impede your achievements.

The treasure map is represented as an undirected graph in which vertices correspond to junctions and edges correspond to roads. Your path begins at a certain fixed vertex with a label known to you. Every time you come to a vertex that you have not been to before, you dig up a treasure chest and put a flag in this vertex. At the initial vertex you'll find a treasure chest immediately and, consequently, you'll put a flag there immediately as well.

When you are standing at the junction you can see for each of the adjacent vertices its degree and if there is a flag there. There are no other things you can see from there. Besides, the power of the wicked wizard is so great that he is able to change the location of the roads and junctions on the map without changing the graph structure. Therefore, the sequence of the roads coming from the junction $v$ might be different each time you come in the junction $v$. However, keep in mind that the set of adjacent crossroads does not change, and you are well aware of previously dug treasures at each adjacent to $v$ vertex.

Your goal is to collect treasures from all vertices of the graph as fast as you can. Good luck in hunting!

Interaction

On the first line the interactor prints an integer $t$ ($1 \leq t \leq 5$) — the number of maps for which you need to solve the problem.

Then for each of the $t$ maps interactor firstly prints the graph description and after that interaction on this map starts. The map description is given in the following format.

The first line contains four integers $n, m, start, base\_move\_count$ ($2 \leq n \leq 300$, $1 \leq m \leq min(\frac{n(n-1)}{2}, 25n)$, $1 \leq start \leq n$, $1000 \leq base\_move\_count \leq 30000$) — the number of vertices and edges in the graph, the label of the vertex where you start the journey and some base move count, on which the score for the map depends. It's guaranteed that the jury has a solution traversing the map using not more than $base\_move\_count$ moves with high probability.

The next $m$ lines contain descriptions of the edges of the graph $u, v$ ($1 \leq u, v \leq n$, $u \neq v$). It is guaranteed that the graph is connected, does not contain multiple edges and the degrees of all vertices do not exceed 50.

You can find map descriptions for all tests in the archive 'map\_descriptions.zip' which you can find in any of the archives 'problem-X-materials.zip' in the section "Contest materials" — they are all the same.

After that the interaction begins. The interactor prints vertex descriptions in the following format:

R~d~deg\_1~flag\_1~deg\_2~flag\_2 \ldots deg\_d~flag\_d, where $d$ is the degree of the current vertex, $deg_i$ is the degree of the $i$-th vertex adjacent to the current one, and $flag_i$ (0 or 1) is an indicator if the $i$-th adjacent vertex contains a flag. The order of neighbors in the vertex description is chosen by the interactor uniformly at random independently each time. Please keep in mind that you are not given the actual labels of adajacent vertices.

In response to the description of the vertex you should print a single integer $i$ ($1 \leq i \leq d$), which means that you have chosen the vertex with description $deg_i~flag_i$. Remember to use the flush operation after each output. If your output is invalid, you will get a "Wrong Answer" verdict.

When you have visited all the vertices of the graph at least once, the interactor prints the string "AC" instead of the vertex description. If you use more than $2 \cdot base\_move\_count$ moves, the interactor prints the string "F". In both cases, you have to either start reading the description of the next map, or terminate the program, if it has been the last map in the test.

Below the example of interaction is presented. Note that the test from the example is not the same that your solution will be tested on.

```
|  |  |
| --- | --- |
| Interactor | Solution |
| 1 |  |
| 3 3 1 1000 |  |
| 1 2 |  |
| 2 3 |  |
| 3 1 |  |
| R 2 2 0 2 0 |  |
|  | 1 |
| R 2 2 0 2 1 |  |
|  | 2 |
| R 2 2 0 2 1 |  |
|  | 1 |
| AC |  |
```

Scoring

All problems of this contest share the same statement and differ only in the test. Each problem contains one test. Map descriptions for the test are available to look at in the archive.

Each test consists of several maps.

The solution score for the problem will be $0$ in case your solution for some map failed to get an answer "AC" or "F". If the solution correctly interacted with the interactor on all $t$ maps, the score for the task will be equal to the sum of the scores for each of the maps.

If you have successfully passed all vertices of a graph with $n$ vertices using $moves$ moves, the score for the map is calculated as follows. Denote

base\\_fraction=\frac{base\\_move\\_count + 1}{n},sol\\_fraction=\frac{moves+1}{n},c=\frac{90}{\sqrt{base\\_fraction - 1}}.

Then:

* if $moves \leq base\_move\_count$, you get $100-c \sqrt{sol\_fraction - 1}$ points.
* if $base\_move\_count < moves \leq 2 \cdot base\_move\_count$, you get $20 - \frac{10\cdot(moves + 1)}{base\_move\_count + 1}$ points.

If you use more than $2 \cdot base\_move\_count$ moves, you get 0 points for the map.

For each problem the solution with the highest score is chosen. Please note that the maximum is chosen for the entire test as a whole, not for each separate map.

The final result of the participant is the sum of points for each of the problems.

Non-adaptive interactor (C++):
#include "testlib.h"
#include <bits/stdc++.h>

using namespace std;

static long long queries = 0;
static long long query_limit = 0;
static mt19937 rng(42);

static void log_metrics() {
    try {
        tout << "queries=" << queries << endl;
        tout << "query_limit=" << query_limit << endl;
    } catch (...) {
        
    }
}

static void finish(TResult verdict, const string& msg) {
    log_metrics();
    quitf(verdict, "%s", msg.c_str());
}

static int read_choice_index() {
    string token;
    if (!(cin >> token)) {
        finish(_wa, "Unexpected EOF while reading move");
    }
    if (token.empty()) {
        finish(_wa, "Invalid move token");
    }
    for (char ch : token) {
        if (ch < '0' || ch > '9') {
            finish(_wa, "Invalid move token");
        }
    }
    try {
        size_t pos = 0;
        long long v = stoll(token, &pos);
        if (pos != token.size() || v > numeric_limits<int>::max()) {
            finish(_wa, "Invalid move token");
        }
        return (int)v;
    } catch (...) {
        finish(_wa, "Invalid move token");
    }
    return -1;
}

int main(int argc, char** argv) {
    registerInteraction(argc, argv);
    atexit(log_metrics);

    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int t = inf.readInt(1, 5, "t");
    cout << t << endl;
    cout.flush();

    for (int tc = 0; tc < t; ++tc) {
        int n = inf.readInt(2, 300, "n");
        int max_m = (int)min(1LL * n * (n - 1) / 2, 25LL * n);
        int m = inf.readInt(1, max_m, "m");
        int start = inf.readInt(1, n, "start");
        int base_move_count = inf.readInt(1000, 30000, "base_move_count");

        long long map_limit = 2LL * base_move_count;
        query_limit += map_limit;
        if (tc == 0) log_metrics();

        vector<vector<int>> adj(n + 1);
        vector<int> deg(n + 1, 0);
        vector<pair<int, int>> edges;
        edges.reserve(m);

        for (int i = 0; i < m; ++i) {
            int u = inf.readInt(1, n, "u");
            int v = inf.readInt(1, n, "v");
            adj[u].push_back(v);
            adj[v].push_back(u);
            deg[u]++;
            deg[v]++;
            edges.push_back({u, v});
        }

        cout << n << " " << m << " " << start << " " << base_move_count << endl;
        for (const auto& e : edges) {
            cout << e.first << " " << e.second << endl;
        }
        cout.flush();

        vector<char> visited(n + 1, 0);
        visited[start] = 1;
        int visited_count = 1;
        int cur = start;
        long long moves = 0;

        while (true) {
            if (visited_count == n) {
                cout << "AC" << endl;
                cout.flush();
                break;
            }
            if (moves > map_limit) {
                cout << "F" << endl;
                cout.flush();
                break;
            }

            vector<int> neighbors = adj[cur];
            shuffle(neighbors.begin(), neighbors.end(), rng);

            cout << "R " << neighbors.size();
            for (int v : neighbors) {
                cout << " " << deg[v] << " " << (visited[v] ? 1 : 0);
            }
            cout << endl;
            cout.flush();

            int choice = read_choice_index();
            if (choice < 1 || choice > (int)neighbors.size()) {
                finish(_wa, format("Invalid choice %d (expected 1..%d)", choice, (int)neighbors.size()));
            }

            cur = neighbors[choice - 1];
            moves++;
            queries++;
            if (queries % 200 == 0) log_metrics();

            if (!visited[cur]) {
                visited[cur] = 1;
                visited_count++;
            }
        }
    }

    finish(_ok, "All maps processed");
    return 0;
}


Adaptive interactor (C++):

Test generator (C++):














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

using namespace std;


struct DSU {
    vector<int> p;
    DSU(int n) {
        p.resize(n + 1);
        iota(p.begin(), p.end(), 0);
    }
    int find(int x) {
        return (x == p[x]) ? x : (p[x] = find(p[x]));
    }
    bool unite(int x, int y) {
        int rx = find(x), ry = find(y);
        if (rx != ry) {
            p[rx] = ry;
            return true;
        }
        return false;
    }
};

int main(int argc, char* argv[]) {
    registerGen(argc, argv, 1);

    string mode = opt<string>("mode", "non");
    
    
    
    int t = 1;
    cout << t << "\n";

    while (t--) {
        int n, m, start_node, base_moves;
        vector<pair<int, int>> edges;

        if (mode == "non") {
            
            
            if (rnd.next(10) == 0) n = rnd.next(2, 50);
            else n = rnd.next(50, 300);

            
            
            if (n > 100) base_moves = rnd.next(2000, 5000);
            else base_moves = rnd.next(1000, 2000);

            
            for (int i = 2; i <= n; i++) {
                edges.push_back({rnd.next(1, i - 1), i});
            }

            
            long long max_m = min((long long)n * (n - 1) / 2, (long long)25 * n);
            
            int m_target = rnd.next((int)edges.size(), (int)max_m);
            
            
            set<pair<int,int>> current_edges;
            vector<int> deg(n + 1, 0);
            for(auto &e: edges) {
                if(e.first > e.second) swap(e.first, e.second);
                current_edges.insert(e);
                deg[e.first]++;
                deg[e.second]++;
            }

            int attempts = 0;
            while((int)edges.size() < m_target && attempts < 50000) {
                attempts++;
                int u = rnd.next(1, n);
                int v = rnd.next(1, n);
                if (u == v) continue;
                if (u > v) swap(u, v);
                if (current_edges.count({u, v})) continue;
                if (deg[u] >= 50 || deg[v] >= 50) continue; 

                current_edges.insert({u, v});
                edges.push_back({u, v});
                deg[u]++;
                deg[v]++;
            }
        } else {
            
            
            n = rnd.next(50, 300);
            base_moves = rnd.next(1500, 4000); 

            
            int k = rnd.next(3, min(n - 1, 50));
            
            
            if ((n * k) % 2 != 0) {
                
                if (n % 2 != 0) {
                    n++;
                    if (n > 300) n = 298;
                }
            }
            
            k = min(k, n - 1);

            
            bool generated = false;
            int try_graph = 0;
            while (!generated && try_graph < 20) {
                try_graph++;
                edges.clear();
                vector<int> stubs;
                stubs.reserve(n * k);
                for (int i = 1; i <= n; i++) 
                    for (int j = 0; j < k; j++) stubs.push_back(i);
                
                shuffle(stubs.begin(), stubs.end());
                
                bool possible = true;
                set<pair<int,int>> edge_set;
                vector<pair<int,int>> temp_edges;
                
                for (size_t i = 0; i < stubs.size(); i += 2) {
                    int u = stubs[i];
                    int v = stubs[i+1];
                    if (u == v) { possible = false; break; }
                    if (u > v) swap(u, v);
                    if (edge_set.count({u, v})) { possible = false; break; }
                    edge_set.insert({u, v});
                    temp_edges.push_back({u, v});
                }
                
                if (possible) {
                    DSU dsu(n);
                    int components = n;
                    for (auto &e : temp_edges) {
                        if (dsu.unite(e.first, e.second)) components--;
                    }
                    if (components == 1) {
                        edges = temp_edges;
                        generated = true;
                    }
                }
            }

            
            if (!generated) {
                edges.clear();
                set<pair<int,int>> edge_set;
                vector<int> deg(n + 1, 0);
                
                
                for(int i = 1; i < n; i++) edges.push_back({i, i+1});
                edges.push_back({n, 1});
                
                for(auto &e : edges) {
                    if (e.first > e.second) swap(e.first, e.second);
                    edge_set.insert(e);
                    deg[e.first]++; deg[e.second]++;
                }
                
                int target_m = min((long long)n * k / 2, (long long)25 * n);
                int attempts = 0;
                while((int)edges.size() < target_m && attempts < 50000) {
                    attempts++;
                    int u = rnd.next(1, n);
                    int v = rnd.next(1, n);
                    if(u == v) continue;
                    if(u > v) swap(u, v);
                    if(edge_set.count({u, v})) continue;
                    if(deg[u] >= 50 || deg[v] >= 50) continue;
                    
                    edge_set.insert({u, v});
                    edges.push_back({u, v});
                    deg[u]++; deg[v]++;
                }
            }
        }

        
        vector<int> p(n + 1);
        iota(p.begin(), p.end(), 0);
        shuffle(p.begin() + 1, p.end());

        start_node = rnd.next(1, n);
        m = edges.size();

        
        cout << n << " " << m << " " << p[start_node] << " " << base_moves << "\n";
        for (auto &e : edges) {
            cout << p[e.first] << " " << p[e.second] << "\n";
        }
    }

    return 0;
}