Problem p03379 (C++)

Buggy submission (status: Time Limit Exceeded):
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using LL = long long;
using ULL = unsigned long long;
constexpr int INF = 2147483647;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};

// 以下はC++の練習のための便利プログラム　あんまり便利じゃないけど…
//------------------------------------------便利型----------------------------------------------
// 二次元の点
// TODO map,setのほうが楽かも
template <typename T> struct Point2D {
  T x;
  T y;

  friend ostream &operator<<(ostream &os, const Point2D<T> &point);
};

ostream &operator<<(ostream &os, const Point2D<int> &point) {
  os << "(" << point.x << ',' << point.y << ")";
  return os;
}

// 長くて読みづらかったのでエイリアステンプレートに
template <class T> using StdAlloc = std::allocator<T>;
//------------------------------------------便利型----------------------------------------------

//-----------------------------------------便利関数---------------------------------------------
// ユニークな要素数
template <class T> unsigned long long UniqueElementNum(const vector<T> &data) {
  auto copy = data;

  sort(begin(copy), end(copy));
  copy.erase(unique(begin(copy), end(copy)), end(copy));

  return copy.size();

  // set<unsigned long long>(begin(copy), end(copy)).size();
  // //１行版　マクロにしても良い
}

// 最小公倍数
long long gcd(long long a, long long b) {
  long long c;

  if (a < b) {
    a += b;
    b = a - b;
    a -= b;
  }

  while (b != 0) {
    c = a % b;
    a = b;
    b = c;
  }

  return a;
}

// 素数かどうか
bool IsPrime(ULL num) {
  if (num < 2)
    return false;
  else if (num == 2)
    return true;
  else if (num % 2 == 0)
    return false; // 偶数はあらかじめ除く

  double sqrtNum = sqrt(num);
  for (ULL i = 3; i <= sqrtNum; i += 2) {
    if (num % i == 0) {
      // 素数ではない
      return false;
    }
  }

  // 素数である
  return true;
}

// 素因数分解　試し割り（sqrt(n)まで）
// もっと早い方法もあるらしい…
void DecomposePrime(ULL n, vector<tuple<ULL, ULL>> &result) {
  vector<ULL> primeList;

  // 割る数の初期値
  ULL a = 2;

  // √n ≧ a ( n ≧ a * a ) の間ループ処理
  while (n >= a * a) {
    // a で割り切れたら、a は素因数
    // そして、割られる数を a で割る
    // a で割り切れなかったら、 a を 1 増加させる
    if (n % a == 0) {
      primeList.emplace_back(a);
      n /= a;
    } else {
      a++;
    }
  }
  // 最後に残った n は素因数
  primeList.emplace_back(n);

  // 素因数がそれぞれいくつあるかを調べる
  set<ULL> uniquePrimeList(begin(primeList), end(primeList));
  for (const auto &p : uniquePrimeList) {
    ULL primeNum = count(begin(primeList), end(primeList), p);
    result.emplace_back(make_tuple(p, primeNum));
  }
}

// n個からr個取り出す組み合わせの数
template <typename Type> Type nCr(Type n, Type r) {
  Type ans = 1;
  for (Type i = n; i > n - r; --i) {
    ans = ans * i;
  }
  for (Type i = 1; i < r + 1; ++i) {
    ans = ans / i;
  }
  return ans;
}

// 新しい方に対応したい場合、以下を参考にする
// コンテナへ要素を追加
// プリミティブ型など
template <class Num, class Container>
void InitContainer(Num num, Container &container) {
  container.resize(num);
  for (auto &d : container) {
    cin >> d;
  }
}

// コンテナへ要素を追加
// Container<Point2D<T>>で特殊化　読みにくい…　マクロにする？
template <class Num,
          template <class T, class Allocator = StdAlloc<T>> class Container,
          class T2>
void InitContainer(Num num, Container<Point2D<T2>> &firstContainer) {
  firstContainer.resize(num);
  for (auto &d : firstContainer) {
    cin >> d.x >> d.y;
  }
}

// コンテナへ要素を追加　を呼び出す処理
template <class Num, class First, class... Rest>
void InitContainer(Num num, First &first, Rest &...rest) {
  InitContainer(num, first);
  InitContainer(num, rest...);
}

// 要素数Nと各要素をコンテナに格納
// コンテナを複数個取れるようにしてみた　テンプレートの練習
template <class Num, class... Container>
void InitNumAndContainer(Num &num, Container &...container) {
  cin >> num;
  InitContainer(num, container...);
}

// コンテナの内容をstreamへ出力
// 今はてきとーにcoutへ改行しながら　果たしてこの書き方は便利なのか…？
// #TODO 引数増やしたりオーバーロード増やしたり
template <template <class T, class Allocator = StdAlloc<T>> class Container,
          class T>
void ShowContainer(const Container<T> &container) {
  ostream_iterator<T> outItr(cout, "\n");
  copy(container.begin(), container.end(), outItr);
  cout << endl;
}

//-----------------------------------------便利関数---------------------------------------------

int main() {
  int N;
  cin >> N;

  vector<int> AList;
  InitContainer(N, AList);

  struct NumAndIndx {
    int A;
    int indx;
  };

  vector<NumAndIndx> NumAndIndxList;
  for (const auto &A : AList) {
    NumAndIndxList.push_back({A, (int)NumAndIndxList.size()});
  }

  sort(begin(NumAndIndxList), end(NumAndIndxList),
       [&](const auto &a, const auto &b) { return a.A < b.A; });

  for (int i = 0; i < NumAndIndxList.size(); i++) {
    auto copy = NumAndIndxList;
    copy.erase(
        remove_if(begin(copy), end(copy),
                  [&](const auto &numAndIndx) { return numAndIndx.indx == i; }),
        end(copy));

    cout << copy[N / 2 - 1].A << endl;
  }

  return 0;
}

Fixed submission:
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using LL = long long;
using ULL = unsigned long long;
constexpr int INF = 2147483647;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};

// 以下はC++の練習のための便利プログラム　あんまり便利じゃないけど…
//------------------------------------------便利型----------------------------------------------
// 二次元の点
// TODO map,setのほうが楽かも
template <typename T> struct Point2D {
  T x;
  T y;

  friend ostream &operator<<(ostream &os, const Point2D<T> &point);
};

ostream &operator<<(ostream &os, const Point2D<int> &point) {
  os << "(" << point.x << ',' << point.y << ")";
  return os;
}

// 長くて読みづらかったのでエイリアステンプレートに
template <class T> using StdAlloc = std::allocator<T>;
//------------------------------------------便利型----------------------------------------------

//-----------------------------------------便利関数---------------------------------------------
// ユニークな要素数
template <class T> unsigned long long UniqueElementNum(const vector<T> &data) {
  auto copy = data;

  sort(begin(copy), end(copy));
  copy.erase(unique(begin(copy), end(copy)), end(copy));

  return copy.size();

  // set<unsigned long long>(begin(copy), end(copy)).size();
  // //１行版　マクロにしても良い
}

// 最小公倍数
long long gcd(long long a, long long b) {
  long long c;

  if (a < b) {
    a += b;
    b = a - b;
    a -= b;
  }

  while (b != 0) {
    c = a % b;
    a = b;
    b = c;
  }

  return a;
}

// 素数かどうか
bool IsPrime(ULL num) {
  if (num < 2)
    return false;
  else if (num == 2)
    return true;
  else if (num % 2 == 0)
    return false; // 偶数はあらかじめ除く

  double sqrtNum = sqrt(num);
  for (ULL i = 3; i <= sqrtNum; i += 2) {
    if (num % i == 0) {
      // 素数ではない
      return false;
    }
  }

  // 素数である
  return true;
}

// 素因数分解　試し割り（sqrt(n)まで）
// もっと早い方法もあるらしい…
void DecomposePrime(ULL n, vector<tuple<ULL, ULL>> &result) {
  vector<ULL> primeList;

  // 割る数の初期値
  ULL a = 2;

  // √n ≧ a ( n ≧ a * a ) の間ループ処理
  while (n >= a * a) {
    // a で割り切れたら、a は素因数
    // そして、割られる数を a で割る
    // a で割り切れなかったら、 a を 1 増加させる
    if (n % a == 0) {
      primeList.emplace_back(a);
      n /= a;
    } else {
      a++;
    }
  }
  // 最後に残った n は素因数
  primeList.emplace_back(n);

  // 素因数がそれぞれいくつあるかを調べる
  set<ULL> uniquePrimeList(begin(primeList), end(primeList));
  for (const auto &p : uniquePrimeList) {
    ULL primeNum = count(begin(primeList), end(primeList), p);
    result.emplace_back(make_tuple(p, primeNum));
  }
}

// n個からr個取り出す組み合わせの数
template <typename Type> Type nCr(Type n, Type r) {
  Type ans = 1;
  for (Type i = n; i > n - r; --i) {
    ans = ans * i;
  }
  for (Type i = 1; i < r + 1; ++i) {
    ans = ans / i;
  }
  return ans;
}

// 新しい方に対応したい場合、以下を参考にする
// コンテナへ要素を追加
// プリミティブ型など
template <class Num, class Container>
void InitContainer(Num num, Container &container) {
  container.resize(num);
  for (auto &d : container) {
    cin >> d;
  }
}

// コンテナへ要素を追加
// Container<Point2D<T>>で特殊化　読みにくい…　マクロにする？
template <class Num,
          template <class T, class Allocator = StdAlloc<T>> class Container,
          class T2>
void InitContainer(Num num, Container<Point2D<T2>> &firstContainer) {
  firstContainer.resize(num);
  for (auto &d : firstContainer) {
    cin >> d.x >> d.y;
  }
}

// コンテナへ要素を追加　を呼び出す処理
template <class Num, class First, class... Rest>
void InitContainer(Num num, First &first, Rest &...rest) {
  InitContainer(num, first);
  InitContainer(num, rest...);
}

// 要素数Nと各要素をコンテナに格納
// コンテナを複数個取れるようにしてみた　テンプレートの練習
template <class Num, class... Container>
void InitNumAndContainer(Num &num, Container &...container) {
  cin >> num;
  InitContainer(num, container...);
}

// コンテナの内容をstreamへ出力
// 今はてきとーにcoutへ改行しながら　果たしてこの書き方は便利なのか…？
// #TODO 引数増やしたりオーバーロード増やしたり
template <template <class T, class Allocator = StdAlloc<T>> class Container,
          class T>
void ShowContainer(const Container<T> &container) {
  ostream_iterator<T> outItr(cout, "\n");
  copy(container.begin(), container.end(), outItr);
  cout << endl;
}

//-----------------------------------------便利関数---------------------------------------------

int main() {
  int N;
  cin >> N;

  vector<int> AList;
  InitContainer(N, AList);

  struct NumAndIndx {
    int A;
    int indx;
  };

  vector<NumAndIndx> NumAndIndxList;
  for (const auto &A : AList) {
    NumAndIndxList.push_back({A, (int)NumAndIndxList.size()});
  }

  sort(begin(NumAndIndxList), end(NumAndIndxList),
       [&](const auto &a, const auto &b) { return a.A < b.A; });

  vector<NumAndIndx> resultList(N);

  for (int i = 0; i < N; i++) {
    if (i < N / 2) {
      resultList[i] = {NumAndIndxList[N / 2].A, NumAndIndxList[i].indx};
    } else {
      resultList[i] = {NumAndIndxList[N / 2 - 1].A, NumAndIndxList[i].indx};
    }
  }

  // インデックスでソート
  sort(begin(resultList), end(resultList),
       [](const auto &a, const auto &b) { return a.indx < b.indx; });

  for (const auto &numAndIndx : resultList) {
    cout << numAndIndx.A << endl;
  }

  return 0;
}