2017-2018 ACM-ICPC, NEERC, Moscow Subregional Contest J. Judging the Trick

J. Judging the Trick

time limit per test

2.0 s

memory limit per test

512 MB

input

standard input

output

standard output

Tricky Ricky is a world-famous magician. He even claims that he can overcome the laws of physics and geometry.

In his latest trick he covers a w × h rectangle with n triangles fully contained within the rectangle. Sounds easy? But what would you say if he told you that the total area of those triangles is smaller than w·h?

You are of that kind of people that are not very fun at parties and magic shows, so you want to prove him that this is impossible. Given a description of n triangles, find any point of the rectangle which does not belong to any triangle interior or border.

Input

The first line of the input contains three integers n, w and h (1 ≤ n ≤ 100 000, 1 ≤ w, h ≤ 10 000) — the number of triangles and the dimensions of the rectangle.

The following n lines contain descriptions of triangle vertices. Each line contains six integers xi, 1, yi, 1, xi, 2, yi, 2, xi, 3 and yi, 3(0 ≤ xi, j ≤ w, 0 ≤ yi, j ≤ h). It is guaranteed that all given triangles are non-degenerate, and the total area of triangles is smaller than w·h.

Output

Print two real numbers x and y (0 ≤ x ≤ w, 0 ≤ y ≤ h) defining the coordinates of a point that lies strictly outside of all of the triangles. The numbers should be printed as decimal fractions with at most 9 digits after decimal point. Note that usage of exponential format is not allowed. Your answer will be considered correct if the given point does not belong to any triangle interior or border. Please, note that your answer will be verified with no absolute or relative tolerance.

It is guaranteed (by Euclid and some other guys) that such point always exists.

Example

input

Copy

5 4 3
0 0 3 0 0 2
3 3 0 1 0 3
1 1 3 1 2 3
3 0 4 0 4 3
4 3 3 2 4 1

output

Copy

1.1 1.6

Note

An illustration for the sample is given below.

思路：题目保证了三角形面积和不超过矩形面积。四分矩形，必有一子矩形中面积超过该矩形与所有三角形面积交的和，求三角形和矩形面积交用的半平面交板子。四分一定次数后在子矩形内随机取点判断是否合法。

程序中的trick：四个子矩形中随机选顺序判断，若子矩形面积差值超过大矩形面积差值四分之一，则进入该子矩形；

　　　　　　   四分过程中及时排除掉与当前矩形相交面积为0的三角形。

　　　　　　　随机选点之前也排除掉不可能在其上的三角形。

　　　　　　　不加这几个优化会T，调了92发才过，可能我的半平面交比较挫吧。

#include <iostream>
#include <fstream>
#include <sstream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <iomanip>
#include <cctype>
#include <cassert>
#include <bitset>
#include <ctime>

using namespace std;

#define pau system("pause")
#define ll long long
#define pii pair<int, int>
#define pb push_back
#define pli pair<ll, int>
#define pil pair<int, ll>
#define clr(a, x) memset(a, x, sizeof(a))

const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double EPS = 1e-14;

/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define TREE tree<pli, null_type, greater<pli>, rb_tree_tag, tree_order_statistics_node_update>
TREE T;
*/


#define Double double

int n;
Double w, h;
struct Point {
    Double x, y;
    Point () {}
    Point(Double x, Double y) : x(x), y(y) {}
    Point operator - (const Point &p) const {
        return Point(x - p.x, y - p.y);
    }
    Double operator ^ (const Point &p) const {
        return x * p.y - y * p.x;
    }
    void input() {
        double tx, ty;
        scanf("%lf%lf", &tx, &ty);
        x = tx, y = ty;
    }
};
struct Line {
    Point s, e;
    double k;
    Line () {}
    Line (Point _s, Point _e) {
        s = _s, e = _e;
        k = atan2(e.y - s.y, e.x - s.x);
    }
    Point operator & (const Line &b) const {
        Point res = s;
        double t = ((s - b.s) ^ (b.s - b.e)) / ((s - e) ^ (b.s - b.e));
        res.x += (e.x - s.x) * t;
        res.y += (e.y - s.y) * t;
        return res;
    }
};

//左侧有效
bool HPIcmp(Line a, Line b) {
    if (fabs(a.k - b.k) > EPS) return a.k < b.k;
    return ((a.s - b.s) ^ (b.e - b.s)) < 0;
}

bool onRightPL(Point p, Line l) {
    return ((p - l.s) ^ (l.e - l.s)) > EPS;
}

Line Q[22510];

inline void HPI(Line line[], int n, Point res[], int &resn) {
    sort(line, line + n, HPIcmp);
    int tot = 0;
    for (int i = 1; i < n; ++i) {
        if (fabs(line[i].k - line[i - 1].k) > EPS) {
            line[++tot] = line[i];
        }
    }
    int head = 0, tail = 1;
    Q[0] = line[0]; Q[1] = line[1];
    for (int i = 2; i <= tot; ++i) {
        if (fabs((Q[tail].e - Q[tail].s) ^ (Q[tail - 1].e - Q[tail - 1].s)) < EPS || 
            fabs((Q[head].e - Q[head].s) ^ (Q[head + 1].e - Q[head + 1].s)) < EPS)
            return;
        while (head < tail && onRightPL(Q[tail] & Q[tail - 1], line[i])) --tail;
        while (head < tail && onRightPL(Q[head] & Q[head + 1], line[i])) ++head;
        Q[++tail] = line[i];
    }
    while (head < tail && onRightPL(Q[tail] & Q[tail - 1], Q[head])) --tail;
    while (head < tail && onRightPL(Q[head] & Q[head + 1], Q[tail])) ++head;
    if (tail <= head + 1) return;
    for (int i = head; i < tail; ++i) {
        res[resn++] = Q[i] & Q[i + 1];
    }
    if (head < tail - 1) res[resn++] = Q[tail] & Q[head];
}
inline double cal_S(Point p[], int resn) {
    double ans = 0;
    for (int i = 0; i < resn; ++i) {
        ans += p[i] ^ p[(i + 1) % resn];
    }
    return 0.5 * fabs(ans);
}
struct Tran {
    Point p[3];
    void input() {
        for (int i = 0; i < 3; ++i) {
            p[i].input();
        }
    }
    void modify() {
        double wx = (p[0].x + p[1].x + p[2].x) / 3;
        double wy = (p[0].y + p[1].y + p[2].y) / 3;
        if (onRightPL(Point(wx, wy), Line(p[0], p[1]))) {
            swap(p[0], p[2]);
        }
    }
    inline double S(double x1, double x2, double y1, double y2) {
        Line l[11];
        for (int i = 0; i < 3; ++i) {
            l[i] = Line(p[i], p[(i + 1) % 3]);
        }
        l[3] = Line(Point(x2, 0), Point(x2, 1));
        l[4] = Line(Point(x1, 1), Point(x1, 0));
        l[5] = Line(Point(0, y1), Point(1, y1));
        l[6] = Line(Point(1, y2), Point(0, y2));
        Point res[17]; int resn = 0;
        HPI(l, 7, res, resn);
        return cal_S(res, resn);
    }
} t[100015];
bool inTran(Point p, Tran t) {
    Double res1 = (p - t.p[0]) ^ (p - t.p[1]);
    Double res2 = (p - t.p[1]) ^ (p - t.p[2]);
    Double res3 = (p - t.p[2]) ^ (p - t.p[0]);
    if (fabs(res1) < EPS || fabs(res2) < EPS || fabs(res3) < EPS) return true;
    return res1 < -EPS && res2 < -EPS && res3 < -EPS || 
        res1 > EPS && res2 > EPS && res3 > EPS;
}
bool vis[100015], tvis[100015];
bool ok(Point p) {
    for (int i = 1; i <= n; ++i) {
        if (vis[i]) continue;
        if (inTran(p, t[i])) return false;
    }
    return true;
}
double ok(double x1, double x2, double y1, double y2) {
    double s = 0;
    for (int i = 1; i <= n; ++i) {
        if (vis[i]) continue;
        double x = t[i].S(x1, x2, y1, y2);
        if (x < EPS) tvis[i] = 1;
        s += x;
    }
    return (y2 - y1) * (x2 - x1) - s;
}
const int dir[4][2] = {
    1, 1, 0, 1, 
    1, 0, 0, 0
};
bool online(Point p1, Point p2, Point p3) {
    double res = (p2 - p1) ^ (p3 - p1);
    if (fabs(res) > EPS) return false;
    double x1 = min(p2.x, p3.x), x2 = max(p2.x, p3.x);
    double y1 = min(p2.y, p3.y), y2 = max(p2.y, p3.y);
    return x1 <= p2.x && p2.x <= x2 && y1 <= p2.y && p2.y <= y2;
}
bool ok(int id, double x1, double x2, double y1, double y2) {
    if (t[id].S(x1, x2, y1, y2) > EPS) return false;
    for (int i = 0; i < 3; ++i) {
        if (online(t[id].p[i], Point(x1, y1), Point(x1, y2))) return false;
        if (online(t[id].p[i], Point(x1, y1), Point(x2, y1))) return false;
        if (online(t[id].p[i], Point(x2, y2), Point(x1, y2))) return false;
        if (online(t[id].p[i], Point(x2, y2), Point(x2, y1))) return false;
        if (online(Point(x1, y1), t[id].p[i], t[id].p[(i + 1) % 3])) return false;
        if (online(Point(x1, y2), t[id].p[i], t[id].p[(i + 1) % 3])) return false;
        if (online(Point(x2, y1), t[id].p[i], t[id].p[(i + 1) % 3])) return false;
        if (online(Point(x2, y2), t[id].p[i], t[id].p[(i + 1) % 3])) return false;
    }
    return true;
}
int main() {
    clock_t start = clock();
    srand((int)time(NULL));
    scanf("%d", &n);
    cin >> w >> h;
    for (int i = 1; i <= n; ++i) {
        t[i].input();
        t[i].modify();
    }    
    Double sx = 0, sy = 0, lx = w * 0.5, ly = h * 0.5;
    double deltas = w * h;
    for (int i = 1; i <= n; ++i) {
        deltas += ((t[i].p[2] - t[i].p[0]) ^ (t[i].p[1] - t[i].p[0])) / 2;
    }
    if (99978 == n) {
        //printf("%.12f
", deltas);
    }
    for (int rep = 1; rep <= 20; ++rep) {
        double tmp[4];    
        int id;
        int dd[4] = {0, 1, 2, 3};
        random_shuffle(dd, dd + 4);
        for (int i = 3; ~i; --i) {
            double tx = sx + lx * dir[dd[i]][0];
            double ty = sy + ly * dir[dd[i]][1];
            for (int i = 1; i <= n; ++i) tvis[i] = 0;
            tmp[i] = ok(tx, tx + lx, ty, ty + ly);
            if (tmp[i] >= 0.25 * deltas - EPS) {
                id = dd[i];
                for (int i = 1; i <= n; ++i) {
                    vis[i] |= tvis[i];
                }
                break;
            }
        }
        //int id = rand() % 4;
        for (int i = 0; i < 4; ++i) {
            //if (tmp[i] > tmp[id]) id = i;
        }
        sx = sx + dir[id][0] * lx;
        sy = sy + dir[id][1] * ly;
        lx *= 0.5, ly *= 0.5;
        deltas *= 0.25;
    }
    clock_t end = clock();
    if (99978 == n) {
        //return !printf("%.6f
", (double)(end - start) / CLOCKS_PER_SEC);
    }
    for (int i = 1; i <= n; ++i) {
        vis[i] = ok(i, sx, sx + lx * 2, sy, sy + ly * 2);
    }
    double Lx = lx, Ly = ly;
    for (int rep = 1; rep <= 100000; ++rep) {
        Double x = 1.0 * rand() / RAND_MAX * Lx * 2 + sx;
        Double y = 1.0 * rand() / RAND_MAX * Ly * 2 + sy;
        if (ok(Point(x, y))) {
            return !printf("%.9f %.9f
", (double)x, (double)y);
        }
    }
    printf("%.9f %.9f
", (double)(sx + lx), (double)(sy + ly));
    return 0;
}