/**
 * @file qoj7119.cpp
 * @author n685
 * @brief
 * @date 2023-12-27
 *
 *
 */
#include "longesttrip.h"
#include <bits/stdc++.h>

#ifdef LOCAL
#include "dd/debug.h"
#else
#define dbg(...) 42
#define dbgR(...) 4242
#define dbgP(...) 420
#define dbgRP(...) 420420
void nline() {}
#endif
std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());

std::vector<int> longest_trip(int N, int D) {
  int n = N;
  std::vector<int> ind(n);
  std::iota(ind.begin(), ind.end(), 0);
  // std::shuffle(ind.begin(), ind.end(), rng);

  auto query = [&](std::vector<int> a, std::vector<int> b) {
    std::vector<int> A(a.size()), B(b.size());
    for (int i = 0; i < (int)a.size(); ++i) {
      A[i] = ind[a[i]];
    }
    for (int i = 0; i < (int)b.size(); ++i) {
      B[i] = ind[b[i]];
    }
    return are_connected(A, B);
  };

  std::vector<std::vector<int>> gr;
  for (int i = 0; i < n; ++i) {
    gr.push_back(std::vector{i});
  }
  auto merge = [&](auto &a, auto &b) {
    if ((int)a.size() < (int)b.size()) {
      std::swap(a, b);
    }
    std::reverse(a.begin(), a.end());
    for (int i : b) {
      a.push_back(i);
    }
    b.clear();
  };

  while ((int)gr.size() >= 4) {
    std::vector g{gr.back(), gr.end()[-2], gr.end()[-3], gr.end()[-4]};
    for (int i = 0; i < 4; ++i) {
      gr.pop_back();
    }
    if (query({g[0][0]}, {g[1][0]})) {
      merge(g[0], g[1]);
      if (query({g[2][0]}, {g[0][0]})) {
        merge(g[0], g[2]);
        gr.push_back(g[3]);
      } else if (query({g[3][0]}, {g[0][0]})) {
        merge(g[0], g[3]);
        gr.push_back(g[2]);
      } else {
        merge(g[2], g[3]);
        gr.push_back(g[2]);
      }
      gr.push_back(g[0]);
    } else if (query({g[0][0]}, {g[2][0]})) {
      merge(g[0], g[2]);
      if (query({g[0][0]}, {g[3][0]})) {
        merge(g[0], g[3]);
        gr.push_back(g[2]);
      } else {
        merge(g[1], g[3]);
        gr.push_back(g[1]);
      }
      gr.push_back(g[0]);
    } else {
      merge(g[1], g[2]);
      if (query({g[1][0]}, {g[3][0]})) {
        merge(g[1], g[3]);
        gr.push_back(g[0]);
      } else {
        merge(g[3], g[0]);
        gr.push_back(g[3]);
      }
      gr.push_back(g[1]);
    }
  }
  if ((int)gr.size() == 3) {
    auto ga = gr.back(), gb = gr.end()[-2], gc = gr.end()[-3];
    gr.pop_back(), gr.pop_back(), gr.pop_back();
    if (query({ga[0]}, {gb[0]})) {
      std::swap(ga, gc);
    } else if (query({ga[0]}, {gc[0]})) {
      std::swap(ga, gb);
    }
    merge(gb, gc);
    gr.push_back(ga);
    gr.push_back(gb);
  }
  // assert(gr.size() == 2 && !gr[0].empty() && !gr[1].empty());

  auto answer = [&](const std::vector<int> &seq) {
    std::vector<int> ans;
    for (int i : seq) {
      ans.push_back(ind[i]);
    }
    return ans;
  };
  if (!query(gr[0], gr[1])) {
    if ((int)gr[0].size() < (int)gr[1].size()) {
      std::swap(gr[0], gr[1]);
    }
    return answer(gr[0]);
  }

  int l1 = -1, l2 = -1;
  for (int i = 0; i < 2; ++i) {
    for (int j = 0; j < 2; ++j) {
      if (query({gr[0][0]}, {gr[1][0]})) {
        l1 = 0;
        l2 = 0;
        break;
      }
      std::reverse(gr[1].begin(), gr[1].end());
    }
    if (l1 == 0) {
      break;
    }
    std::reverse(gr[0].begin(), gr[0].end());
  }
  if (l1 != 0) {
    assert(l1 < 0);
    l1 = 0;
    int r1 = (int)gr[0].size() - 1;
    while (l1 < r1) {
      int mid = (l1 + r1) / 2;
      if (query(std::vector<int>(gr[0].begin(), gr[0].begin() + mid + 1),
                gr[1])) {
        r1 = mid;
      } else {
        l1 = mid + 1;
      }
    }
    l2 = 0;
    int r2 = (int)gr[1].size() - 1;
    while (l2 < r2) {
      int mid = (l2 + r2) / 2;
      if (query({gr[0][l1]},
                std::vector<int>(gr[1].begin(), gr[1].begin() + mid + 1))) {
        r2 = mid;
      } else {
        l2 = mid + 1;
      }
    }
  }

  std::rotate(gr[0].begin(), gr[0].begin() + l1, gr[0].end());
  std::rotate(gr[1].begin(), gr[1].begin() + l2, gr[1].end());
  merge(gr[0], gr[1]);
  return answer(gr[0]);
}