oj.uz

Submission #802336

# Submission time Handle Problem Language Result Execution time Memory
802336 2023-08-02T11:42:21 Z boris_mihov Highway Tolls (IOI18_highway) C++17
39 / 100
 141 ms 34308 KB 
#include "highway.h"
#include <algorithm>
#include <iostream>
#include <numeric>
#include <cassert>
#include <numeric>
#include <vector>
#include <queue>

typedef long long llong;
const int MAXN = 90000 + 10;
const llong INF = 1e18;
const int INTINF = 1e9;

int n, m, a, b;
std::queue <int> q;
std::vector <std::pair <int,int>> g[MAXN];
std::vector <std::pair <int,int>> t1[MAXN];
std::vector <std::pair <int,int>> t2[MAXN];
std::vector <int> edgeU;
std::vector <int> edgeV;
int inTree[MAXN];
bool vis[MAXN];
int par[MAXN];

int find(std::vector <std::pair <int,int>> t[], int root, int cnt, int cnt2)
{
    // std::cout << "find: " << root << ' ' << cnt << '\n' << std::flush;
    if (cnt == 0)
    {
        return root;
    }

    while (!q.empty())
    {
        q.pop();
    }

    std::vector <int> order;
    q.push(root);

    while (!q.empty())
    {
        int top = q.front();
        q.pop();

        for (const auto &[u, idx] : t[top])
        {
            if (u != par[top])
            {
                order.push_back(idx);
                q.push(u);
            }
        }
    }

    std::vector <int> w(m);
    int l = -1, r = order.size(), mid;
    while (l < r - 1)
    {
        mid = (l + r) / 2;
        std::fill(w.begin(), w.end(), 1);

        for (int i = 0 ; i <= mid ; ++i)
        {
            w[order[i]] = 0;
        }

        llong res = ask(w);
        // std::cout << "here: " << mid << ' ' << res << ' ' << 1LL * a * cnt + 1LL * b * cnt2 << '\n';
        if (res > 1LL * a * cnt + 1LL * b * cnt2) l = mid;
        else r = mid;
    }

    assert(r < order.size());
    int u = edgeU[order[r]];
    int v = edgeV[order[r]];
    if (par[v] == u)
    {
        std::swap(u, v);
    }

    return u;
}

void find_pair(int N, std::vector<int> U, std::vector<int> V, int A, int B) 
{
    n = N;
    m = U.size();
    a = A; b = B;
    edgeU = U;
    edgeV = V;

    for (int i = 0 ; i < m ; ++i)
    {
        g[U[i]].push_back({V[i], i});
        g[V[i]].push_back({U[i], i});
    }

    std::vector <int> toAsk(m, 0);
    llong res = ask(toAsk);

    int l = -1, r = m, mid;
    while (l < r - 1)
    {
        mid = (l + r) / 2;
        std::fill(toAsk.begin(), toAsk.end(), 0);
        for (int i = 0 ; i <= mid ; ++i)
        {
            toAsk[i] = 1;
        }

        llong curr = ask(toAsk);
        if (curr == res) l = mid;
        else r = mid;
    }

    while (r == m);
    int rootOne = U[r];
    int rootTwo = V[r];
    inTree[rootOne] = 1;
    inTree[rootTwo] = 2;
    vis[rootOne] = true;
    vis[rootTwo] = true;
    q.push(rootOne);
    q.push(rootTwo);

    while (!q.empty())
    {
        int top = q.front();
        q.pop();

        // std::cout << "top: " << top << ' ' << inTree[top] << '\n';
        for (const auto &[u, idx] : g[top])
        {
            if (!vis[u])
            {
                par[u] = top;
                vis[u] = true;
                inTree[u] = inTree[top];
                if (inTree[top] == 1)
                {
                    t1[top].push_back({u, idx});
                    t1[u].push_back({top, idx});
                } else
                {
                    t2[top].push_back({u, idx});
                    t2[u].push_back({top, idx});
                }

                q.push(u);
            }
        }
    }       

    std::fill(toAsk.begin(), toAsk.end(), 0);
    for (int i = 0 ; i < n ; ++i)
    {
        for (const auto &[u, idx] : t1[i])
        {
            // std::cout << "idx: " << idx << '\n';
            toAsk[idx] = 1;
        }
    }

    // std::cout << "EDGE: " << rootOne << ' ' << rootTwo << '\n';
    // std::cout << "treeONE\n";
    // for (int i = 0 ; i < m ; ++i)
    // {
    //     if (toAsk[i] == 1)
    //     {
    //         std::cout << i + 1 << ' ';
    //     }
    // }
    
    // std::cout << '\n';
    
    // std::fill(toAsk.begin(), toAsk.end(), 0);
    // for (int i = 0 ; i < n ; ++i)
    // {
    //     for (const auto &[u, idx] : t2[i])
    //     {
    //         std::cout << "idx: " << idx << '\n';
    //         toAsk[idx] = 1;
    //     }
    // }

    // std::cout << "treeTWO\n";
    // for (int i = 0 ; i < m ; ++i)
    // {
    //     if (toAsk[i] == 1)
    //     {
    //         std::cout << i + 1 << ' ';
    //     }
    // }

    // std::cout << "in tree\n" << std::flush;
    // for (int i = 0 ; i < n ; ++i)
    // {
    //     std::cout << inTree[i] << ' ';
    // }

    // std::cout << '\n';
    std::fill(toAsk.begin(), toAsk.end(), 0);
    for (int i = 0 ; i < n ; ++i)
    {
        for (const auto &[u, idx] : t1[i])
        {
            // std::cout << "idx: " << idx << '\n';
            toAsk[idx] = 1;
        }
    }

    llong currRES = ask(toAsk);
    int cntEdges = (currRES - res) / (b - a);
    int cntEdges2 = res / a - cntEdges - 1;
    int s = find(t1, rootOne, cntEdges, cntEdges2 + 1);
    int t = find(t2, rootTwo, cntEdges2, cntEdges + 1);
    answer(s, t);
}

/*
9 12 1 10 1 3
0 1
1 2
2 6
6 3
3 4
4 0
0 5
5 6
6 7
7 0
0 8
8 6
*/

Compilation message

In file included from /usr/include/c++/10/cassert:44,
                 from highway.cpp:5:
highway.cpp: In function 'int find(std::vector<std::pair<int, int> >*, int, int, int)':
highway.cpp:75:14: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   75 |     assert(r < order.size());
      |            ~~^~~~~~~~~~~~~~

Subtask #1
0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 4 ms 6656 KB Output is correct
2 Correct 3 ms 6652 KB Output is correct
3 Correct 3 ms 6608 KB Output is correct
4 Correct 3 ms 6616 KB Output is correct
5 Correct 3 ms 6584 KB Output is correct
6 Correct 3 ms 6608 KB Output is correct
7 Correct 3 ms 6656 KB Output is correct
8 Runtime error 10 ms 13308 KB Execution killed with signal 6
9 Halted 0 ms 0 KB -

Subtask #2
0 / 7.0

# Verdict Execution time Memory Grader output
1 Correct 4 ms 6704 KB Output is correct
2 Correct 11 ms 7760 KB Output is correct
3 Correct 90 ms 17484 KB Output is correct
4 Correct 102 ms 17620 KB Output is correct
5 Correct 122 ms 17508 KB Output is correct
6 Correct 101 ms 17476 KB Output is correct
7 Correct 111 ms 17504 KB Output is correct
8 Correct 126 ms 17520 KB Output is correct
9 Runtime error 141 ms 34308 KB Execution killed with signal 6
10 Halted 0 ms 0 KB -

Subtask #3
6.0 / 6.0

# Verdict Execution time Memory Grader output
1 Correct 11 ms 7616 KB Output is correct
2 Correct 18 ms 8816 KB Output is correct
3 Correct 26 ms 9736 KB Output is correct
4 Correct 88 ms 16236 KB Output is correct
5 Correct 95 ms 16320 KB Output is correct
6 Correct 69 ms 16304 KB Output is correct
7 Correct 71 ms 15948 KB Output is correct
8 Correct 103 ms 16344 KB Output is correct
9 Correct 86 ms 16128 KB Output is correct

Subtask #4
33.0 / 33.0

# Verdict Execution time Memory Grader output
1 Correct 3 ms 6728 KB Output is correct
2 Correct 10 ms 7772 KB Output is correct
3 Correct 74 ms 15152 KB Output is correct
4 Correct 104 ms 17512 KB Output is correct
5 Correct 93 ms 17476 KB Output is correct
6 Correct 114 ms 17468 KB Output is correct
7 Correct 78 ms 16992 KB Output is correct
8 Correct 93 ms 17496 KB Output is correct
9 Correct 113 ms 17468 KB Output is correct
10 Correct 112 ms 17468 KB Output is correct
11 Correct 105 ms 16368 KB Output is correct
12 Correct 140 ms 16356 KB Output is correct
13 Correct 120 ms 16400 KB Output is correct
14 Correct 102 ms 16264 KB Output is correct
15 Correct 96 ms 17516 KB Output is correct
16 Correct 104 ms 17720 KB Output is correct
17 Correct 118 ms 16348 KB Output is correct
18 Correct 119 ms 16364 KB Output is correct
19 Correct 110 ms 17496 KB Output is correct
20 Correct 107 ms 16392 KB Output is correct
21 Correct 118 ms 18244 KB Output is correct
22 Correct 80 ms 18212 KB Output is correct
23 Correct 92 ms 17932 KB Output is correct
24 Correct 137 ms 17836 KB Output is correct
25 Correct 133 ms 16540 KB Output is correct

Subtask #5
0 / 18.0

# Verdict Execution time Memory Grader output
1 Correct 15 ms 7880 KB Output is correct
2 Incorrect 16 ms 8004 KB Output is incorrect: {s, t} is wrong.
3 Halted 0 ms 0 KB -

Subtask #6
0 / 31.0

# Verdict Execution time Memory Grader output
1 Runtime error 23 ms 15816 KB Execution killed with signal 6
2 Halted 0 ms 0 KB -