Problem p02604 (C++) — buggy submission, verdict: Time Limit Exceeded

// include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <locale>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

// typedef
//------------------------------------------
typedef long long LL;
typedef vector<int> VI;
typedef vector<bool> VB;
typedef vector<char> VC;
typedef vector<double> VD;
typedef vector<string> VS;
typedef vector<LL> VLL;
typedef vector<VI> VVI;
typedef vector<VB> VVB;
typedef vector<VS> VVS;
typedef vector<VLL> VVLL;
typedef vector<VVI> VVVI;
typedef vector<VVLL> VVVLL;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<int, string> PIS;
typedef pair<string, int> PSI;
typedef pair<string, string> PSS;
typedef vector<PII> VPII;
typedef vector<PLL> VPLL;
typedef vector<VPII> VVPII;
typedef vector<VPLL> VVPLL;
typedef vector<VS> VVS;
typedef map<int, int> MII;
typedef map<LL, LL> MLL;
typedef map<string, int> MSI;
typedef map<int, string> MIS;

// container util
//------------------------------------------

typedef int pInt[4];
#define ALL(a) (a).begin(), (a).end()
#define SZ(a) int((a).size())
#define EACH(i, arr)                                                           \\
  for (typeof((arr).begin()) i = (arr).begin(); i != (arr).end(); ++i)
#define EXIST(str, e) ((str).find(e) != (str).end())
#define COUNT(arr, v) count((arr).begin(), (arr).end(), v)
#define SEARCH(v, w) search((v).begin(), (v).end(), (w).begin(), (w).end())
#define SORT(c) sort((c).begin(), (c).end())
#define RSORT(c) sort((c).rbegin(), (c).rend())
#define REVERSE(c) reverse((c).begin(), (c).end())
#define ROTATE_LEFT(arr, c)                                                    \\
  rotate((arr).begin(), (arr).begin() + (c), (arr).end())
#define ROTATE_RIGHT(arr, c)                                                   \\
  rotate((arr).rbegin(), (arr).rbegin() + (c), (arr).rend())
#define SUMI(arr) accumulate((arr).begin(), (arr).end(), 0)
#define SUMD(arr) accumulate((arr).begin(), (arr).end(), 0.)
#define SUMLL(arr) accumulate((arr).begin(), (arr).end(), 0LL)
#define MULD(arr)                                                              \\
  accumulate((arr).begin(), (arr).end(), 1., multiplies<double>())
#define UB(arr, n) upper_bound((arr).begin(), (arr).end(), n)
#define LB(arr, n) lower_bound((arr).begin(), (arr).end(), n)
#define PB push_back
#define MP make_pair
#define ft first
#define sd second

// input output
//------------------------------------------
#define GL(s) getline(cin, (s))
#define INIT()                                                                 \\
  std::ios::sync_with_stdio(false);                                            \\
  std::cin.tie(0)
#define OUT(d) std::cout << (d)
#define OUT_L(d) std::cout << (d) << endl
#define FOUT(n, data) std::cout << std::fixed << std::setprecision(n) << (data)
#define FOUT_L(n, data)                                                        \\
  std::cout << std::fixed << std::setprecision(n) << (data) << "\\n"
#define EL() printf("\\n")
#define SHOW_VECTOR(v)                                                         \\
  {                                                                            \\
    std::cerr << #v << "\\t:";                                                  \\
    for (const auto &xxx : v) {                                                \\
      std::cerr << xxx << " ";                                                 \\
    }                                                                          \\
    std::cerr << "\\n";                                                         \\
  }
#define SHOW_MAP(v)                                                            \\
  {                                                                            \\
    std::cerr << #v << endl;                                                   \\
    for (const auto &xxx : v) {                                                \\
      std::cerr << xxx.first << " " << xxx.second << "\\n";                     \\
    }                                                                          \\
  }
#define Yes() printf("Yes\\n")
#define No() printf("No\\n")
#define YES() printf("YES\\n")
#define NO() printf("NO\\n")
#define Yay() printf("Yay!\\n")
#define Nnn() printf(":(\\n")
#define CE(x, y) ((x + y - 1) / (y))

template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &p) {
  in >> p.first >> p.second;
  return in;
}

template <typename T> istream &operator>>(istream &in, vector<T> &v) {
  for (auto &x : v)
    in >> x;
  return in;
}

template <typename T1, typename T2>
ostream &operator<<(ostream &out, const std::pair<T1, T2> &p) {
  out << "[" << p.first << ", " << p.second << "]"
      << "\\n";
  return out;
}

template <class T1, class T2> inline bool chmin(T1 &a, T2 b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}

template <class T1, class T2> inline bool chmax(T1 &a, T2 b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}

// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) for (int i = n - 1; i >= 0; i--)
#define FORLL(i, a, b) for (LL i = LL(a); i < LL(b); ++i)
#define RFORLL(i, a, b) for (LL i = LL(b) - 1; i >= LL(a); --i)
#define REPLL(i, n) for (LL i = 0; i < LL(n); ++i)
#define RREPLL(i, n) for (LL i = LL(n) - 1; i >= 0; --i)
#define FOREACH(x, arr) for (auto &(x) : (arr))

// Option + Control + K  Terminal
// Command + Control + K    Run
// Command + b   EOF

//------------------------------------------
//------------------------------------------

VLL solve(int N, VLL X, VLL Y, VLL P) {
  constexpr LL INF = 1LL << 62;
  LL mul = 1;
  REP(i, N) mul *= 3;

  // xsel[bit][j] = bitが1のところに立てるときの　都市jのコスト
  VVLL xsel(1 << N, VLL(N));
  VVLL ysel(1 << N, VLL(N));
  REP(bit, 1 << N) {
    // j番目の都市
    REP(j, N) {
      xsel[bit][j] = abs(X[j]);
      ysel[bit][j] = abs(Y[j]);
      REP(k, N) {
        if ((bit >> k) & 1) {
          chmin(xsel[bit][j], abs(X[j] - X[k]));
          chmin(ysel[bit][j], abs(Y[j] - Y[k]));
        }
      }
    }
  }

  VLL ans(N + 1, INF);
  REP(bit, 1 << N) {
    int bit_cnt = __builtin_popcount(bit);
    for (int j = bit; j >= 0; j--) {
      j &= bit;
      LL cost = 0;
      REP(k, N) {
        if (!((bit >> k) & 1)) {
          cost += min(xsel[j][k], ysel[bit - j][k]) * P[k];
        }
      }
      ans[bit_cnt] = min(ans[bit_cnt], cost);
    }
  }

  return ans;
}

int main() {

  int N;
  cin >> N;

  VLL X(N), Y(N), P(N);
  REP(i, N) cin >> X[i] >> Y[i] >> P[i];

  auto ans = solve(N, X, Y, P);
  REP(i, N + 1) cout << ans[i] << endl;
}


Error: TLE

Fixed submission:

// include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <locale>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

// typedef
//------------------------------------------
typedef long long LL;
typedef vector<int> VI;
typedef vector<bool> VB;
typedef vector<char> VC;
typedef vector<double> VD;
typedef vector<string> VS;
typedef vector<LL> VLL;
typedef vector<VI> VVI;
typedef vector<VB> VVB;
typedef vector<VS> VVS;
typedef vector<VLL> VVLL;
typedef vector<VVI> VVVI;
typedef vector<VVLL> VVVLL;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<int, string> PIS;
typedef pair<string, int> PSI;
typedef pair<string, string> PSS;
typedef vector<PII> VPII;
typedef vector<PLL> VPLL;
typedef vector<VPII> VVPII;
typedef vector<VPLL> VVPLL;
typedef vector<VS> VVS;
typedef map<int, int> MII;
typedef map<LL, LL> MLL;
typedef map<string, int> MSI;
typedef map<int, string> MIS;

// container util
//------------------------------------------

typedef int pInt[4];
#define ALL(a) (a).begin(), (a).end()
#define SZ(a) int((a).size())
#define EACH(i, arr)                                                           \\
  for (typeof((arr).begin()) i = (arr).begin(); i != (arr).end(); ++i)
#define EXIST(str, e) ((str).find(e) != (str).end())
#define COUNT(arr, v) count((arr).begin(), (arr).end(), v)
#define SEARCH(v, w) search((v).begin(), (v).end(), (w).begin(), (w).end())
#define SORT(c) sort((c).begin(), (c).end())
#define RSORT(c) sort((c).rbegin(), (c).rend())
#define REVERSE(c) reverse((c).begin(), (c).end())
#define ROTATE_LEFT(arr, c)                                                    \\
  rotate((arr).begin(), (arr).begin() + (c), (arr).end())
#define ROTATE_RIGHT(arr, c)                                                   \\
  rotate((arr).rbegin(), (arr).rbegin() + (c), (arr).rend())
#define SUMI(arr) accumulate((arr).begin(), (arr).end(), 0)
#define SUMD(arr) accumulate((arr).begin(), (arr).end(), 0.)
#define SUMLL(arr) accumulate((arr).begin(), (arr).end(), 0LL)
#define MULD(arr)                                                              \\
  accumulate((arr).begin(), (arr).end(), 1., multiplies<double>())
#define UB(arr, n) upper_bound((arr).begin(), (arr).end(), n)
#define LB(arr, n) lower_bound((arr).begin(), (arr).end(), n)
#define PB push_back
#define MP make_pair
#define ft first
#define sd second

// input output
//------------------------------------------
#define GL(s) getline(cin, (s))
#define INIT()                                                                 \\
  std::ios::sync_with_stdio(false);                                            \\
  std::cin.tie(0)
#define OUT(d) std::cout << (d)
#define OUT_L(d) std::cout << (d) << endl
#define FOUT(n, data) std::cout << std::fixed << std::setprecision(n) << (data)
#define FOUT_L(n, data)                                                        \\
  std::cout << std::fixed << std::setprecision(n) << (data) << "\\n"
#define EL() printf("\\n")
#define SHOW_VECTOR(v)                                                         \\
  {                                                                            \\
    std::cerr << #v << "\\t:";                                                  \\
    for (const auto &xxx : v) {                                                \\
      std::cerr << xxx << " ";                                                 \\
    }                                                                          \\
    std::cerr << "\\n";                                                         \\
  }
#define SHOW_MAP(v)                                                            \\
  {                                                                            \\
    std::cerr << #v << endl;                                                   \\
    for (const auto &xxx : v) {                                                \\
      std::cerr << xxx.first << " " << xxx.second << "\\n";                     \\
    }                                                                          \\
  }
#define Yes() printf("Yes\\n")
#define No() printf("No\\n")
#define YES() printf("YES\\n")
#define NO() printf("NO\\n")
#define Yay() printf("Yay!\\n")
#define Nnn() printf(":(\\n")
#define CE(x, y) ((x + y - 1) / (y))

template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &p) {
  in >> p.first >> p.second;
  return in;
}

template <typename T> istream &operator>>(istream &in, vector<T> &v) {
  for (auto &x : v)
    in >> x;
  return in;
}

template <typename T1, typename T2>
ostream &operator<<(ostream &out, const std::pair<T1, T2> &p) {
  out << "[" << p.first << ", " << p.second << "]"
      << "\\n";
  return out;
}

template <class T1, class T2> inline bool chmin(T1 &a, T2 b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}

template <class T1, class T2> inline bool chmax(T1 &a, T2 b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}

// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) for (int i = n - 1; i >= 0; i--)
#define FORLL(i, a, b) for (LL i = LL(a); i < LL(b); ++i)
#define RFORLL(i, a, b) for (LL i = LL(b) - 1; i >= LL(a); --i)
#define REPLL(i, n) for (LL i = 0; i < LL(n); ++i)
#define RREPLL(i, n) for (LL i = LL(n) - 1; i >= 0; --i)
#define FOREACH(x, arr) for (auto &(x) : (arr))

// Option + Control + K  Terminal
// Command + Control + K    Run
// Command + b   EOF

//------------------------------------------
//------------------------------------------

template <class Iter>
bool next_partial_permutation(Iter first, Iter middle, Iter last) {
  reverse(middle, last);
  return next_permutation(first, last);
}

template <class Iter>
bool next_combination(Iter first1, Iter last1, Iter first2, Iter last2) {
  if ((first1 == last1) || (first2 == last2)) {
    return false;
  }
  Iter m1 = last1;
  Iter m2 = last2;
  --m2;
  while (--m1 != first1 && !(*m1 < *m2)) {
  }
  bool result = (m1 == first1) && !(*first1 < *m2);
  if (!result) {
    while (first2 != m2 && !(*m1 < *first2)) {
      ++first2;
    }
    first1 = m1;
    std::iter_swap(first1, first2);
    ++first1;
    ++first2;
  }
  if ((first1 != last1) && (first2 != last2)) {
    m1 = last1;
    m2 = first2;
    while ((m1 != first1) && (m2 != last2)) {
      std::iter_swap(--m1, m2);
      ++m2;
    }
    std::reverse(first1, m1);
    std::reverse(first1, last1);
    std::reverse(m2, last2);
    std::reverse(first2, last2);
  }
  return !result;
}

int main() {

  LL N;
  cin >> N;

  VLL X(N), Y(N), P(N);
  REP(i, N) cin >> X[i] >> Y[i] >> P[i];

  // 何本か
  for (int k = 0; k <= N; k++) {

    vector<int> index(N);
    iota(ALL(index), 0);

    LL ans = LLONG_MAX;

    VLL D(N);
    REP(i, N) D[i] = min(abs(X[i]), abs(Y[i]));

    // k個どこを選ぶか 6435 15Ck
    do {

      VLL which(k);

      // x方向か y方向か 2^k
      for (int bit = 0; bit < (1 << k); bit++) {
        auto div = D;
        for (int i = 0; i < k; i++) {
          // x方向に引く
          if (bit & (1 << i)) {
            which[i] = 1;
          } else {
            // y方向に引く
            which[i] = 0;
          }
        }

        for (int i = 0; i < k; i++) {
          // 線を引く基準の街　
          int id = index[i];
          if (which[i]) {
            LL dy = Y[id];
            for (int j = 0; j < N; j++) {
              chmin(div[j], abs(dy - Y[j]));
            }
          }
          if (!which[i]) {
            LL dx = X[id];
            for (int j = 0; j < N; j++) {
              chmin(div[j], abs(dx - X[j]));
            }
          }
        }

        LL cost = 0;
        for (int i = 0; i < N; i++)
          cost += div[i] * P[i];
        chmin(ans, cost);
      }

    } while (next_combination(index.begin(), index.begin() + k,
                              index.begin() + k, index.end()));

    cout << ans << endl;
  }
}