oj.uz

Submission #903961

# Submission time Handle Problem Language Result Execution time Memory
903961 2024-01-11T15:40:15 Z LaviniaTornaghi Longest Trip (IOI23_longesttrip) C++17
15 / 100
 14 ms 1476 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;
    }

    int l1 = 0, r1 = chain_a.size();
    while (l1 + 1 < r1) {
        int m = (l1 + r1) / 2;
        if (are_connected(vector<int>(chain_a.begin(), chain_a.begin() + m), chain_b)) {
            r1 = m;
        } else {
            l1 = 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(), chain_b.begin() + m), {chain_a[r1]})) {
            r2 = m;
        } else {
            l2 = m;
        }
    }

    rotate(chain_a.begin(), chain_a.begin() + r1 + 1, chain_a.end());
    rotate(chain_b.begin(), chain_b.begin() + r2, 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 0 ms 344 KB Output is correct
2 Correct 1 ms 612 KB Output is correct

Subtask #1
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 7 ms 1236 KB Output is correct
2 Correct 4 ms 624 KB Output is correct
3 Correct 4 ms 856 KB Output is correct
4 Correct 5 ms 852 KB Output is correct
5 Correct 5 ms 448 KB Output is correct

Subtask #2
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 6 ms 604 KB Output is correct
2 Correct 6 ms 856 KB Output is correct
3 Correct 5 ms 856 KB Output is correct
4 Correct 5 ms 860 KB Output is correct
5 Correct 5 ms 976 KB Output is correct
6 Correct 8 ms 1212 KB Output is correct
7 Correct 5 ms 728 KB Output is correct
8 Correct 5 ms 700 KB Output is correct
9 Correct 5 ms 868 KB Output is correct
10 Correct 4 ms 1476 KB Output is correct
11 Correct 5 ms 1224 KB Output is correct
12 Correct 6 ms 748 KB Output is correct
13 Correct 5 ms 1236 KB Output is correct

Subtask #3
0.0 / 25.0

# Verdict Execution time Memory Grader output
1 Correct 7 ms 880 KB Output is correct
2 Correct 5 ms 868 KB Output is correct
3 Correct 5 ms 1124 KB Output is correct
4 Correct 5 ms 868 KB Output is correct
5 Correct 4 ms 736 KB Output is correct
6 Correct 8 ms 1124 KB Output is correct
7 Correct 6 ms 864 KB Output is correct
8 Correct 5 ms 600 KB Output is correct
9 Correct 5 ms 712 KB Output is correct
10 Correct 5 ms 876 KB Output is correct
11 Correct 4 ms 456 KB Output is correct
12 Correct 4 ms 1224 KB Output is correct
13 Correct 4 ms 732 KB Output is correct
14 Correct 13 ms 996 KB Output is correct
15 Correct 14 ms 880 KB Output is correct
16 Incorrect 1 ms 344 KB Incorrect
17 Halted 0 ms 0 KB -

Subtask #4
0.0 / 60.0

# Verdict Execution time Memory Grader output
1 Correct 6 ms 872 KB Output is correct
2 Correct 5 ms 976 KB Output is correct
3 Correct 5 ms 600 KB Output is correct
4 Correct 4 ms 728 KB Output is correct
5 Correct 6 ms 988 KB Output is correct
6 Correct 9 ms 1468 KB Output is correct
7 Correct 5 ms 344 KB Output is correct
8 Correct 4 ms 856 KB Output is correct
9 Correct 5 ms 700 KB Output is correct
10 Correct 6 ms 616 KB Output is correct
11 Correct 4 ms 968 KB Output is correct
12 Correct 5 ms 888 KB Output is correct
13 Correct 4 ms 968 KB Output is correct
14 Correct 12 ms 1104 KB Output is correct
15 Correct 11 ms 944 KB Output is correct
16 Incorrect 1 ms 344 KB Incorrect
17 Halted 0 ms 0 KB -