oj.uz

Submission #903972

# Submission time Handle Problem Language Result Execution time Memory
903972 2024-01-11T15:49:28 Z LaviniaTornaghi Longest Trip (IOI23_longesttrip) C++17
15 / 100
 13 ms 1384 KB 
#include <bits/stdc++.h>
#include "longesttrip.h"
using namespace std;

struct XorList {
    struct Node {
        int val;
        Node *x, *y;

        Node(int val) : val(val), x(NULL), y(NULL) { }
    } *start, *end;

    void merge(XorList *o) {
        if (end->x == NULL) {
            end->x = o->start;
        } else {
            end->y = o->start;
        }

        if (o->start->x == NULL) {
            o->start->x = end;
        } else {
            o->start->y = end;
        }

        end = o->end;
        o->start = o->end = NULL;
    }

    vector<int> vectorize() {
        vector<int> ans;
        
        Node* curr = start, *old = NULL;
        while (curr != NULL) {
            ans.push_back(curr->val);

            if (old == curr->x) {
                old = curr;
                curr = old->y;
            } else {
                old = curr;
                curr = old->x;
            }
        }
        return ans;
    }

    int first() { return start->val; }
    int last() { return end->val; }
    void reverse() { swap(start, end); }
    XorList(int val) { start = end = new Node(val); }
};

vector<int> longest_trip(int N, int D) {
    XorList *a = new XorList(0);
    XorList *b = new XorList(1);
    
    for (int i = 2; i < N; i++) {
        int last_a = a->last();
        int last_b = b->last();
        XorList *m = new XorList(i);

        if (are_connected({last_a}, {last_b})) {
            b->reverse();
            a->merge(b);

            b = m;
        } else if (are_connected({last_a}, {i})) {
            a->merge(m);
        } else {
            b->merge(m);
        }
    }

    if (are_connected({a->first()}, {b->first()})) {
        a->reverse();
        a->merge(b);
        return a->vectorize();
    }

    if (are_connected({a->first()}, {b->last()})) {
        a->reverse();
        b->reverse();
        a->merge(b);
        return a->vectorize();
    }

    if (are_connected({a->last()}, {b->first()})) {
        a->merge(b);
        return a->vectorize();
    }

    if (are_connected({a->last()}, {b->last()})) {
        b->reverse();
        a->merge(b);
        return a->vectorize();
    }

    vector<int> chain_a = a->vectorize();
    vector<int> chain_b = b->vectorize();

    if (!are_connected(chain_a, chain_b)) {
        return chain_a.size() > chain_b.size() ? chain_a : chain_b;
    }
    exit(1);

    int l1 = 0, r1 = chain_a.size();
    while (l1 + 1 < r1) {
        int m = (l1 + r1) / 2;
        if (are_connected(vector<int>(chain_a.begin() + m, chain_a.end()), chain_b)) {
            l1 = m;
        } else {
            r1 = m;
        }
    }

    int l2 = 0, r2 = chain_b.size();
    while (l2 + 1 < r2) {
        int m = (l2 + r2) / 2;
        if (are_connected(vector<int>(chain_b.begin() + m, chain_b.end()), {chain_a[r1]})) {
            l2 = m;
        } else {
            r2 = m;
        }
    }

    rotate(chain_a.begin(), chain_a.begin() + l1 + 1, chain_a.end());
    rotate(chain_b.begin(), chain_b.begin() + l2, chain_b.end());
    copy(chain_b.begin(), chain_b.end(), back_inserter(chain_a));

    return chain_a;
}

Subtask #0
0.0 / 0.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 344 KB Output is correct
2 Correct 2 ms 440 KB Output is correct

Subtask #1
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 6 ms 1112 KB Output is correct
2 Correct 5 ms 600 KB Output is correct
3 Correct 5 ms 856 KB Output is correct
4 Correct 6 ms 872 KB Output is correct
5 Correct 4 ms 964 KB Output is correct

Subtask #2
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 5 ms 724 KB Output is correct
2 Correct 5 ms 956 KB Output is correct
3 Correct 5 ms 872 KB Output is correct
4 Correct 4 ms 960 KB Output is correct
5 Correct 4 ms 980 KB Output is correct
6 Correct 8 ms 872 KB Output is correct
7 Correct 7 ms 1112 KB Output is correct
8 Correct 5 ms 856 KB Output is correct
9 Correct 5 ms 600 KB Output is correct
10 Correct 5 ms 1384 KB Output is correct
11 Correct 5 ms 988 KB Output is correct
12 Correct 6 ms 1112 KB Output is correct
13 Correct 5 ms 872 KB Output is correct

Subtask #3
0.0 / 25.0

# Verdict Execution time Memory Grader output
1 Correct 6 ms 856 KB Output is correct
2 Correct 6 ms 980 KB Output is correct
3 Correct 6 ms 600 KB Output is correct
4 Correct 5 ms 976 KB Output is correct
5 Correct 6 ms 864 KB Output is correct
6 Correct 7 ms 600 KB Output is correct
7 Correct 6 ms 1112 KB Output is correct
8 Correct 4 ms 712 KB Output is correct
9 Correct 5 ms 600 KB Output is correct
10 Correct 4 ms 972 KB Output is correct
11 Correct 4 ms 1232 KB Output is correct
12 Correct 5 ms 744 KB Output is correct
13 Correct 5 ms 968 KB Output is correct
14 Correct 13 ms 948 KB Output is correct
15 Correct 11 ms 1224 KB Output is correct
16 Runtime error 1 ms 344 KB Execution failed because the return code was nonzero
17 Halted 0 ms 0 KB -

Subtask #4
0.0 / 60.0

# Verdict Execution time Memory Grader output
1 Correct 5 ms 724 KB Output is correct
2 Correct 4 ms 344 KB Output is correct
3 Correct 5 ms 856 KB Output is correct
4 Correct 4 ms 344 KB Output is correct
5 Correct 5 ms 996 KB Output is correct
6 Correct 8 ms 1112 KB Output is correct
7 Correct 6 ms 1112 KB Output is correct
8 Correct 5 ms 1372 KB Output is correct
9 Correct 5 ms 1368 KB Output is correct
10 Correct 6 ms 712 KB Output is correct
11 Correct 5 ms 1120 KB Output is correct
12 Correct 5 ms 992 KB Output is correct
13 Correct 4 ms 964 KB Output is correct
14 Correct 12 ms 1232 KB Output is correct
15 Correct 10 ms 948 KB Output is correct
16 Runtime error 0 ms 344 KB Execution failed because the return code was nonzero
17 Halted 0 ms 0 KB -