Submission #985504

#	Time	Username	Problem	Language	Result	Execution time	Memory
985504		Maaxle	Stations (IOI20_stations)	C++17	0 / 100	572 ms	1132 KiB

stations

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

#define range(it, a, b) for (ll it = a; it < b; it++)
#define all(x) begin(x), end(x)
#define ll long long
#define ull unsigned long long
#define INF64 ((ll) 1 << 62)
#define INF32 (1 << 30)
#define mset multiset
#define uset unordered_set
#define umap unordered_map 
#define pqueue priority_queue 
#define ptr(A) shared_ptr<A>

using namespace std;

struct Node {
    int in, out;
    int depth;
};

static void dfs(int i, int p, int d, vector<int>& euler, vector<vector<int>>& adj, vector<Node>& nodes) {    
    nodes[i].depth = d;
    nodes[i].in = euler.size();
    euler.push_back(i);

    for (int& k : adj[i]) {
        if (k != p)
            dfs(k, i, d+1, euler, adj, nodes);
    }

    nodes[i].out = euler.size();
    euler.push_back(i);    
}

vector<int> label(int n, int k, vector<int> u, vector<int> v) {
    vector<Node> nodes (n);
    vector<vector<int>> adj (n);
    vector<int> euler;

    range(i, 0, n-1) {
        adj[u[i]].push_back(v[i]);
        adj[v[i]].push_back(u[i]);
    }

    dfs(0, 0, 0, euler, adj, nodes);

    vector<int> label (n);
    range(i, 0, n) 
        label[i] = (nodes[i].depth & 1 ? nodes[i].out : nodes[i].in);
    sort(all(label));

    vector<int> ans (n);
    range(i, 0, n) {
        int bs = (nodes[i].depth & 1 ? nodes[i].out : nodes[i].in);
        ans[i] = distance(begin(label), lower_bound(all(label), bs));
    }
    return ans;
}
		

int find_next_station(int s, int t, vector<int> c) {
    if (c.size() == 1)
        return c[0];
    sort(all(c));

    // CASE 0 -> s is the root (node 0)
    // every node in c has value 'out'
    // t has to be a decendant of some c
    // ancestor of t is the first that is >= t
    // if (s == 0) {
    //     for (int& i : c) {
    //         if (i >= t)
    //             return i;
    //     }
    // }

    // CASE 1 -> s has an 'in' value
    // every node in c has value 'out'
    // the parent of them all is the right-most value
    // s is the left-most value
    if (s < c[0]) {

        // CASE 1.1 -> t is not a decendant of s
        // and t is before s
        if (t < s) 
            return c.back();
            
        // CASE 1.2 -> t may or not be decendant of s
        // ancestor of t is the first in c that is >= t
        for (int& i : c) {
            if (i >= t)
                return i;
        }
    }

    // CASE 2 -> s has an 'out' value
    // every node in c has value 'in'
    // the parent of them all is the left-most value
    // s is the right-most value
    
    // CASE 2.1 -> t is not a decendant of s
    //  and t is after s
    if (t > s) 
        return c[0];
    
    // CASE 2.2 -> t may or not be a decendant of s
    // ancestor of t is the first in c that is <= t (backwards)
    for (auto it = rbegin(c); 1; it++) {
        if (*it <= t)
            return *it;
    }
}

• Subtask 1: 0 / 5
• Subtask 2: 0 / 8
• Subtask 3: 0 / 16
• Subtask 4: 0 / 10
• Subtask 5: 0 / 61