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

#include <bits/stdc++.h>
using namespace std;

using ll = long long;
#define int ll

// [a -> b-1]
#define reps(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
// [0 -> a-1]
#define rep(i, a) reps(i, 0, (a))
// [a-1 -> b]
#define rreps(i, a, b) for (int i = (int)((a)-1); i >= (int)(b); i--)
// [a-1 -> 0]
#define rrep(i, a) rreps(i, a, 0)
#define all(v) (v).begin(), (v).end()
// next_permutation(all(v))
#define PERM(v) next_permutation(all(v))
/*sort(all(v));
 * (v).erase(unique(all(v)), v.end())*/
#define UNIQUE(v)                                                              \\
  sort(all(v));                                                                \\
  (v).erase(unique(all(v)), v.end())
// b is [a, c)
#define RANGE(a, b, c) ((a) <= (b) && (b) < (c))
// c is [a, e) && d is [b, f)
#define RANGE2D(a, b, c, d, e, f) (RANGE((a), (c), (e)) && RANGE((b), (d), (f)))
#define chmin(a, b) a = min(a, (b))
#define chmax(a, b) a = max(a, (b))
#define fcout cout << fixed << setprecision(15)
#define YES(f) cout << ((f) ? YES_STR : NO_STR) << endl;

#ifdef LOCAL_DEBUG_OPTION
namespace debug_print_n {
struct DebugPrint {
  template <class T, class U = remove_const_t<remove_reference_t<T>>>
  static enable_if_t<is_integral<U>::value && !is_same<U, bool>::value &&
                     !is_same<U, char>::value>
  DUMP_SUB_FUNCTION(T x) {
    cerr << x;
  }
  template <class T, class U = remove_const_t<remove_reference_t<T>>>
  static enable_if_t<is_same<U, bool>::value> DUMP_SUB_FUNCTION(T x) {
    if (x)
      cerr << "True";
    else
      cerr << "False";
  }
  template <class T, class U = remove_const_t<remove_reference_t<T>>>
  static enable_if_t<is_same<U, char>::value> DUMP_SUB_FUNCTION(T x) {
    cerr << '\\'' << x << '\\'';
  }
  template <class T, class U = remove_const_t<remove_reference_t<T>>>
  static enable_if_t<is_same<U, string>::value> DUMP_SUB_FUNCTION(T x) {
    cerr << '\\"' << x << '\\"';
  }
  template <class T>
  static enable_if_t<is_same<T, const char *>::value> DUMP_SUB_FUNCTION(T x) {
    cerr << string(x);
  }
  template <class T> static enable_if_t<true> DUMP_SUB_FUNCTION(vector<T> x) {
    cerr << '{';
    for (size_t i = 0; i < x.size(); i++) {
      if (i)
        cerr << ", ";
      DUMP_SUB_FUNCTION(x[i]);
    }
    cerr << '}';
  }
  template <class T, size_t N>
  static enable_if_t<true> DUMP_SUB_FUNCTION(array<T, N> x) {
    cerr << '{';
    for (size_t i = 0; i < x.size(); i++) {
      if (i)
        cerr << ", ";
      DUMP_SUB_FUNCTION(x[i]);
    }
    cerr << '}';
  }
  template <class T> static enable_if_t<true> DUMP_SUB_FUNCTION(set<T> x) {
    cerr << '[';
    size_t i = 0;
    for (auto itr = x.begin(); itr != x.end(); itr++, i++) {
      if (i)
        cerr << ", ";
      DUMP_SUB_FUNCTION(*itr);
    }
    cerr << ']';
  }
  template <class T, class U>
  static enable_if_t<true> DUMP_SUB_FUNCTION(map<T, U> x) {
    cerr << '[';
    size_t i = 0;
    for (auto itr = x.begin(); itr != x.end(); itr++, i++) {
      if (i)
        cerr << ", ";
      DUMP_SUB_FUNCTION(itr->first);
      cerr << " : ";
      DUMP_SUB_FUNCTION(itr->second);
    }
    cerr << ']';
  }
  template <class T, class U = remove_const_t<remove_reference_t<T>>>
  static enable_if_t<is_floating_point<U>::value> DUMP_SUB_FUNCTION(T x) {
    cerr << fixed << setprecision(5) << x;
  }
  template <class T, class U>
  static enable_if_t<true> DUMP_SUB_FUNCTION(pair<T, U> p) {
    cerr << '(';
    DUMP_SUB_FUNCTION(p.first);
    cerr << ", ";
    DUMP_SUB_FUNCTION(p.second);
    cerr << ')';
  }
  template <int num = 0, class... Args>
  static enable_if_t<num == sizeof...(Args)>
  DUMP_SUB_FUNCTION(tuple<Args...> t) {
    if (num)
      cerr << ')';
  }
  template <int num = 0, class... Args>
      static enable_if_t <
      num<sizeof...(Args)> DUMP_SUB_FUNCTION(tuple<Args...> t) {
    if (num == 0)
      cerr << '(';
    DUMP_SUB_FUNCTION(get<num>(t));
    if (num + 1 < sizeof...(Args))
      cerr << ", ";
    DUMP_SUB_FUNCTION<num + 1>(t);
  }
  template <long unsigned N>
  static enable_if_t<true> DUMP_SUB_FUNCTION(bitset<N> x) {
    cerr << x;
  }
};
void dump() { cerr << endl; }
template <class Head, class... Tail> void dump(Head &&head, Tail &&...tail) {
  DebugPrint::DUMP_SUB_FUNCTION(head);
  if (sizeof...(Tail) != 0) {
    cerr << ' ';
  }
  dump(forward<Tail>(tail)...);
}
} // namespace debug_print_n
using debug_print_n::dump;
#else
template <class... Args> void dump(Args &&...args) {}
#endif

namespace bit {
using u32 = uint_fast32_t;
using u64 = unsigned long long;
template <class T> constexpr T set(T bin, u32 pos) {
  return bin | (1ull << pos);
}
template <class T> constexpr T unset(T bin, u32 pos) {
  return bin & ~(1ull << pos);
}
template <class T> constexpr T get(T bin, u32 pos) {
  return bin & (1ull << pos);
}
template <class T> constexpr bool check(T bin, u32 pos) {
  return get(bin, pos);
}
constexpr u32 popcount(u64 bin) { return __builtin_popcountll(bin); }
} // namespace bit

signed main() {
  int N;
  cin >> N;
  int N3 = 1;
  rep(i, N) N3 *= 3;
  vector<int> res(N + 1, 4e18);
  vector<int> X(N), Y(N), P(N);
  rep(i, N) { cin >> X[i] >> Y[i] >> P[i]; }
  auto f = [&](const vector<int> &A, vector<vector<int>> &res) {
    rep(i, 1 << N) {
      vector<int> a{0};
      rep(j, N) {
        if (bit::check(i, j))
          a.push_back(A[j]);
      }
      rep(j, N) {
        int mi = 1e9;
        for (auto x : a) {
          chmin(mi, abs(x - A[j]));
        }
        chmin(res[i][j], mi);
      }
    }
  };
  vector<vector<int>> XR(1 << N, vector<int>(N, 1e9));
  vector<vector<int>> YR(1 << N, vector<int>(N, 1e9));
  f(X, XR);
  f(Y, YR);
  rep(x, 1 << N) {
    int Y = ((1 << N) - 1) ^ x;
    for (int y = Y;; y = (y - 1) & Y) {
      int cnt = bit::popcount(x + y);
      int r = 0;
      rep(i, N) { r += min(XR[x][i], YR[y][i]) * P[i]; }
      chmin(res[cnt], r);
      if (!y)
        break;
    }
  }
  rep(i, N + 1) { cout << res[i] << endl; }
  return 0;
}


Error: TLE

Fixed submission:

#include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string>
#include <vector>

using namespace std;

using ll = long long;
#define int ll

// [a -> b-1]
#define reps(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
// [0 -> a-1]
#define rep(i, a) reps(i, 0, (a))
// [a-1 -> b]
#define rreps(i, a, b) for (int i = (int)((a)-1); i >= (int)(b); i--)
// [a-1 -> 0]
#define rrep(i, a) rreps(i, a, 0)
#define all(v) (v).begin(), (v).end()
// next_permutation(all(v))
#define PERM(v) next_permutation(all(v))
/*sort(all(v));
 * (v).erase(unique(all(v)), v.end())*/
#define UNIQUE(v)                                                              \\
  sort(all(v));                                                                \\
  (v).erase(unique(all(v)), v.end())
// b is [a, c)
#define RANGE(a, b, c) ((a) <= (b) && (b) < (c))
// c is [a, e) && d is [b, f)
#define RANGE2D(a, b, c, d, e, f) (RANGE((a), (c), (e)) && RANGE((b), (d), (f)))
#define chmin(a, b) a = min(a, (b))
#define chmax(a, b) a = max(a, (b))
#define fcout cout << fixed << setprecision(15)
#define YES(f) cout << ((f) ? YES_STR : NO_STR) << endl;

#ifdef LOCAL_DEBUG_OPTION
namespace debug_print_n {
struct DebugPrint {
  template <class T, class U = remove_const_t<remove_reference_t<T>>>
  static enable_if_t<is_integral<U>::value && !is_same<U, bool>::value &&
                     !is_same<U, char>::value>
  DUMP_SUB_FUNCTION(T x) {
    cerr << x;
  }
  template <class T, class U = remove_const_t<remove_reference_t<T>>>
  static enable_if_t<is_same<U, bool>::value> DUMP_SUB_FUNCTION(T x) {
    if (x)
      cerr << "True";
    else
      cerr << "False";
  }
  template <class T, class U = remove_const_t<remove_reference_t<T>>>
  static enable_if_t<is_same<U, char>::value> DUMP_SUB_FUNCTION(T x) {
    cerr << '\\'' << x << '\\'';
  }
  template <class T, class U = remove_const_t<remove_reference_t<T>>>
  static enable_if_t<is_same<U, string>::value> DUMP_SUB_FUNCTION(T x) {
    cerr << '\\"' << x << '\\"';
  }
  template <class T>
  static enable_if_t<is_same<T, const char *>::value> DUMP_SUB_FUNCTION(T x) {
    cerr << string(x);
  }
  template <class T> static enable_if_t<true> DUMP_SUB_FUNCTION(vector<T> x) {
    cerr << '{';
    for (size_t i = 0; i < x.size(); i++) {
      if (i)
        cerr << ", ";
      DUMP_SUB_FUNCTION(x[i]);
    }
    cerr << '}';
  }
  template <class T, size_t N>
  static enable_if_t<true> DUMP_SUB_FUNCTION(array<T, N> x) {
    cerr << '{';
    for (size_t i = 0; i < x.size(); i++) {
      if (i)
        cerr << ", ";
      DUMP_SUB_FUNCTION(x[i]);
    }
    cerr << '}';
  }
  template <class T> static enable_if_t<true> DUMP_SUB_FUNCTION(set<T> x) {
    cerr << '[';
    size_t i = 0;
    for (auto itr = x.begin(); itr != x.end(); itr++, i++) {
      if (i)
        cerr << ", ";
      DUMP_SUB_FUNCTION(*itr);
    }
    cerr << ']';
  }
  template <class T, class U>
  static enable_if_t<true> DUMP_SUB_FUNCTION(map<T, U> x) {
    cerr << '[';
    size_t i = 0;
    for (auto itr = x.begin(); itr != x.end(); itr++, i++) {
      if (i)
        cerr << ", ";
      DUMP_SUB_FUNCTION(itr->first);
      cerr << " : ";
      DUMP_SUB_FUNCTION(itr->second);
    }
    cerr << ']';
  }
  template <class T, class U = remove_const_t<remove_reference_t<T>>>
  static enable_if_t<is_floating_point<U>::value> DUMP_SUB_FUNCTION(T x) {
    cerr << fixed << setprecision(5) << x;
  }
  template <class T, class U>
  static enable_if_t<true> DUMP_SUB_FUNCTION(pair<T, U> p) {
    cerr << '(';
    DUMP_SUB_FUNCTION(p.first);
    cerr << ", ";
    DUMP_SUB_FUNCTION(p.second);
    cerr << ')';
  }
  template <int num = 0, class... Args>
  static enable_if_t<num == sizeof...(Args)>
  DUMP_SUB_FUNCTION(tuple<Args...> t) {
    if (num)
      cerr << ')';
  }
  template <int num = 0, class... Args>
      static enable_if_t <
      num<sizeof...(Args)> DUMP_SUB_FUNCTION(tuple<Args...> t) {
    if (num == 0)
      cerr << '(';
    DUMP_SUB_FUNCTION(get<num>(t));
    if (num + 1 < sizeof...(Args))
      cerr << ", ";
    DUMP_SUB_FUNCTION<num + 1>(t);
  }
  template <long unsigned N>
  static enable_if_t<true> DUMP_SUB_FUNCTION(bitset<N> x) {
    cerr << x;
  }
};
void dump() { cerr << endl; }
template <class Head, class... Tail> void dump(Head &&head, Tail &&...tail) {
  DebugPrint::DUMP_SUB_FUNCTION(head);
  if (sizeof...(Tail) != 0) {
    cerr << ' ';
  }
  dump(forward<Tail>(tail)...);
}
} // namespace debug_print_n
using debug_print_n::dump;
#else
template <class... Args> void dump(Args &&...args) {}
#endif

namespace bit {
using u32 = uint_fast32_t;
using u64 = unsigned long long;
template <class T> constexpr T set(T bin, u32 pos) {
  return bin | (1ull << pos);
}
template <class T> constexpr T unset(T bin, u32 pos) {
  return bin & ~(1ull << pos);
}
template <class T> constexpr T get(T bin, u32 pos) {
  return bin & (1ull << pos);
}
template <class T> constexpr bool check(T bin, u32 pos) {
  return get(bin, pos);
}
constexpr u32 popcount(u64 bin) { return __builtin_popcountll(bin); }
} // namespace bit

signed main() {
  int N;
  cin >> N;
  int N3 = 1;
  rep(i, N) N3 *= 3;
  vector<int> res(N + 1, 4e18);
  vector<int> X(N), Y(N), P(N);
  rep(i, N) cin >> X[i] >> Y[i] >> P[i];
  rep(i, N3) {
    vector<int> R{(int)-1e9, 0, (int)1e9}, C{(int)-1e9, 0, (int)1e9};
    vector<int> l;
    int t = i;
    int cnt = N;
    rep(j, N) {
      if (t % 3 == 0)
        R.push_back(Y[j]);
      else if (t % 3 == 1)
        C.push_back(X[j]);
      else
        cnt--, l.push_back(j);
      t /= 3;
    }
    sort(all(R));
    sort(all(C));
    int r = 0;
    for (auto j : l) {
      auto f = [&](auto itr, int x) { return abs(*itr - x) * P[j]; };
      auto a = upper_bound(all(R), Y[j]);
      auto b = prev(a);
      auto c = upper_bound(all(C), X[j]);
      auto d = prev(c);
      r += min({f(a, Y[j]), f(b, Y[j]), f(c, X[j]), f(d, X[j])});
    }
    chmin(res[cnt], r);
  }
  rep(i, N + 1) { cout << res[i] << endl; }
  return 0;
}