uva 11595 - Crossing Streets EXTREME(切割多边形)

题目链接:uva 11595 - Crossing Streets EXTREME

对初始平面进行切割,得到所有平面,然后处理出所有边,有公共边的两个平面之间可以到达,对于城市的权值可以加到点上,进出各加一次即可。

#include <cstdio>
#include <cstring>
#include <cmath>
#include <queue>
#include <vector>
#include <complex>
#include <algorithm>

using namespace std;
typedef pair<int,int> pii;
const double pi = 4 * atan(1);
const double eps = 1e-3;

inline int dcmp (double x) { if (fabs(x) < eps) return 0; else return x < 0 ? -1 : 1; }
inline double getDistance (double x, double y) { return sqrt(x * x + y * y); }
inline double torad(double deg) { return deg / 180 * pi; }

struct Point {
	double x, y;
	Point (double x = 0, double y = 0): x(x), y(y) {}
	void read () { scanf("%lf%lf", &x, &y); }
	void write () { printf("%lf %lf", x, y); }

	bool operator == (const Point& u) const { return dcmp(x - u.x) == 0 && dcmp(y - u.y) == 0; }
	bool operator != (const Point& u) const { return !(*this == u); }
	bool operator < (const Point& u) const { return dcmp(x - u.x) < 0 || (dcmp(x-u.x)==0 && dcmp(y-u.y) < 0); }
	bool operator > (const Point& u) const { return u < *this; }
	bool operator <= (const Point& u) const { return *this < u || *this == u; }
	bool operator >= (const Point& u) const { return *this > u || *this == u; }
	Point operator + (const Point& u) { return Point(x + u.x, y + u.y); }
	Point operator - (const Point& u) { return Point(x - u.x, y - u.y); }
	Point operator * (const double u) { return Point(x * u, y * u); }
	Point operator / (const double u) { return Point(x / u, y / u); }
	double operator * (const Point& u) { return x*u.y - y*u.x; }
};
typedef Point Vector;
typedef vector<Point> Polygon;

struct Line {
	double a, b, c;
	Line (double a = 0, double b = 0, double c = 0): a(a), b(b), c(c) {}
};

struct DirLine {
	Point p;
	Vector v;
	double ang;
	DirLine () {}
	DirLine (Point p, Vector v): p(p), v(v) { ang = atan2(v.y, v.x); }
	bool operator < (const DirLine& u) const { return ang < u.ang; }
};

struct Circle {
	Point o;
	double r;
	Circle () {}
	Circle (Point o, double r = 0): o(o), r(r) {}
	void read () { o.read(), scanf("%lf", &r); }
	Point point(double rad) { return Point(o.x + cos(rad)*r, o.y + sin(rad)*r); }
	double getArea (double rad) { return rad * r * r / 2; }
};

namespace Punctual {
	double getDistance (Point a, Point b) { double x=a.x-b.x, y=a.y-b.y; return sqrt(x*x + y*y); }
};

namespace Vectorial {
	/* 点积: 两向量长度的乘积再乘上它们夹角的余弦, 夹角大于90度时点积为负 */
	double getDot (Vector a, Vector b) { return a.x * b.x + a.y * b.y; }

	/* 叉积: 叉积等于两向量组成的三角形有向面积的两倍, cross(v, w) = -cross(w, v) */
	double getCross (Vector a, Vector b) { return a.x * b.y - a.y * b.x; }

	double getLength (Vector a) { return sqrt(getDot(a, a)); }
	double getPLength (Vector a) { return getDot(a, a); }
	double getAngle (Vector u) { return atan2(u.y, u.x); }
	double getAngle (Vector a, Vector b) { return acos(getDot(a, b) / getLength(a) / getLength(b)); }
	Vector rotate (Vector a, double rad) { return Vector(a.x*cos(rad)-a.y*sin(rad), a.x*sin(rad)+a.y*cos(rad)); }
	/* 单位法线 */
	Vector getNormal (Vector a) { double l = getLength(a); return Vector(-a.y/l, a.x/l); }
};

namespace ComplexVector {
	typedef complex<double> Point;
	typedef Point Vector;

	double getDot(Vector a, Vector b) { return real(conj(a)*b); }
	double getCross(Vector a, Vector b) { return imag(conj(a)*b); }
	Vector rotate(Vector a, double rad) { return a*exp(Point(0, rad)); }
};

namespace Linear {
	using namespace Vectorial;

	Line getLine (double x1, double y1, double x2, double y2) { return Line(y2-y1, x1-x2, y1*x2-x1*y2); }
	Line getLine (double a, double b, Point u) { return Line(a, -b, u.y * b - u.x * a); }

	bool getIntersection (Line p, Line q, Point& o) {
		if (fabs(p.a * q.b - q.a * p.b) < eps)
			return false;
		o.x = (q.c * p.b - p.c * q.b) / (p.a * q.b - q.a * p.b);
		o.y = (q.c * p.a - p.c * q.a) / (p.b * q.a - q.b * p.a);
		return true;
	}

	/* 直线pv和直线qw的交点 */
	bool getIntersection (Point p, Vector v, Point q, Vector w, Point& o) {
		if (dcmp(getCross(v, w)) == 0) return false;
		Vector u = p - q;
		double k = getCross(w, u) / getCross(v, w);
		o = p + v * k;
		return true;
	}

	/* 点p到直线ab的距离 */
	double getDistanceToLine (Point p, Point a, Point b) { return fabs(getCross(b-a, p-a) / getLength(b-a)); }
	double getDistanceToSegment (Point p, Point a, Point b) {
		if (a == b) return getLength(p-a);
		Vector v1 = b - a, v2 = p - a, v3 = p - b;
		if (dcmp(getDot(v1, v2)) < 0) return getLength(v2);
		else if (dcmp(getDot(v1, v3)) > 0) return getLength(v3);
		else return fabs(getCross(v1, v2) / getLength(v1));
	}

	/* 点p在直线ab上的投影 */
	Point getPointToLine (Point p, Point a, Point b) { Vector v = b-a; return a+v*(getDot(v, p-a) / getDot(v,v)); }

	/* 判断线段是否存在交点 */
	bool haveIntersection (Point a1, Point a2, Point b1, Point b2) {
		double c1=getCross(a2-a1, b1-a1), c2=getCross(a2-a1, b2-a1), c3=getCross(b2-b1, a1-b1), c4=getCross(b2-b1,a2-b1);
		return dcmp(c1)*dcmp(c2) < 0 && dcmp(c3)*dcmp(c4) < 0;
	}

	/* 判断点是否在线段上 */
	bool onSegment (Point p, Point a, Point b) { return dcmp(getCross(a-p, b-p)) == 0 && dcmp(getDot(a-p, b-p)) < 0; }
	bool onLeft(DirLine l, Point p) { return dcmp(l.v * (p-l.p)) >= 0; }
}

namespace Triangular {
	using namespace Vectorial;

	double getAngle (double a, double b, double c) { return acos((a*a+b*b-c*c) / (2*a*b)); }
	double getArea (double a, double b, double c) { double s =(a+b+c)/2; return sqrt(s*(s-a)*(s-b)*(s-c)); }
	double getArea (double a, double h) { return a * h / 2; }
	double getArea (Point a, Point b, Point c) { return fabs(getCross(b - a, c - a)) / 2; }
	double getDirArea (Point a, Point b, Point c) { return getCross(b - a, c - a) / 2; }
};

namespace Polygonal {
	using namespace Vectorial;
	using namespace Linear;

	double getArea (Point* p, int n) {
		double ret = 0;
		for (int i = 0; i < n-1; i++)
			ret += (p[i]-p[0]) * (p[i+1]-p[0]);
		return ret/2;
	}

	/* 凸包 */
	int getConvexHull (Point* p, int n, Point* ch) {
		sort(p, p + n);
		int m = 0;
		for (int i = 0; i < n; i++) {
			/* 可共线 */
			//while (m > 1 && dcmp(getCross(ch[m-1]-ch[m-2], p[i]-ch[m-1])) < 0) m--;
			while (m > 1 && dcmp(getCross(ch[m-1]-ch[m-2], p[i]-ch[m-1])) <= 0) m--;
			ch[m++] = p[i];
		}
		int k = m;
		for (int i = n-2; i >= 0; i--) {
			/* 可共线 */
			//while (m > k && dcmp(getCross(ch[m-1]-ch[m-2], p[i]-ch[m-2])) < 0) m--;
			while (m > k && dcmp(getCross(ch[m-1]-ch[m-2], p[i]-ch[m-2])) <= 0) m--;
			ch[m++] = p[i];
		}
		if (n > 1) m--;
		return m;
	}

	int isPointInPolygon (Point o, Point* p, int n) {
		int wn = 0;
		for (int i = 0; i < n; i++) {
			int j = (i + 1) % n;
			if (onSegment(o, p[i], p[j]) || o == p[i]) return 0; // 边界上
			int k = dcmp(getCross(p[j] - p[i], o-p[i]));
			int d1 = dcmp(p[i].y - o.y);
			int d2 = dcmp(p[j].y - o.y);
			if (k > 0 && d1 <= 0 && d2 > 0) wn++;
			if (k < 0 && d2 <= 0 && d1 > 0) wn--;
		}
		return wn ? -1 : 1;
	}

	/* 旋转卡壳 */
	void rotatingCalipers(Point *p, int n, vector<pii>& sol) {
		sol.clear();
		int j = 1; p[n] = p[0];
		for (int i = 0; i < n; i++) {
			while (getCross(p[j+1]-p[i+1], p[i]-p[i+1]) > getCross(p[j]-p[i+1], p[i]-p[i+1]))
				j = (j+1) % n;
			sol.push_back(make_pair(i, j));
			sol.push_back(make_pair(i + 1, j + 1));
		}
	}

	void rotatingCalipersGetRectangle (Point *p, int n, double& area, double& perimeter) {
		p[n] = p[0];
		int l = 1, r = 1, j = 1;
		area = perimeter = 1e20;

		for (int i = 0; i < n; i++) {
			Vector v = (p[i+1]-p[i]) / getLength(p[i+1]-p[i]);
			while (dcmp(getDot(v, p[r%n]-p[i]) - getDot(v, p[(r+1)%n]-p[i])) < 0) r++;
			while (j < r || dcmp(getCross(v, p[j%n]-p[i]) - getCross(v,p[(j+1)%n]-p[i])) < 0) j++;
			while (l < j || dcmp(getDot(v, p[l%n]-p[i]) - getDot(v, p[(l+1)%n]-p[i])) > 0) l++;
			double w = getDot(v, p[r%n]-p[i])-getDot(v, p[l%n]-p[i]);
			double h = getDistanceToLine (p[j%n], p[i], p[i+1]);
			area = min(area, w * h);
			perimeter = min(perimeter, 2 * w + 2 * h);
		}
	}

	/* 计算半平面相交可以用增量法,o(n^2),初始设置4条无穷大的半平面 */
	/* 用有向直线A->B切割多边形u,返回左侧。可能退化成单点或线段 */
	Polygon cutPolygon (Polygon u, Point a, Point b) {
		Polygon ret;
		int n = u.size();
		for (int i = 0; i < n; i++) {
			Point c = u[i], d = u[(i+1)%n];
			if (dcmp((b-a)*(c-a)) >= 0) ret.push_back(c);
			if (dcmp((b-a)*(c-d)) != 0) {
				Point t;
				getIntersection(a, b-a, c, d-c, t);
				if (onSegment(t, c, d))
					ret.push_back(t);
			}
		}
		return ret;
	}

	/* 半平面相交 */
	int halfPlaneIntersection(DirLine* li, int n, Point* poly) {
		sort(li, li + n);

		int first, last;
		Point* p = new Point[n];
		DirLine* q = new DirLine[n];
		q[first=last=0] = li[0];

		for (int i = 1; i < n; i++) {
			while (first < last && !onLeft(li[i], p[last-1])) last--;
			while (first < last && !onLeft(li[i], p[first])) first++;
			q[++last] = li[i];

			if (dcmp(q[last].v * q[last-1].v) == 0) {
				last--;
				if (onLeft(q[last], li[i].p)) q[last] = li[i];
			}

			if (first < last)
				getIntersection(q[last-1].p, q[last-1].v, q[last].p, q[last].v, p[last-1]);
		}

		while (first < last && !onLeft(q[first], p[last-1])) last--;
		if (last - first <= 1) { delete [] p; delete [] q; return 0; }
		getIntersection(q[last].p, q[last].v, q[first].p, q[first].v, p[last]);

		int m = 0;
		for (int i = first; i <= last; i++) poly[m++] = p[i];
		delete [] p; delete [] q;
		return m;
	}

	/* 去除多边形共线点 */
	Polygon simplify (const Polygon& poly) {
		Polygon ret;
		int n = poly.size();
		for (int i = 0; i < n; i++) {
			Point a = poly[i];
			Point b = poly[(i+1)%n];
			Point c = poly[(i+2)%n];
			if (dcmp((b-a)*(c-b)) != 0 && (ret.size() == 0 || b != ret[ret.size()-1]))
				ret.push_back(b);
		}
		return ret;
	}
};

namespace Circular {
	using namespace Linear;
	using namespace Vectorial;
	using namespace Triangular;

	/* 直线和原的交点 */
	int getLineCircleIntersection (Point p, Point q, Circle O, double& t1, double& t2, vector<Point>& sol) {
		Vector v = q - p;
		/* 使用前需清空sol */
		//sol.clear();
		double a = v.x, b = p.x - O.o.x, c = v.y, d = p.y - O.o.y;
		double e = a*a+c*c, f = 2*(a*b+c*d), g = b*b+d*d-O.r*O.r;
		double delta = f*f - 4*e*g;
		if (dcmp(delta) < 0) return 0;
		if (dcmp(delta) == 0) {
			t1 = t2 = -f / (2 * e);
			sol.push_back(p + v * t1);
			return 1;
		}

		t1 = (-f - sqrt(delta)) / (2 * e); sol.push_back(p + v * t1);
		t2 = (-f + sqrt(delta)) / (2 * e); sol.push_back(p + v * t2);
		return 2;
	}

	/* 圆和圆的交点 */
	int getCircleCircleIntersection (Circle o1, Circle o2, vector<Point>& sol) {
		double d = getLength(o1.o - o2.o);

		if (dcmp(d) == 0) {
			if (dcmp(o1.r - o2.r) == 0) return -1;
			return 0;
		}

		if (dcmp(o1.r + o2.r - d) < 0) return 0;
		if (dcmp(fabs(o1.r-o2.r) - d) > 0) return 0;

		double a = getAngle(o2.o - o1.o);
		double da = acos((o1.r*o1.r + d*d - o2.r*o2.r) / (2*o1.r*d));

		Point p1 = o1.point(a-da), p2 = o1.point(a+da);

		sol.push_back(p1);
		if (p1 == p2) return 1;
		sol.push_back(p2);
		return 2;
	}

	/* 过定点作圆的切线 */
	int getTangents (Point p, Circle o, Vector* v) {
		Vector u = o.o - p;
		double d = getLength(u);
		if (d < o.r) return 0;
		else if (dcmp(d - o.r) == 0) {
			v[0] = rotate(u, pi / 2);
			return 1;
		} else {
			double ang = asin(o.r / d);
			v[0] = rotate(u, -ang);
			v[1] = rotate(u, ang);
			return 2;
		}
	}

	/* a[i] 和 b[i] 分别是第i条切线在O1和O2上的切点 */
	/* have some problems */
	int getTangents (Circle o1, Circle o2, Point* a, Point* b) {
		int cnt = 0;
		if (o1.r < o2.r) { swap(o1, o2); swap(a, b); }
		double d2 = getLength(o1.o - o2.o); d2 = d2 * d2;
		double rdif = o1.r - o2.r, rsum = o1.r + o2.r;
		if (d2 < rdif * rdif) return 0;
		if (dcmp(d2) == 0 && dcmp(o1.r - o2.r) == 0) return -1;

		double base = getAngle(o2.o - o1.o);
		if (dcmp(d2 - rdif * rdif) == 0) {
			a[cnt] = o1.point(base); b[cnt] = o2.point(base); cnt++;
			return cnt;
		}

		double ang = acos( rdif / sqrt(d2) );
		a[cnt] = o1.point(base+ang); b[cnt] = o2.point(base+ang); cnt++;
		a[cnt] = o1.point(base-ang); b[cnt] = o2.point(base-ang); cnt++;

		if (dcmp(d2 - rsum * rsum) == 0) {
			a[cnt] = o1.point(base); b[cnt] = o2.point(base); cnt++;
		} else if (d2 > rsum * rsum) {
			double ang = acos( rsum / sqrt(d2) );
			a[cnt] = o1.point(base+ang); b[cnt] = o2.point(pi+base+ang); cnt++;
			a[cnt] = o1.point(base-ang); b[cnt] = o2.point(pi+base-ang); cnt++;
		}
		return cnt;
	}

	/* 三点确定外切圆 */
	Circle CircumscribedCircle(Point p1, Point p2, Point p3) {
		double Bx = p2.x - p1.x, By = p2.y - p1.y;
		double Cx = p3.x - p1.x, Cy = p3.y - p1.y;
		double D = 2 * (Bx * Cy - By * Cx);
		double cx = (Cy * (Bx * Bx + By * By) - By * (Cx * Cx + Cy * Cy)) / D + p1.x;
		double cy = (Bx * (Cx * Cx + Cy * Cy) - Cx * (Bx * Bx + By * By)) / D + p1.y;
		Point p = Point(cx, cy);
		return Circle(p, getLength(p1 - p));
	}

	/* 三点确定内切圆 */
	Circle InscribedCircle(Point p1, Point p2, Point p3) {
		double a = getLength(p2 - p3);
		double b = getLength(p3 - p1);
		double c = getLength(p1 - p2);
		Point p = (p1 * a + p2 * b + p3 * c) / (a + b + c);
		return Circle(p, getDistanceToLine(p, p1, p2));
	} 

	/* 三角形一顶点为圆心 */
	double getPublicAreaToTriangle (Circle O, Point a, Point b) {
		if (dcmp((a-O.o)*(b-O.o)) == 0) return 0;
		int sig = 1;
		double da = getPLength(O.o-a), db = getPLength(O.o-b);
		if (dcmp(da-db) > 0) {
			swap(da, db);
			swap(a, b);
			sig = -1;
		}

		double t1, t2;
		vector<Point> sol;
		int n = getLineCircleIntersection(a, b, O, t1, t2, sol);

		if (dcmp(da-O.r*O.r) <= 0) {
			if (dcmp(db-O.r*O.r) <= 0)	return getDirArea(O.o, a, b) * sig;

			int k = 0;
			if (getPLength(sol[0]-b) > getPLength(sol[1]-b)) k = 1;

			double ret = getArea(O.o, a, sol[k]) + O.getArea(getAngle(sol[k]-O.o, b-O.o));
			double tmp = (a-O.o)*(b-O.o);
			return ret * sig * dcmp(tmp);
		}

		double d = getDistanceToSegment(O.o, a, b);
		if (dcmp(d-O.r) >= 0) {
			double ret = O.getArea(getAngle(a-O.o, b-O.o));
			double tmp = (a-O.o)*(b-O.o);
			return ret * sig * dcmp(tmp);
		}

		double k1 = O.r / getLength(a - O.o), k2 = O.r / getLength(b - O.o);
		Point p = O.o + (a - O.o) * k1, q = O.o + (b - O.o) * k2;
		double ret1 = O.getArea(getAngle(p-O.o, q-O.o));
		double ret2 = O.getArea(getAngle(sol[0]-O.o, sol[1]-O.o)) - getArea(O.o, sol[0], sol[1]);
		double ret = (ret1 - ret2), tmp = (a-O.o)*(b-O.o);
		return ret * sig * dcmp(tmp);
	}

	double getPublicAreaToPolygon (Circle O, Point* p, int n) {
		if (dcmp(O.r) == 0) return 0;
		double area = 0;
		for (int i = 0; i < n; i++) {
			int u = (i + 1) % n;
			area += getPublicAreaToTriangle(O, p[i], p[u]);
		}
		return fabs(area);
	}
};

using namespace Polygonal;
const int maxn = 1005;
const double inf = 1e6;

struct Edge {
	int be;
	Point a, b;
	Edge () {}
	Edge (Point a, Point b, int be): a(a), b(b), be(be) {}
	bool operator < (const Edge& u) const { return a < u.a || (a == u.a && b < u.b); }
	bool operator == (const Edge& u) const { return !((*this)<u || u<(*this)); }
};

int N, C, Q, W[maxn], D[maxn], vis[maxn];
vector<Edge> T;
vector<int> G[maxn];
vector<Polygon> faces, newfaces;

int isPointInPolygon (Point o, Polygon p) {
	int wn = 0, n = p.size();
	for (int i = 0; i < n; i++) {
		int j = (i + 1) % n;
		if (onSegment(o, p[i], p[j]) || o == p[i]) return 0; // 边界上
		int k = dcmp(getCross(p[j] - p[i], o-p[i]));
		int d1 = dcmp(p[i].y - o.y);
		int d2 = dcmp(p[j].y - o.y);
		if (k > 0 && d1 <= 0 && d2 > 0) wn++;
		if (k < 0 && d2 <= 0 && d1 > 0) wn--;
	}
	return wn ? -1 : 1;
}

void addEdge (Point a, Point b, int idx) {
	if (a > b) swap(a, b);
	T.push_back(Edge(a, b, idx));
}

int find (Point t) {
	for (int j = 0; j < N; j++) {
		if (isPointInPolygon (t, faces[j]) <= 0) return j;
	}
	return -1;
}

void build () {
	T.clear();
	N = faces.size();

	for (int i = 0; i < N; i++) {
		G[i].clear();
		int k = faces[i].size();
		//	printf("%d:%d\n", i, k);
		for (int j = 0; j < k; j++)
			addEdge(faces[i][j], faces[i][(j+1)%k], i);
	}
	//printf("%lu!!!!\n", T.size());

	sort(T.begin(), T.end());
	for (int i = 1; i < T.size(); i++) {
		if (T[i-1] == T[i]) {
			G[T[i-1].be].push_back(T[i].be);
			G[T[i].be].push_back(T[i-1].be);
		}
	}
}

void init () {
	Polygon cur;
	cur.push_back(Point(-inf, -inf));
	cur.push_back(Point(inf, -inf));
	cur.push_back(Point(inf, inf));
	cur.push_back(Point(-inf, inf));

	faces.clear();
	faces.push_back(cur);

	Point ca, cb;
	double a, b, c;
	for (int i = 0; i < N; i++) {
		scanf("%lf%lf%lf", &a, &b, &c);
		while (dcmp(b) == 0 && dcmp(a) == 0);

		if (dcmp(a)) {
			ca = Point((b+c)/(-a), 1);
			cb = Point((-b+c)/(-a), -1);
		} else {
			ca = Point(1, (a+c)/(-b));
			cb = Point(-1, (-a+c)/(-b));
		}

		//	printf("sum:%lu\n", faces.size());

		newfaces.clear();
		for (int j = 0; j < faces.size(); j++) {
			Polygon left = cutPolygon(faces[j], ca, cb);
			Polygon right = cutPolygon(faces[j], cb, ca);

			/*
			   ca.write(), printf(" ");
			   cb.write(), printf("\n");
			   for (int t = 0; t < faces[j].size(); t++)
			   printf("%lf %lf\n", faces[j][t].x, faces[j][t].y);
			   printf("left:%lu, right:%lu\n", left.size(), right.size());
			   printf("\n");
			   */

			if (left.size() >= 3) newfaces.push_back(left);
			if (right.size() >= 3) newfaces.push_back(right);
		}
		faces = newfaces;
	}

	build ();

	int x, y, value;
	memset(W, 0, sizeof(W));
	for (int i = 0; i < C; i++) {
		scanf("%d%d%d", &x, &y, &value);
		int k = find(Point(x, y));
		//	printf("%d\n", k);
		W[k] += value;
	}
}

int bfs (int s, int e) {
	//printf("%d %d\n", s, e);
	memset(D, -1, sizeof(D));
	memset(vis, 0, sizeof(vis));
	queue<int> que;

	que.push(s);
	D[s] = 0;
	vis[s] = 1;

	/*
	   for (int i = 0; i < N; i++) {
	   printf("%d %d %lu:", i, W[i], faces[i].size());
	   for (int j = 0; j < G[i].size(); j++)
	   printf(" %d", G[i][j]);
	   printf("\n");
	   }
	   */

	while (!que.empty()) {
		int u = que.front();
		que.pop();
		vis[u] = 0;
		for (int i = 0; i < G[u].size(); i++) {
			int v = G[u][i];
			if (D[v] == -1 || D[v] > D[u] + 1 + W[v] + W[u]) {
				D[v] = D[u] + 1 + W[v] + W[u];
				if (vis[v] == 0) {
					que.push(v);
					vis[v] = 1;
				}
			}
		}
	}
	return D[e];
}

int main () {
	int cas = 1;
	while (scanf("%d%d%d", &N, &C, &Q) == 3 && N + C + Q) {
		init();

		printf("Case %d:\n", cas++);
		Point s, e;
		while (Q--) {
			s.read(), e.read();
			printf("%d\n", bfs(find(s), find(e)));
		}
	}
	return 0;
}

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-10-27 11:07:39

uva 11595 - Crossing Streets EXTREME(切割多边形)的相关文章

BZOJ 1091([SCOI2003]切割多边形-切割直线)

1091: [SCOI2003]切割多边形 Time Limit: 1 Sec  Memory Limit: 162 MB Submit: 223  Solved: 82 [Submit][Status] Description 有一个凸p边形(p<=8),我们希望通过切割得到它.一开始的时候,你有一个n*m的矩形,即它的四角的坐标分别为(0,0), (0,m), (n,0), (n,m).每次你可以选择一条直线把当前图形切割成两部分,保留其中一个部分(另一部分扔掉)切割线的长度为此直线在多边形

UVA 12230 - Crossing Rivers(概率)

UVA 12230 - Crossing Rivers 题目链接 题意:给定几条河,每条河上有来回开的船,某一天出门,船位置随机,现在要求从A到B,所需要的期望时间 思路:每条河的期望,最坏就是船刚开走3L/V,最好就是直接上船L/V,期望为4L/V/2 = 2L/V,然后在算上陆地上的时间,就是答案 代码: #include <stdio.h> #include <string.h> int n; double d, p, l, v; int main() { int cas =

uva 12230 - Crossing Rivers(求数学期望)

利用了数学期望的线性性质:有线个随机变量之和的数学期望的关于每个随机变量的期望之和: 由于过每条河的时间为L / V和3L / V的均匀分布,因此期望过河时间为2L / V. #include<cstdio> #include<cstring> #include<algorithm> using namespace std; int n;double d; int main() { int kase=0; while(scanf("%d%lf",&a

bzoj1091: [SCOI2003]切割多边形

Description 有一个凸p边形(p<=8),我们希望通过切割得到它.一开始的时候,你有一个n*m的矩形,即它的四角的坐标分别为(0,0), (0,m), (n,0), (n,m).每次你可以选择一条直线把当前图形切割成两部分,保留其中一个部分(另一部分扔掉)切割线的长度为此直线在多边形内部的部分的长度.求出最短的切割线总长度.下面是一个例子.我们需要得到中间的多边形. 分别沿着直线1,2,3,4进行切割即可,得到中间的四边形. Input 第一行有两个整数n, m(0 < n,m &l

【BZOJ】【1091】【SCOI2003】切割多边形

计算几何+枚举 我比较傻逼……一开始想了个贪心,就是这样: 对于每个顶点,找到它的两条切割线……然后我们枚举第一刀是哪一条直线,剩下的p-2个顶点我们只要取两个方向中的较小值min(l[i],r[i])就可以了,枚举第一刀是为了防止风车型的出现…… 然而WA了= =突然想到有个反例…… 这种玩意你就不能砍了一刀后再取min了……因为其中一个方向可能会变短…… 所以还是只能枚举切割的顺序(反正只有p刀)然后模拟这个切割的过程……算长度…… Orz果然我还是太弱,这种东西写出来干嘛……(表示一下我一

UVa 12230 - Crossing Rivers(数学期望)

链接: https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=3382 题意: 你住在村庄A,每天需要过很多条河到另一个村庄B上班.B在A的右边,所有的河都在中间.幸运的是,每条河上都有匀速移动的自动船,因此每当到达一条河的左岸时,只需等船过来,载着你过河,然后在右岸下船.你很瘦,因此上船之后船速不变.日复一日,年复一年,你问自己:从A到B,平均

UVa 12230 Crossing Rivers (数学期望水题)

题意:你要从A到B去上班,然而这中间有n条河,距离为d.给定这n条河离A的距离p,长度L,和船的移动速度v,求从A到B的时间的数学期望. 并且假设出门前每条船的位置是随机的,如果不是在端点,方向也是不定的,你在陆地行走速度为1,输入保证河在AB之前,并且不会重叠. 析:一看这个题,好像不会啊...这怎么求,这么乱,这么复杂... 但是仔细一想求时间期望,不就是在过河的地方时间不是固定的么,只要求出过河的时间的数学期望,利用数学期望的线性,加起来就OK了. 这样一想感觉就不乱了,那么怎么求每个河的

uva 12230 Crossing Rivers

https://vjudge.net/problem/UVA-12230 题意: 在一条笔直的线上,有A和B,两者之间距离为D,之间有n条河,要从A到达B 每条河上都有匀速移动的自动船,因此每当到达一条河的左岸时,只需等船过来,载着你过河,然后在右岸下船. 假设在出门时所有船的位置都是均匀随机分布.如果位置不是在河的端点处,则朝向也是均匀随机.在陆地上行走的速度为1. 告诉你每条河的左端点坐标离A的距离p,长度L和移动速度v(0≤p<D,0<L≤D,1≤v≤100),输出A到B时间的数学期望

UVA - 12230 Crossing Rivers (期望)

Description You live in a village but work in another village. You decided to follow the straight path between your house (A) and the working place (B), but there are several rivers you need to cross. Assume B is to the right of A, and all the rivers