Submission #1266546

#TimeUsernameProblemLanguageResultExecution timeMemory
1266546julia_08Scales (IOI15_scales)C++20
71.43 / 100
0 ms328 KiB
#include <bits/stdc++.h>
#include "scales.h"

using namespace std;

void init(int T){

}

void add(vector<int> &ans, int nxt, int x){

  // eh maior que todo mundo

  if(nxt == -1){
    ans.push_back(x);
    return;
  }

  vector<int> new_ans;

  for(auto i : ans){
    if(i == nxt) new_ans.push_back(x);
    new_ans.push_back(i);
  }

  ans = new_ans;

}

void orderCoins(){

  // 7 queries

  int A[4], B[4];

  A[1] = getLightest(1, 2, 3);
  A[2] = getMedian(1, 2, 3);

  A[3] = 6 - A[1] - A[2];

  // A[1] <= A[2] <= A[3]

  // no segundo vetor, só acho a mediana

  B[2] = getMedian(4, 5, 6);

  B[1] = 4;
  B[3] = 6;

  // B[1], B[3] nao ta necessariamente ordenado

  if(B[1] == B[2]) B[1] = 5;
  if(B[3] == B[2]) B[3] = 5;

  int pos_B1 = getMedian(A[1], A[3], B[1]), pos_B3 = getMedian(A[1], A[3], B[3]);

  // 0 A[1] A[3] 
  // A[1] 1 A[3]
  // A[1] A[3] 2

  if(pos_B1 == A[1]){
    pos_B1 = 0;

  } else if(pos_B1 == B[1]){
    pos_B1 = 1;

  } else pos_B1 = 2;

  if(pos_B3 == A[1]){
    pos_B3 = 0;

  } else if(pos_B3 == B[3]){
    pos_B3 = 1;

  } else pos_B3 = 2;

  if(pos_B1 > pos_B3){
    swap(pos_B1, pos_B3);
    swap(B[1], B[3]);
  }

  int W[6];
   
  // muitos casos:

  vector<int> ans;

  if(pos_B1 == 0){

    if(pos_B3 == 0){

      if(getLightest(B[1], B[2], B[3]) != B[1]) swap(B[1], B[3]);

      for(int i=1; i<=3; i++) ans.push_back(B[i]);
      for(int i=1; i<=3; i++) ans.push_back(A[i]);

      for(int i=0; i<6; i++) W[i] = ans[i];

      answer(W);

    } else if(pos_B3 == 1){

      ans = {B[1], A[1], A[2], A[3]};

      add(ans, getNextLightest(A[1], A[2], A[3], B[2]), B[2]);
      add(ans, getNextLightest(A[1], A[2], A[3], B[3]), B[3]);

      for(int i=0; i<6; i++) W[i] = ans[i];

      answer(W);

    } else if(pos_B3 == 2){

      if(getMedian(B[1], B[2], A[1]) == B[2]){

        ans = {B[1], B[2], A[1], A[2], A[3], B[3]};

      } else{

        ans = {B[1], A[1], A[2], A[3], B[3]};

        int pos = getNextLightest(A[2], A[3], B[3], B[2]);
        add(ans, pos, B[2]);

      }
      
      for(int i=0; i<6; i++) W[i] = ans[i];

      answer(W);
    
    }

  } else if(pos_B1 == 1){

    if(pos_B3 == 1){

      // caso chato :(

      /*
      query 6: getLightest({b1, b3, a2})

      se deu a2, a ordem é a1 a2 ... a3:
        query 7: getLightest({b1, b2, b3})

      caso contrário, descobrimos quem é o b1 real e a ordem é a1 b1 ... a3
        query 7: getMedian({a2, b2, b3})
      */

      int x = getLightest(B[1], B[3], A[2]);

      if(x == A[2]){

        if(getLightest(B[1], B[2], B[3]) == B[3]) swap(B[1], B[3]);

        ans = {A[1], A[2], B[1], B[2], B[3], A[3]};

      } else{

        if(x == B[3]) swap(B[1], B[3]);

        int m = getMedian(A[2], B[2], B[3]);

        if(m == B[3]){
          
          ans = {A[1], B[1], B[2], B[3], A[2], A[3]};
        
        } else if(m == A[2]){
          
          ans = {A[1], B[1], B[2], A[2], B[3], A[3]};

        } else ans = {A[1], B[1], A[2], B[2], B[3], A[3]};

      }

      for(int i=0; i<6; i++) W[i] = ans[i];

      answer(W);

    } else if(pos_B3 == 2){

      ans = {A[1], A[2], A[3], B[3]};

      add(ans, getNextLightest(A[1], A[2], A[3], B[1]), B[1]);
      add(ans, getNextLightest(A[2], A[3], B[3], B[2]), B[2]);

      for(int i=0; i<6; i++) W[i] = ans[i];

      answer(W);

    }

  } else if(pos_B1 == 2){

    if(pos_B3 == 2){

      if(getLightest(B[1], B[2], B[3]) != B[1]) swap(B[1], B[3]);

      for(int i=1; i<=3; i++) ans.push_back(A[i]);
      for(int i=1; i<=3; i++) ans.push_back(B[i]);

      for(int i=0; i<6; i++) W[i] = ans[i];

      answer(W);

    }

  }
  
}
#Verdict Execution timeMemoryGrader output
Fetching results...