Problem p00873 (C++) — buggy submission, verdict: Memory Limit Exceeded

#include <algorithm>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef char ll;
typedef ll li;
typedef pair<int, int> PI;
#define EPS (1e-6)
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP(i, n) rep(i, n)
#define F first
#define S second
#define mp(a, b) make_pair(a, b)
#define pb(a) push_back(a)
#define min3(a, b, c) min((a), min((b), (c)))
#define min4(a, b, c, d) min((a), min3((b), (c), (d)))
#define SZ(a) (int)((a).size())
#define ALL(a) a.begin(), a.end()
#define FLL(a, b) memset((a), b, sizeof(a))
#define CLR(a) memset((a), 0, sizeof(a))
#define FOR(it, a) for (__typeof(a.begin()) it = a.begin(); it != a.end(); ++it)
template <typename T, typename U>
ostream &operator<<(ostream &out, const pair<T, U> &val) {
  return out << "(" << val.F << ", " << val.S << ")";
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &val) {
  out << "{";
  rep(i, SZ(val)) out << (i ? ", " : "") << val[i];
  return out << "}";
}
typedef double FP;
typedef complex<FP> pt;
typedef pt P;
typedef pair<pt, pt> line;
FP dot(P a, P b) { return real(conj(a) * b); }
FP crs(P a, P b) { return imag(conj(a) * b); }
P ortho(P a) { return conj(P(imag(a), real(a))); }
P ortho(line a) { return ortho(a.S - a.F); }
P crspt(P a, P b, P c, P d) {
  b -= a, d -= c;
  return a + b * crs(d, c - a) / crs(d, b);
}
P crspt(line a, line b) { return crspt(a.F, a.S, b.F, b.S); }
bool onl(P a1, P a2, P b) {
  return abs(b - a1) + abs(b - a2) < abs(a1 - a2) + EPS;
}
bool onl(line a, P b) { return onl(a.F, a.S, b); }
bool iscrs(line a, line b) {
  P c = crspt(a, b);
  return onl(a, c) && onl(b, c);
}
void pkuassert(bool t) { t = 1 / t; };
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1};
int dy[] = {1, 0, -1, 0, -1, 1, 1, -1};
enum { TOP, BTM, LFT, RGT, FRT, BCK };
int dxdy2ce[] = {RGT, FRT, LFT, BCK};
template <class T> T shift(T a, int b, int c, int d, int e) {
  __typeof(a[0]) t = a[b];
  a[b] = a[c];
  a[c] = a[d];
  a[d] = a[e];
  a[e] = t;
  return a;
}
template <class T> T rgt(T a) { return shift(a, TOP, LFT, BTM, RGT); }
template <class T> T lft(T a) { return shift(a, TOP, RGT, BTM, LFT); }
template <class T> T frt(T a) { return shift(a, TOP, BCK, BTM, FRT); }
template <class T> T bck(T a) { return shift(a, TOP, FRT, BTM, BCK); }
line mkl(P a, P v) { return line(a, a + v); }
FP lpdist(line a, P b) { return abs(b - crspt(a, mkl(b, ortho(a)))); }
FP spdist(line a, P b) {
  P c(crspt(a, mkl(b, ortho(a))));
  return onl(a, c) ? abs(b - c) : min(abs(a.F - b), abs(a.S - b));
}
FP ssdist(line a, line b) {
  return iscrs(a, b) ? 0.
                     : min4(spdist(a, b.F), spdist(a, b.S), spdist(b, a.F),
                            spdist(b, a.S));
}
namespace std {
bool operator<(const P &a, const P &b) {
  return mp(real(a), imag(a)) < mp(real(b), imag(b));
}
} // namespace std

int n;
bool vis[2500][1 << 10];
int x[10], y[10];
void solve() {
  rep(i, n) cin >> x[i] >> y[i];
  vector<P> pp;
  rep(i, n) pp.pb(P(x[i], y[i]));
  rep(i, n) rep(j, i) rep(k, n) rep(l, k) {
    P c = crspt(line(P(x[i], y[i]), P(x[j], y[j])),
                line(P(x[k], y[k]), P(x[l], y[l])));
    if (abs(crs(P(x[i], y[i]) - P(x[j], y[j]), P(x[k], y[k]) - P(x[l], y[l]))) <
        EPS)
      continue;
    if (onl(line(P(x[i], y[i]), P(x[j], y[j])), c) ||
        onl(line(P(x[k], y[k]), P(x[l], y[l])), c))
      continue;
    pp.pb(c);
  }
  sort(ALL(pp));
  pp.erase(unique(ALL(pp)), pp.end());
  // cout << SZ(pp) << endl;

  priority_queue<pair<pair<int, double>, PI>> q;
  rep(i, n) {
    int id = find(ALL(pp), P(x[i], y[i])) - pp.begin();
    q.push(mp(mp(0, 0.), mp(id, 1 << i)));
  }
  // cout << SZ(pp) << endl;
  int ronriwa[SZ(pp)][SZ(pp)];
  CLR(ronriwa);
  rep(i, SZ(pp)) rep(j, i) {
    rep(k, n) if (onl(line(pp[i], pp[j]), P(x[k], y[k]))) ronriwa[i][j] |= 1
                                                                           << k;
    ronriwa[j][i] = ronriwa[i][j];
  }

  CLR(vis);
  while (!q.empty()) {
    PI cv = q.top().S;
    int ct = -q.top().F.F;
    double cc = -q.top().F.S;
    q.pop();
    if (vis[cv.F][cv.S])
      continue;
    vis[cv.F][cv.S] = true;
    // cout << ' ' << ct << ' ' << cc << ' ' << cv << endl;

    if (cv.S == (1 << n) - 1) {
      printf("%d %.8f\\n", ct, cc);
      return;
    }
    if (__builtin_popcount(cv.S) > 1)
      ++ct;
    if (ct > 4)
      continue;
    rep(i, SZ(pp)) {
      line l(pp[cv.F], pp[i]);
      int nvis = cv.S | ronriwa[cv.F][i];
      // rep(j,n) if(onl(l,P(x[j],y[j]))) nvis|=1<<j;
      if (nvis != cv.S)
        q.push(mp(mp(-ct, -cc - abs(l.F - l.S)), mp(i, nvis)));
    }
  }
}

int main(int argc, char *argv[]) {
  while (cin >> n && n)
    solve();
  return 0;
}

Error: MLE

Fixed submission:

#include <algorithm>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef char ll;
typedef ll li;
typedef pair<int, int> PI;
#define EPS (1e-6)
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP(i, n) rep(i, n)
#define F first
#define S second
#define mp(a, b) make_pair(a, b)
#define pb(a) push_back(a)
#define min3(a, b, c) min((a), min((b), (c)))
#define min4(a, b, c, d) min((a), min3((b), (c), (d)))
#define SZ(a) (int)((a).size())
#define ALL(a) a.begin(), a.end()
#define FLL(a, b) memset((a), b, sizeof(a))
#define CLR(a) memset((a), 0, sizeof(a))
#define FOR(it, a) for (__typeof(a.begin()) it = a.begin(); it != a.end(); ++it)
template <typename T, typename U>
ostream &operator<<(ostream &out, const pair<T, U> &val) {
  return out << "(" << val.F << ", " << val.S << ")";
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &val) {
  out << "{";
  rep(i, SZ(val)) out << (i ? ", " : "") << val[i];
  return out << "}";
}
typedef double FP;
typedef complex<FP> pt;
typedef pt P;
typedef pair<pt, pt> line;
FP dot(P a, P b) { return real(conj(a) * b); }
FP crs(P a, P b) { return imag(conj(a) * b); }
P ortho(P a) { return conj(P(imag(a), real(a))); }
P ortho(line a) { return ortho(a.S - a.F); }
P crspt(P a, P b, P c, P d) {
  b -= a, d -= c;
  return a + b * crs(d, c - a) / crs(d, b);
}
P crspt(line a, line b) { return crspt(a.F, a.S, b.F, b.S); }
bool onl(P a1, P a2, P b) {
  return abs(b - a1) + abs(b - a2) < abs(a1 - a2) + EPS;
}
bool onl(line a, P b) { return onl(a.F, a.S, b); }
bool iscrs(line a, line b) {
  P c = crspt(a, b);
  return onl(a, c) && onl(b, c);
}
void pkuassert(bool t) { t = 1 / t; };
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1};
int dy[] = {1, 0, -1, 0, -1, 1, 1, -1};
enum { TOP, BTM, LFT, RGT, FRT, BCK };
int dxdy2ce[] = {RGT, FRT, LFT, BCK};
template <class T> T shift(T a, int b, int c, int d, int e) {
  __typeof(a[0]) t = a[b];
  a[b] = a[c];
  a[c] = a[d];
  a[d] = a[e];
  a[e] = t;
  return a;
}
template <class T> T rgt(T a) { return shift(a, TOP, LFT, BTM, RGT); }
template <class T> T lft(T a) { return shift(a, TOP, RGT, BTM, LFT); }
template <class T> T frt(T a) { return shift(a, TOP, BCK, BTM, FRT); }
template <class T> T bck(T a) { return shift(a, TOP, FRT, BTM, BCK); }
line mkl(P a, P v) { return line(a, a + v); }
FP lpdist(line a, P b) { return abs(b - crspt(a, mkl(b, ortho(a)))); }
FP spdist(line a, P b) {
  P c(crspt(a, mkl(b, ortho(a))));
  return onl(a, c) ? abs(b - c) : min(abs(a.F - b), abs(a.S - b));
}
FP ssdist(line a, line b) {
  return iscrs(a, b) ? 0.
                     : min4(spdist(a, b.F), spdist(a, b.S), spdist(b, a.F),
                            spdist(b, a.S));
}
namespace std {
bool operator<(const P &a, const P &b) {
  return mp(real(a), imag(a)) < mp(real(b), imag(b));
}
} // namespace std

int n;
bool vis[1300][1 << 10];
int x[10], y[10];
void solve() {
  rep(i, n) cin >> x[i] >> y[i];
  vector<P> pp;
  rep(i, n) pp.pb(P(x[i], y[i]));
  rep(i, n) rep(j, i) rep(k, n) rep(l, k) {
    P c = crspt(line(P(x[i], y[i]), P(x[j], y[j])),
                line(P(x[k], y[k]), P(x[l], y[l])));
    if (abs(crs(P(x[i], y[i]) - P(x[j], y[j]), P(x[k], y[k]) - P(x[l], y[l]))) <
        EPS)
      continue;
    pp.pb(c);
  }
  sort(ALL(pp));
  pp.erase(unique(ALL(pp)), pp.end());
  // cout << SZ(pp) << endl;

  priority_queue<pair<pair<int, double>, PI>> q;
  rep(i, n) {
    int id = find(ALL(pp), P(x[i], y[i])) - pp.begin();
    q.push(mp(mp(0, 0.), mp(id, 1 << i)));
  }
  CLR(vis);
  while (!q.empty()) {
    PI cv = q.top().S;
    int ct = -q.top().F.F;
    double cc = -q.top().F.S;
    q.pop();
    if (vis[cv.F][cv.S])
      continue;
    vis[cv.F][cv.S] = true;
    // cout << ' ' << ct << ' ' << cc << ' ' << cv << endl;

    if (cv.S == (1 << n) - 1) {
      printf("%d %.8f\\n", ct, cc);
      return;
    }
    if (cv.S)
      ++ct;
    if (ct > 5)
      continue;
    rep(i, SZ(pp)) {
      line l(pp[cv.F], pp[i]);
      int nvis = cv.S;
      rep(j, n) if (onl(l, P(x[j], y[j]))) nvis |= 1 << j;
      q.push(mp(mp(-ct, -cc - abs(l.F - l.S)), mp(i, nvis)));
    }
  }
}

int main(int argc, char *argv[]) {
  while (cin >> n && n)
    solve();
  return 0;
}