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

#include <algorithm> // other
#include <bitset>
#include <cassert> // c
#include <complex>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream> // io
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <valarray>
#include <vector> // container

using namespace std;
typedef long long ll;

#define ALL(c) (c).begin(), (c).end()
#define FOR(i, l, r) for (int i = (int)l; i < (int)r; ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORr(i, l, r) for (int i = (int)r - 1; i >= (int)l; --i)
#define REPr(i, n) FORr(i, 0, n)
#define EACH(i, c)                                                             \\
  for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define IN(l, v, r) ((l) <= (v) && (v) < (r))
#define UNIQUE(v) v.erase(unique(ALL(v)), v.end())
// debug
#define DUMP(x) cerr << #x << " = " << (x)
#define LINE() cerr << " (L" << __LINE__ << ")"

template <typename T, typename U> T pmod(T x, U M) { return (x % M + M) % M; }

// must template
typedef double D;
const D INF = 1e12, EPS = 1e-8;

typedef complex<D> P;
#define X real()
#define Y imag()
istream &operator>>(istream &is, P &p) {
  D x, y;
  is >> x >> y;
  p = P(x, y);
  return is;
}

int sig(D a, D b = 0) { return a < b - EPS ? -1 : a > b + EPS ? 1 : 0; }
template <typename T> bool eq(const T &a, const T &b) {
  return sig(abs(a - b)) == 0;
}
bool compX(const P &a, const P &b) {
  return !eq(a.X, b.X) ? sig(a.X, b.X) < 0 : sig(a.Y, b.Y) < 0;
}
namespace std {
bool operator<(const P &a, const P &b) { return compX(a, b); }
bool operator==(const P &a, const P &b) { return eq(a, b); }
}; // namespace std
typedef valarray<D> Pn;
istream &operator>>(istream &is, Pn &p) {
  D x, y, z;
  is >> x >> y >> z;
  p.resize(3);
  p[0] = x;
  p[1] = y;
  p[2] = z;
  return is;
}

const int dim = 3;
D dot(const Pn &a, const Pn &b) { return (a * b).sum(); }
Pn cross(const Pn &a, const Pn &b) {
  return a.cshift(+1) * b.cshift(-1) - a.cshift(-1) * b.cshift(+1);
}

D len(const Pn &a) { return sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]); }

struct C {
  P o;
  D r;
  C(const P &o, D r) : o(o), r(r) {}
};
struct L : public vector<Pn> {
  Pn vec() const { return this->at(1) - this->at(0); }
  L(const Pn &a, const Pn &b) {
    push_back(a);
    push_back(b);
  }
  L() {
    push_back(Pn());
    push_back(Pn());
  }
};
bool isIntersectSP(const L &s, const Pn &p) {
  return sig(len(s[0] - p) + len(s[1] - p), len(s[1] - s[0])) <=
         0; // triangle inequality
};
Pn projection(const L &l, const Pn &p) {
  D t = dot(p - l[0], l.vec()) / (len(l.vec()) * len(l.vec()));
  Pn res = l[0];
  Pn v = l.vec();
  REP(i, 3) res[i] += t * v[i];
  return res;
  // return l[0] + t * l.vec();
}
D distanceSP(const L &s, const Pn &p) {
  const Pn r = projection(s, p);
  if (isIntersectSP(s, r))
    return len(r - p);
  return min(len(s[0] - p), len(s[1] - p));
}

// fast zeta transform g(S):=Σ{T ⊆ S} f(T)
template <typename T> vector<T> fzt(int n, vector<T> f) {
  REP(v, n) REP(bit, 1 << n) if (bit & 1 << v) f[bit] += f[bit ^ 1 << v];
  return f;
}

template <typename T> ostream &operator<<(ostream &os, const vector<T> &as) {
  REP(i, as.size()) {
    if (i != 0)
      os << " ";
    os << as[i];
  }
  return os;
}

int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  // ofstream cout( "out" );
  cerr << fixed << setprecision(20);
  cout << fixed << setprecision(20);

  while (true) {
    int N, M, R;
    cin >> N >> M >> R;
    if (N == 0)
      break;

    vector<Pn> sos;
    vector<D> rs(N);
    REP(i, N) {
      Pn p;
      cin >> p;
      sos.push_back(p);
      cin >> rs[i];
    }
    vector<Pn> ts;
    vector<D> bs(M);
    REP(i, M) {
      Pn p;
      cin >> p;
      ts.push_back(p);
      cin >> bs[i];
    }
    Pn e;
    cin >> e;
    vector<L> ls(M);
    REP(i, M) ls[i] = L(ts[i], e);

    // 幾何
    vector<vector<bool>> isIntersect(M, vector<bool>(N));
    REP(i, M) REP(j, N) {
      if (sig(distanceSP(ls[i], sos[j]), rs[j]) <= 0) {
        if (!(sig(len(ls[i][0] - sos[j]), rs[j]) <= 0 &&
              sig(len(ls[i][1] - sos[j]), rs[j]) <= 0))
          isIntersect[i][j] = true;
      }
    }
    vector<D> p(M);
    REP(i, M) p[i] = bs[i] / (len(ts[i] - e) * len(ts[i] - e));

    //
    D res = 0;
    vector<bool> isI(N);
    REP(bit, 1 << M) {
      fill(ALL(isI), false);
      REP(i, M)
      if ((bit >> i) & 1) REP(j, N) if (isIntersect[i][j]) isI[j] = true;
      int c = 0;
      REP(j, N) c += isI[j];
      if (c > R)
        continue;
      D v = 0;
      REP(i, M) if ((bit >> i) & 1) v += p[i];
      res = max(res, v);
    }

    // cout << res <<endl;
    printf("%.20lf\\n", res);
    // cout << res <<endl;
  }
}

Error: TLE

Fixed submission:

#include <algorithm> // other
#include <bitset>
#include <cassert> // c
#include <complex>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream> // io
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <valarray>
#include <vector> // container

using namespace std;
typedef long long ll;

#define ALL(c) (c).begin(), (c).end()
#define FOR(i, l, r) for (int i = (int)l; i < (int)r; ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORr(i, l, r) for (int i = (int)r - 1; i >= (int)l; --i)
#define REPr(i, n) FORr(i, 0, n)
#define EACH(i, c)                                                             \\
  for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define IN(l, v, r) ((l) <= (v) && (v) < (r))
#define UNIQUE(v) v.erase(unique(ALL(v)), v.end())
// debug
#define DUMP(x) cerr << #x << " = " << (x)
#define LINE() cerr << " (L" << __LINE__ << ")"

template <typename T, typename U> T pmod(T x, U M) { return (x % M + M) % M; }

// must template
typedef double D;
const D INF = 1e12, EPS = 1e-8;

typedef complex<D> P;
#define X real()
#define Y imag()
istream &operator>>(istream &is, P &p) {
  D x, y;
  is >> x >> y;
  p = P(x, y);
  return is;
}

int sig(D a, D b = 0) { return a < b - EPS ? -1 : a > b + EPS ? 1 : 0; }
template <typename T> bool eq(const T &a, const T &b) {
  return sig(abs(a - b)) == 0;
}
bool compX(const P &a, const P &b) {
  return !eq(a.X, b.X) ? sig(a.X, b.X) < 0 : sig(a.Y, b.Y) < 0;
}
namespace std {
bool operator<(const P &a, const P &b) { return compX(a, b); }
bool operator==(const P &a, const P &b) { return eq(a, b); }
}; // namespace std
typedef valarray<D> Pn;
istream &operator>>(istream &is, Pn &p) {
  D x, y, z;
  is >> x >> y >> z;
  p.resize(3);
  p[0] = x;
  p[1] = y;
  p[2] = z;
  return is;
}

const int dim = 3;
D dot(const Pn &a, const Pn &b) { return (a * b).sum(); }
Pn cross(const Pn &a, const Pn &b) {
  return a.cshift(+1) * b.cshift(-1) - a.cshift(-1) * b.cshift(+1);
}

D len(const Pn &a) { return sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]); }

struct C {
  P o;
  D r;
  C(const P &o, D r) : o(o), r(r) {}
};
struct L : public vector<Pn> {
  Pn vec() const { return this->at(1) - this->at(0); }
  L(const Pn &a, const Pn &b) {
    push_back(a);
    push_back(b);
  }
  L() {
    push_back(Pn());
    push_back(Pn());
  }
};
bool isIntersectSP(const L &s, const Pn &p) {
  return sig(len(s[0] - p) + len(s[1] - p), len(s[1] - s[0])) <=
         0; // triangle inequality
};
Pn projection(const L &l, const Pn &p) {
  D t = dot(p - l[0], l.vec()) / (len(l.vec()) * len(l.vec()));
  Pn res = l[0];
  Pn v = l.vec();
  REP(i, 3) res[i] += t * v[i];
  return res;
  // return l[0] + t * l.vec();
}
D distanceSP(const L &s, const Pn &p) {
  const Pn r = projection(s, p);
  if (isIntersectSP(s, r))
    return len(r - p);
  return min(len(s[0] - p), len(s[1] - p));
}

// fast zeta transform g(S):=Σ{T ⊆ S} f(T)
template <typename T> vector<T> fzt(int n, vector<T> f) {
  REP(v, n) REP(bit, 1 << n) if (bit & 1 << v) f[bit] += f[bit ^ 1 << v];
  return f;
}

template <typename T> ostream &operator<<(ostream &os, const vector<T> &as) {
  REP(i, as.size()) {
    if (i != 0)
      os << " ";
    os << as[i];
  }
  return os;
}

int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  // ofstream cout( "out" );
  cerr << fixed << setprecision(20);
  cout << fixed << setprecision(20);

  while (true) {
    int N, M, R;
    cin >> N >> M >> R;
    if (N == 0)
      break;

    vector<Pn> sos;
    vector<D> rs(N);
    REP(i, N) {
      Pn p;
      cin >> p;
      sos.push_back(p);
      cin >> rs[i];
    }
    vector<Pn> ts;
    vector<D> bs(M);
    REP(i, M) {
      Pn p;
      cin >> p;
      ts.push_back(p);
      cin >> bs[i];
    }
    Pn e;
    cin >> e;
    vector<L> ls(M);
    REP(i, M) ls[i] = L(ts[i], e);

    // 幾何
    vector<vector<bool>> isIntersect(M, vector<bool>(N));
    REP(i, M) REP(j, N) {
      if (sig(distanceSP(ls[i], sos[j]), rs[j]) <= 0) {
        if (!(sig(len(ls[i][0] - sos[j]), rs[j]) <= 0 &&
              sig(len(ls[i][1] - sos[j]), rs[j]) <= 0))
          isIntersect[i][j] = true;
      }
    }
    vector<D> p(M);
    REP(i, M) p[i] = bs[i] / (len(ts[i] - e) * len(ts[i] - e));

    //
    D res = 0;
    vector<bool> isI(N);
    REP(bit, 1 << M) {
      fill(ALL(isI), false);
      int c = 0;
      REP(i, M)
      if ((bit >> i) & 1) REP(j, N) if (isIntersect[i][j] && !isI[j]) {
        isI[j] = true;
        c++;
      }
      if (c > R)
        continue;
      D v = 0;
      REP(i, M) if ((bit >> i) & 1) v += p[i];
      res = max(res, v);
    }

    // cout << res <<endl;
    printf("%.20lf\\n", res);
    // cout << res <<endl;
  }
}