Submission #1266153

#TimeUsernameProblemLanguageResultExecution timeMemory
1266153m_bezrutchka저울 (IOI15_scales)C++20
0 / 100
0 ms320 KiB
#include <bits/stdc++.h>
#include "scales.h"
using namespace std;

void init(int T) {
}

void answer(vector<int> v) {
    int resp[6];
    for (int i = 0; i < 6; i++) {
        resp[i] = v[i];
    }
    answer(resp);
}

void orderCoins() {    
    vector<int> a = {0, 1, 2, 3};
    vector<int> b = {0, 4, 5, 6};

    // queries 1, 2: sort first half
    a[1] = getLightest(1, 2, 3);
    a[3] = getHeaviest(1, 2, 3);
    a[2] = 6 - a[1] - a[3];

    // query 3: find median of second half
    // (not sorting b[0] and b[2] yet)
    b[2] = getMedian(4, 5, 6);
    if (b[2] == 4) {
        b[1] = 5; b[3] = 6;
    } else if (b[2] == 5) {
        b[1] = 4; b[3] = 6;
    } else {
        b[1] = 4; b[3] = 5;
    }

    // queries 4, 5: find positions of b[1], b[3] relative to a[1], a[3]
    // pos == 1 -- before a[1]
    // pos == 2 -- between a[1] and a[3]
    // pos == 3 -- after a[3]
    int pos_1, pos_3;
    int x_1 = getMedian(a[1], a[3], b[1]);
    if (x_1 == a[1]) {
        pos_1 = 1;
    } else if (x_1 == a[3]) {
        pos_1 = 3;
    } else {
        pos_1 = 2;
    }
    int x_3 = getMedian(a[1], a[3], b[3]);
    if (x_3 == a[1]) {
        pos_3 = 1;
    } else if (x_3 == a[3]) {
        pos_3 = 3;
    } else {
        pos_3 = 2;
    }

    // case: pos_1 == pos_3 in the border
    if (pos_1 == pos_3 && pos_1 != 2) {
        // query 6: sort b[1], b[3]
        int x = getLightest(b[1], b[2], b[3]);
        if (x == b[3]) {
            swap(b[1], b[3]);
        }
        if (pos_1 == 1) {
            answer({b[1], b[2], b[3], a[1], a[2], a[3]});
        } else {
            answer({a[1], a[2], a[3], b[1], b[2], b[3]});
        }
        return;
    }

    // case: pos_1 == pos_3 in the middle
    if (pos_1 == pos_3 && pos_1 == 2) {
        // a[1] ? ? ? ? a[3]
        // query 6: find second number
        int x = getLightest(b[1], b[3], a[2]);

        if (x == a[2]) {
            // a[1] a[2] ? ? ? a[3]
            // query 7: sort b[]
            int y = getLightest(b[1], b[2], b[3]);
            if (y == b[3]) {
                swap(b[1], b[3]);
            }
            answer({a[1], a[2], b[1], b[2], b[3], a[3]});
        } else {
            if (x == b[3]) {
                swap(b[1], b[3]);
            }
            // a[1] b[1] ? ? ? a[3]
            // qury 7: find pos of a[2] relative to b[2], b[3]
            int y = getMedian(a[2], b[2], b[3]);
            if (y == a[2]) {
                answer({a[1], b[1], b[2], a[2], b[3], a[3]});
            } else if (y == b[2]) {
                answer({a[1], b[1], a[2], b[2], b[3], a[3]});
            } else {
                answer({a[1], b[1], b[2], b[3], a[2], a[3]});
            }
        }
        return;
    }

    // now we can assume pos_1 != pos_3
    if (pos_1 > pos_3) {
        swap(pos_1, pos_3);
        swap(b[1], b[3]);
    }
    // now I know for sure b[1] < b[2] < b[3]

    if (pos_1 == 1 && pos_3 == 2) {
        // b[1] a[1] b[3] a[3]
        int x = getMedian(b[2], a[1], b[3]);
        if (x == a[1]) {
            // b[1] b[2] a[1] b[3] a[3]
            int y = getMedian(b[3], a[2], a[3]);
            if (y == b[3]) {
                answer({b[1], b[2], a[1], a[2], b[3], a[3]});

            } else {
                answer({b[1], b[2], a[1], b[3], a[2], a[3]});
            }
        } else {
            // b[1] a[1] b[2] b[3] a[3]
            int y = getMedian(b[2], b[3], a[2]);
            if (y == b[2]) {
                answer({b[1], a[1], a[2], b[2], b[3], a[3]});
            } else if (y == b[3]) {
                answer({b[1], a[1], b[2], b[3], a[2], a[3]});
            } else {
                answer({b[1], a[1], b[2], a[2], b[3], a[3]});
            }
        }
    } else if (pos_1 == 2 && pos_3 == 3) {
        // a[1] b[1] a[3] b[3]
        int x = getMedian(b[1], b[2], a[3]);
        if (x == b[2]) {
            // a[1] b[1] b[2] a[3] b[3]
            int y = getMedian(a[2], b[1], b[2]);
            if (y == b[1]) {
                answer({a[1], a[2], b[1], b[2], a[3], b[3]});
            } else if (y == a[2]) {
                answer({a[1], b[1], a[2], b[2], a[3], b[3]});
            } else {
                answer({a[1], b[1], b[2], a[2], a[3], b[3]});
            }
        } else {
            // a[1] b[1] a[3] b[2] b[3]
            int y = getMedian(a[2], b[1], a[3]);
            if (y == a[2]) {
                answer({a[1], b[1], a[2], a[3], b[2], b[3]});
            } else {
                answer({a[1], a[2], b[1], a[3], b[2], b[3]});
            }
        }
    } else {
        // b[1] a[1] a[3] b[3]
        int x = getMedian(a[1], b[2], a[3]);
        if (x == a[1]) {
            // b[1] b[2] a[1] a[3] b[3]
        } else if (x == b[2]) {
            // b[1] a[1] b[2] a[3] b[3]
            int y = getMedian(a[1], b[2], a[2]);
            if (y == a[2]) {
                answer({b[1], a[1], a[2], b[2], a[3], b[3]});
            } else {
                answer({b[1], a[1], b[2], a[2], a[3], b[3]});
            }
        } else {
            // b[1] b[2] a[1] a[3] b[3]
            answer({b[1], b[2], a[1], a[2], a[3], b[3]});
        }
    }
}
#Verdict Execution timeMemoryGrader output
Fetching results...