主要注意的有几点，一个是，在某处如果射了 2 箭，其实只会产生一个洞，所以重复给出的点只能算一个；还有一点，如果所有三角形的集合是 A, 以“相似关系”划分这个集合，即有 A = A₁ ∪ A₂ ∪ … ∪ A_n, 其中集合 A_i 中的三角形互相相似，那么题目要求的东西是 max { |A_i| }.

代码如下：

#include <cmath>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const double eps = 1e-9;
inline int sgn(double a)
{
	return a > eps ? 1 : a < -eps ? -1 : 0;
}
inline bool eq(double a, double b)
{
	return sgn(b - a) == 0;
}
inline bool eq(double a, double b, double c)
{
	return eq(a, b) && eq(b, c) && eq(a, c);
}
struct point
{
	int x, y;
	inline point() { }
	inline point(const int x, const int y) : x(x), y(y) { }
	inline bool operator<(const point &b) const
	{
		if (x == b.x)
			return y < b.y;
		return x < b.x;
	}
	inline bool operator==(const point &b) const
	{
		return x == b.x && y == b.y;
	}
	inline point operator-(const point &b) const
	{
		return point(x - b.x, y - b.y);
	}
	inline int magsqr() const
	{
		return x * x + y * y;
	}
	inline double mag() const
	{
		return sqrt((double)magsqr());
	}
};
struct triangle
{
	point a, b, c;
	double x, y, z;
	inline triangle() { }
	inline triangle(const point &a, const point &b, const point &c) :
		a(a), b(b), c(c)
	{
		sort((point *)&a, (point *)&a + 3);
		x = (a - b).mag();
		y = (b - c).mag();
		z = (c - a).mag();
		sort((double *)&x, (double *)&x + 3);
	}
	inline bool is_valid() const
	{
		if (x + y <= z || y + z <= x || z + x <= y)
			return false;
		point u = b - a, v = c - b;
		if (u.x * v.y == u.y * v.x)
			return false;
		return true;
	}
};
inline bool is_similar(const triangle &u, const triangle &v)
{
	return eq(u.x / v.x, u.y / v.y, u.z / v.z);
}
point pts[100]; int npt;
triangle tris[10000]; int ntri;
inline void build_triangles()
{
	ntri = 0;
	for (int i = 0; i < npt; ++i)
	{
		for (int j = i + 1; j < npt; ++j)
		{
			for (int k = j + 1; k < npt; ++k)
			{
				triangle tri(pts[i], pts[j], pts[k]);
				if (tri.is_valid())
					tris[ntri++] = tri;
			}
		}
	}
}
inline int count_triangles()
{
	int max_similar = 0;
	for (int i = 0; i < ntri; ++i)
	{
		int similar = 0;
		for (int j = i; j < ntri; ++j)
			similar += is_similar(tris[i], tris[j]) ? 1 : 0;
		max_similar = max(max_similar, similar);
	}
	return max_similar;
}
int main()
{
	// freopen("input.txt", "r", stdin);
	while (scanf("%d", &npt))
	{
		if (npt == 0)
			break;
		for (int i = 0; i < npt; ++i)
			scanf("%d %d", &pts[i].x, &pts[i].y);
		sort(pts, pts + npt);
		npt = unique(pts, pts + npt) - pts;
		build_triangles();
		printf("%d\n", count_triangles());
	}
	return 0;
}

首先生成图的最小生成树，然后，枚举任意两点 u, v: 如果边 (u, v) 就在最小生成树里，那么就算一下把 (u, v) 当成 magic road 时，［人口 / 其余路径长度］的值（即 A / B 的值）；如果边 (u, v) 不在最小生成树里，那么此时如果连接 u 和 v, 就会形成一个环，在环上找到除 (u, v) 外最大的一条边，删除之，再以 (u, v) 为 magic road, 计算 A / B 的值。记录下每次计算出来的值中的最大值，输出之。

我是用 Prim 写的最小生成树，因为这题是一个完全图，边数有点多。然后，我使用了一个二维数组来记录，最小生成树中，路径 u → v 上最长的边有多长。方法是每添加一个新顶点的时候，就判断所有已经添加到最小生成树中的顶点，到新添加的顶点的路径上最长的边的长度。具体内容在我的源代码的 82 到 89 行中。

源代码如下：

#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <cmath>
using namespace std;
const int N = 1000;
struct edge_t
{
	int u, v;
	inline edge_t() { }
	inline edge_t(int u, int v) : u(u), v(v) { }
};
double graph[N][N], max_edge[N][N];
int n, population[N], posx[N], posy[N];
class length_greater {
public:
	inline bool operator()(const edge_t &a, const edge_t &b) {
		return graph[a.u][a.v] > graph[b.u][b.v];
	}
};
inline void init_and_input()
{
	memset(max_edge, 0, sizeof max_edge);
	memset(graph, 0, sizeof graph);
	scanf("%d", &n);
	for (int i = 0; i < n; ++i)
		scanf("%d %d %d", posx + i, posy + i, population + i);
	for (int i = 0; i < n; ++i)
	{
		for (int j = 0; j < i; ++j)
		{
			int dx = posx[j] - posx[i];
			int dy = posy[j] - posy[i];
			graph[i][j] = graph[j][i] = sqrt((double)(dx * dx + dy * dy));
		}
	}
}
inline double less_prim()
{
	priority_queue<edge_t, vector<edge_t>, length_greater> edges;
	vector<bool> intree(n, false);
	int last_node = 0; double result = 0;
	for (int i = 1; i < n; ++i)
	{
		intree[last_node] = true;
		// For each edge from last_node.
		for (int j = 0; j < n; ++j)
			if (!intree[j])
				edges.push(edge_t(last_node, j));
		// Get max valid edge.
		edge_t edge;
		do {
			edge = edges.top(); edges.pop();
		} while (intree[edge.u] && intree[edge.v]);
		double current_length = graph[edge.u][edge.v];
		result += current_length;
		int intree_node, newly_node;
		if (intree[edge.u]) {
			intree_node = edge.u;
			newly_node = edge.v;
		} else {
			intree_node = edge.v;
			newly_node = edge.u;
		}
		for (int j = 0; j < n; ++j)
		{
			if (intree[j])
			{
				double current_max = max(current_length, max_edge[j][intree_node]);
				max_edge[j][newly_node] = max_edge[newly_node][j] = current_max;
			}
		}
		last_node = newly_node;
	}
	return result;
}
int main()
{
	// freopen("input.txt", "r", stdin);
	int T;
	scanf("%d", &T);
	while (T--)
	{
		init_and_input();
		double mst = less_prim();
		double max_ratio = 0.0f;
		for (int i = 0; i < n; ++i)
		{
			for (int j = 0; j < n; ++j)
			{
				if (i == j) continue;
				int pop = population[i] + population[j];
				double non_magic = mst - max_edge[i][j];
				double ratio = (double)pop / non_magic;
				max_ratio = max_ratio > ratio ? max_ratio : ratio;
			}
		}
		printf("%0.2lf\n", max_ratio);
	}
	return 0;
}

数据范围，最多有 100 cases, 学生最多 60 名。排名的话，以区间 [x, y] 表示，其中 1 ≤ x ≤ y ≤ 100000.

开始看这个数据，想起队友 WH 说的，如果有那些 30 啊 60 啊之类的东西，就想想是不是动规，因为那些 30 或者 60 刚好是 32 位整型和 64 位整型能表示的东西。

然后我看到区间，而且范围还挺大，就不禁想到线段树。

后来还是没有想法。Google 了一下，发现前人居然是用二分图匹配来写的。感觉这还是有点勉强啊，而且出题者设计的数据也太容易让人想歪了。

源代码如下：

#include <set>
#include <vector>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef vector<vector<int> > graph_t;
typedef vector<int> int_array;
typedef set<int> int_set;
const int N = 111111; // Max rank.
const int M = 100; // Students.
graph_t graph;
int match_student[N];
int_set rank_occupied;
bool hungarian(int student)
{
	for (int i = 0; i < graph[student].size(); ++i)
	{
		int rank = graph[student][i];
		if (rank_occupied.find(rank) != rank_occupied.end())
			continue; // If rank occupied this time.
		rank_occupied.insert(rank);
		if (match_student[rank] == -1 || // If the rank is not assigned.
			hungarian(match_student[rank])) // Or someone can go elsewhere.
		{
			match_student[rank] = student;
			return true;
		}
	}
	return false;
}
inline void init(int student_count)
{
	graph.clear();
	graph.resize(student_count + 1);
	memset(match_student, -1, sizeof match_student);
}
int main()
{
	// freopen("input.txt", "r", stdin);
	int T, n;
	scanf("%d", &T);
	while (T--)
	{
		scanf("%d", &n); init(n);
		for (int i = 0; i < n; ++i)
		{
			int x, y;
			scanf("%d %d", &x, &y);
			for ( ; x <= y; ++x)
				graph[i].push_back(x);
		}
		int result = 0;
		for (int i = n - 1; i >= 0; --i)
		{
			rank_occupied.clear();
			if (hungarian(i))
				++result;
		}
		int_array scheme; scheme.reserve(M);
		for (int i = 0; i < N; ++i)
			if (match_student[i] != -1)
				scheme.push_back(match_student[i]);
		sort(scheme.begin(), scheme.end());
		printf("%d\n", result);
		if (!scheme.empty())
			printf("%d", scheme[0] + 1);
		for (int i = 1; i < scheme.size(); ++i)
			printf(" %d", scheme[i] + 1);
		printf("\n");
	}
	return 0;
}

赛后练习时提交了三次才 AC, 原因是判断红方马的时候不小心判断到了黑方 boss 的原来位置上（而正确的判断方法应该是黑方 boss 走一步之后的那个位置），后来检查了几遍才看出来。

这里面还有一些小技巧，就是可以专门写一个函数，判断两个棋子之间有多少个其它棋子，这样炮、车、帅就好复用了。其实这里面车的 behavior 和帅的基本上是一样的。

现场赛的时候是队长 Wideas 敲的，赛后他对我的教诲是，对于这种模拟题，数据范围并不是特别大，考点在于编程细心方面的，写起来就不要考虑太多执行效率上的问题了。嗯，所以这种题，应该怎么写爽，就怎么写。

#include <cstdio>
#include <cstring>
using namespace std;
int board[20][20];
int bossx, bossy, red_boss;
int redcnt, redx[10], redy[10];
char redtype[10];
const int dirx[4] = { -1,  0,  1,  0};
const int diry[4] = {  0,  1,  0, -1};
const int horx[8] = { -2, -2, -1,  1,  2,  2,  1, -1};
const int hory[8] = { -1,  1,  2,  2,  1, -1, -2, -2};
const int NONE  = 0;
const int RED   = 1;
const int BLACK = 2;
inline bool init_and_input()
{
	memset(board, 0, sizeof board);
	scanf("%d %d %d", &redcnt, &bossx, &bossy);
	if (redcnt == 0 && bossx == 0 && bossy == 0)
		return false;
	char buf[8];
	for (int i = 0; i < redcnt; ++i)
	{
		scanf("%s %d %d", buf, &redx[i], &redy[i]);
		redtype[i] = *buf; red_boss = -1;
		board[redx[i]][redy[i]] = RED;
		if (*buf == 'G')
			red_boss = i;
	}
	return true;
}
inline bool is_on_board(int x, int y)
{
	if (x >= 1 && x <= 10 && y >= 1 && y <= 9)
		return true;
	return false;
}
inline bool is_in_palace(int x, int y)
{
	if (x >= 1 && x <= 3 && y >= 4 && y <= 6)
		return true;
	if (x >= 8 && x <= 10 && y >= 4 && y <= 6)
		return true;
	return false;
}
inline int count_between(int index, int x, int y)
{
	int delta = 0, result = 0;
	if (redx[index] == x)
	{
		if (y > redy[index])
			delta = 1;
		else
			delta = -1;
		for (int i = redy[index] + delta; i != y; i += delta)
			if (board[x][i] != NONE)
				++result;
		return result;
	}
	else if (redy[index] == y)
	{
		if (x > redx[index])
			delta = 1;
		else
			delta = -1;
		for (int i = redx[index] + delta; i != x; i += delta)
			if (board[i][y] != NONE)
				++result;
		return result;
	}
	return -1;
}
inline bool chariot_can_eat(int index, int x, int y)
{
	return count_between(index, x, y) == 0;
}
inline bool general_can_eat(int index, int x, int y)
{
	return chariot_can_eat(index, x, y);
}
inline bool cannon_can_eat(int index, int x, int y)
{
	return count_between(index, x, y) == 1;
}
inline bool horse_can_eat(int index, int x, int y)
{
	for (int i = 0; i < 8; ++i)
	{
		int destx = redx[index] + horx[i];
		int desty = redy[index] + hory[i];
		int footx = redx[index] + dirx[i >> 1];
		int footy = redy[index] + diry[i >> 1];
		if (!is_on_board(destx, desty))
			continue;
		if (!is_on_board(footx, footy))
			continue;
		if (board[footx][footy] != NONE)
			continue;
		if (destx == x && desty == y)
			return true;
	}
	return false;
}
inline bool can_eat(int index, int x, int y)
{
	switch (redtype[index])
	{
	case 'G':
		return general_can_eat(index, x, y);
	case 'R':
		return chariot_can_eat(index, x, y);
	case 'C':
		return cannon_can_eat(index, x, y);
	case 'H':
		return horse_can_eat(index, x, y);
	}
	return false;
}
int main()
{
	// freopen("input.txt", "r", stdin);
	while (init_and_input())
	{
		if (count_between(red_boss, bossx, bossy) == 0)
		{
			printf("NO\n");
			break;
		}
		bool result = true;
		for (int i = 0; i < 4; ++i)
		{
			int x = bossx + dirx[i];
			int y = bossy + diry[i];
			if (!is_in_palace(x, y))
				continue;
			int before = board[x][y];
			board[x][y] = BLACK;
			bool eat = false;
			for (int j = 0; j < redcnt; ++j)
			{
				if (board[redx[j]][redy[j]] != RED)
					continue;
				if (can_eat(j, x, y))
				{
					eat = true;
					break;
				}
			}
			if (!eat)
			{
				result = false;
				break;
			}
			board[x][y] = before;
		}
		if (result)
			printf("YES\n");
		else
			printf("NO\n");
	}
	return 0;
}

思路应该是比较清晰的：首先求多边形的凸包，然后求多边形的重心；再枚举凸包上的每一条边，从重心向枚举的边作垂线；如果所作的垂线能够与边规范相交，那么这种情况是一种稳定情况。

思路确实很简单，但是写起来就有很多东西要写。比如凸包就是一个比较长的东西了，然后求重心又涉及到多边形的三角形分割啥的，还有垂线与边相交的判定也是有点麻烦的。

这道题我 WA 了一次，是因为我计算重心的时候，用的是凸包而不是原多边形。

本题源代码

#include <cmath>
#include <vector>
#include <cstdio>
#include <algorithm>
using namespace std;
/////////////
// Numbers //
/////////////
const double eps = 1e-6;
inline int sgn(double a)
{
	return a > eps ? 1 : a < -eps ? -1 : 0;
}
inline bool eq(double a, double b)
{
	return !sgn(a - b);
}
inline bool lt(double a, double b)
{
	return sgn(a - b) < 0;
}
inline bool gt(double a, double b)
{
	return sgn(a - b) > 0;
}
////////////
// Points //
////////////
struct point
{
	double x, y;
	inline point() : x(0.0), y(0.0) { }
	inline point(double x, double y) : x(x), y(y) { }
	inline point operator+(const point &b) const {
		return point(x + b.x, y + b.y);
	}
	inline point operator-(const point &b) const {
		return point(x - b.x, y - b.y);
	}
	inline point operator*(double k) const {
		return point(x * k, y * k);
	}
	inline point operator/(double k) const {
		return point(x / k, y / k);
	}
	inline point &operator+=(const point &b) {
		x += b.x; y += b.y; return *this;
	}
	inline point &operator-=(const point &b) {
		x -= b.x; y -= b.y; return *this;
	}
	inline point &operator*=(double k) {
		x *= k; y *= k; return *this;
	}
	inline point &operator/=(double k) {
		x /= k; y /= k; return *this;
	}
	inline bool operator==(const point &b) const {
		return eq(x, b.x) && eq(y, b.y);
	}
	inline double magsqr() const {
		return x * x + y * y;
	}
};
inline double cross(const point &a, const point &b) {
	return a.x * b.y - a.y * b.x;
}
inline double dot(const point &a, const point &b) {
	return a.x * b.x + a.y * b.y;
}
inline double ccw(const point &p, const point &a, const point &b) {
	return cross(a - p, b - p);
}
///////////
// Lines //
///////////
struct line
{
	point a, b;
	inline line(const point &a, const point &b) : a(a), b(b) { }
	inline point vec() const {
		return b - a;
	}
};
inline point inpll(const line &la, const line &lb)
{
	double u = cross(la.vec(), point(lb.b - la.b));
	double v = cross(la.vec(), point(lb.a - la.b));
	return (lb.b * v - lb.a * u) / (v - u);
}
inline int relpl(const point &p, const line &l)
{
	return sgn(cross(p - l.a, l.vec())); // 0: on; -1: .|; 1: |..
}
inline int relps(const point &p, const line &s)
{
	int rp = relpl(p, s);
	if (rp) return rp * 3; // -3: .|; 3: |..
	point psa = s.a - p, psb = s.b - p;
	int r = sgn(dot(psa, psb));
	if (r < 0) return 0; // The point is on the segment between end-points.
	if (r == 0) return 1; // The point is at either end-point.
	return 2; // The point is on the line s.
}
inline point plupl(const point &p, const line &l)
{
	point u = l.vec(), v = p - l.a;
	return l.a + u * dot(u, v) / u.magsqr();
}
//////////////
// Polygons //
//////////////
typedef vector<point> polygon;
inline point tricore(const point &a, const point &b, const point &c)
{
	return point((a.x + b.x + c.x) / 3.0, (a.y + b.y + c.y) / 3.0);
}
inline point polycore(const polygon &poly)
{
	point core(0.0, 0.0);
	double mass = 0.0;
	for (int i = 2; i < poly.size(); ++i)
	{
		point c = tricore(poly[0], poly[i - 1], poly[i]);
		double m = ccw(poly[0], poly[i - 1], poly[i]);
		core += (c *= m);
		mass += m;
	}
	return core /= mass;
}
struct graham_scan
{
	vector<bool> instack;
	vector<int> indices;
	inline static bool lessthan(const point &a, const point &b)
	{
		if (eq(a.y, b.y))
			return lt(a.x, b.x);
		return lt(a.y, b.y);
	}
	inline void scan(const polygon &po, int begin, int end, int delta)
	{
		for (int i = begin; i != end; i += delta)
		{
			if (instack[i]) continue;
			while (indices.size() >= 2)
			{
				const point &a = po[indices.back()];
				const point &p = po[indices[indices.size() - 2]];
				if (sgn(ccw(p, a, po[i])) <= 0) {
					instack[indices.back()] = false; indices.pop_back();
				} else break;
			}
			instack[i] = true; indices.push_back(i);
		}
	}
	inline void solve_indices(polygon &poly) // Incoming poly will be changed.
	{
		instack.clear(); instack.resize(poly.size(), false);
		indices.clear(); indices.reserve(poly.size() + 1);
		sort(poly.begin(), poly.end(), lessthan);
		poly.resize(unique(poly.begin(), poly.end()) - poly.begin());
		indices.push_back(0);
		scan(poly, 1, poly.size(), 1);
		scan(poly, poly.size() - 1, -1, -1);
		indices.pop_back();
	}
	inline polygon polygon_from_indices(const polygon &original)
	{
		polygon result; result.reserve(indices.size());
		for (int i = 0; i < indices.size(); ++i)
			result.push_back(original[indices[i]]);
		return result;
	}
};
graham_scan graham;
inline int stable_side_count(const polygon &original)
{
	polygon sorted = original;
	graham.solve_indices(sorted);
	polygon convex = graham.polygon_from_indices(sorted);
	int result = 0;
	point core = polycore(original);
	for (int i = 0; i < convex.size(); ++i)
	{
		int j = (i + 1) % convex.size();
		line edge(convex[i], convex[j]);
		point plumb = plupl(core, edge);
		if (relps(plumb, edge) == 0)
			++result;
	}
	return result;
}
int main()
{
	// freopen("input.txt", "r", stdin);
	int T, n;
	scanf("%d", &T);
	while (T--)
	{
		polygon poly;
		scanf("%d", &n);
		poly.reserve(n);
		while (n--)
		{
			double x, y;
			scanf("%lf %lf", &x, &y);
			poly.push_back(point(x, y));
		}
		printf("%d\n", stable_side_count(poly));
	}
	return 0;
}

数据生成器源代码

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <ctime>
using namespace std;
int main()
{
	freopen("input.txt", "w", stdout);
	srand(clock());
	int t = 1000;
	cout << t << endl << endl;
	while (t--)
	{
		int n = rand() % 10 + 3;
		cout << n << endl << endl;
		while (n--)
			cout << rand() % 100 << ' ' << rand() % 100 << endl;
		cout << endl << endl;
	}
	return 0;
}

这道题的思路是，枚举每一个圆的圆心，然后以它为圆心画圆。用二分法处理半径，每枚举一个半径就尝试看能不能满足覆盖条件。然后找到最短的半径就行了。

这道题有至多 10 个 cases, 至多 20 个圆。圆心的坐标范围是 [-10000, 10000], 半径范围是 [1, 2000], 输入数据都是整数。输出要求精确到 1e-4 这样。

这题我尝试了很多次才 AC. 需要注意的问题是：

• 计算几何中如果用浮点一定要看准条件，尽量用 double. 如果数据到了 1e4 这种数量级，那么小数点要是表示到 4 位还是很有压力了。
• 这个坐标范围是 -10000 到 10000, 加上半径可以到 2000 这个条件，整个平面中可能产生的长度就可能达到 [latex]4000 + 10000 \sqrt{2}[/latex] 之多。一开始我以为令 [latex]\infty = 11111.0[/latex] 都已经便宜它了，后来 WA 才知道，唉。
• 还有那个 eps 也是要设得小一点，设置成 1e-5 都可能四舍五入错误的。其实设小一点时间完全够的。
• 我本来居然以为两圆如果是包含关系可以直接 pass, 后来 WA 了几次才发现其实如果是商场把伞给包了就跪了。

还有就是有的时候计算几何也确实容易莫名其妙地跪，比如以前似乎 POJ 如果输出 double 用 %lf 就不行（现在不知道可以了没有），用 %f 才可以。

在训练计算几何题目的时候使用数据生成器确实不错，从网上搜索标程，然后生成大量的数据，分别用标程和自己的程序来跑一跑，用专门的比较软件（比如 KDiff）比较一下，确实能够发现问题。

本题源代码

#include <cmath>
#include <cstdio>
#include <vector>
using namespace std;
const double eps = 1e-9;
const double pi = acos(-1.0);
const double inf = 1e18;
struct point_t
{
	double x, y;
	inline point_t(double a, double b) : x(a), y(b) { }
	inline point_t operator-(const point_t &b) const {
		return point_t(x - b.x, y - b.y);
	}
	inline double magsqr() const {
		return x * x + y * y;
	}
	inline double mag() const {
		return sqrt(magsqr());
	}
};
struct circle_t
{
	point_t center;
	double radius;
	inline circle_t(const point_t &c, double r) : center(c), radius(r) { }
};
inline int ccrel(const circle_t &a, const circle_t &b)
{
	double d = (b.center - a.center).mag();
	double p = a.radius + b.radius;
	double s = abs(a.radius - b.radius);
	if (p <= d) return -1; // Outer.
	if (d <= s) return 1; // Inner.
	return 0; // Coincide.
}
inline double cirarea(double radius)
{
	return pi * radius * radius;
}
inline double sectarea(double radius, double theta)
{
	return theta / (2.0 * pi) * cirarea(radius);
}
inline double triarea(double a, double b, double c)
{
	double m = (a + b + c) / 2.0;
	return sqrt(m * (m - a) * (m - b) * (m - c));
}
inline double ccarea(const circle_t &a, const circle_t &b)
{
	//*
	int rel = ccrel(a, b);
	if (rel < 0) return 0.0f;
	if (rel > 0) {
		if (a.radius < b.radius)
			return cirarea(a.radius);
		return cirarea(b.radius);
	}
	//*/
	// Otherwise, two circles must coincide.
	double d = (b.center - a.center).mag();
	double d2 = d * d;
	double r2 = a.radius * a.radius;
	double R2 = b.radius * b.radius;
	double cosa = (r2 + d2 - R2) / (2.0 * a.radius * d);
	double cosb = (R2 + d2 - r2) / (2.0 * b.radius * d);
	double secta = sectarea(a.radius, 2.0 * acos(cosa));
	double sectb = sectarea(b.radius, 2.0 * acos(cosb));
	double quad = 2.0 * triarea(d, a.radius, b.radius);
	return secta + sectb - quad;
}
inline bool is_available(
	const circle_t &umbrella, const vector<circle_t> &malls)
{
	for (int i = 0; i < malls.size(); ++i)
	{
		int rel = ccrel(umbrella, malls[i]);
		if (rel < 0) return false;
		double coincide = ccarea(umbrella, malls[i]);
		double halfarea = cirarea(malls[i].radius) / 2.0;
		if (coincide >= halfarea)
			continue;
		else
			return false;
	}
	return true;
}
int main()
{
	// freopen("input.txt", "r", stdin);
	int T, n;
	vector<circle_t> malls;
	scanf("%d", &T);
	while (T--)
	{
		scanf("%d", &n);
		malls.clear();
		malls.reserve(20);
		while (n--)
		{
			double x, y, r;
			scanf("%lf %lf %lf", &x, &y, &r);
			malls.push_back(circle_t(point_t(x, y), r));
		}
		double result = inf;
		for (int i = 0; i < malls.size(); ++i)
		{
			double left = 0.0f, right = inf;
			circle_t umbrella(malls[i].center, inf / 2.0);
			while (right - left >= eps)
			{
				if (is_available(umbrella, malls))
					right = umbrella.radius;
				else
					left = umbrella.radius;
				umbrella.radius = (right + left) / 2.0;
			}
			if (umbrella.radius < result)
				result = umbrella.radius;
		}
		printf("%.4lf\n", result);
	}
	return 0;
}

数据生成器源代码

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <ctime>
using namespace std;
inline int coord()
{
	// return rand() % 20001 - 10000;
	return rand() % 41 - 20;
}
inline int radius()
{
	// return rand() % 2000 + 1;
	return rand() % 20 + 1;
}
int main()
{
	freopen("input.txt", "w", stdout);
	srand(clock()); int t = 10000;
	cout << t << endl << endl;
	for (int i = 0; i < t; ++i)
	{
		int x = rand() % 20 + 1;
		cout << x << endl;
		for (int j = 0; j < x; ++j)
			cout << coord() << ' ' << coord() << ' ' << radius() << endl;
		cout << endl;
	}
}

代码如下：

#include <queue>
#include <cstdio>
#include <climits>
#include <cstring>
using namespace std;
const int N = 15;
const int M = 155;
const int inf = INT_MAX >> 1;
struct glist
{
	int we[M], fe[N], ne[M], he[M], m, n;
	bool seaside[N];
	inline void reset(int graph_size = 0) {
		memset(fe, -1, sizeof fe);
		memset(seaside, false, sizeof seaside);
		m = 0; n = graph_size;
	}
	inline void insert(int u, int v, int weight) {
		we[m] = weight;
		ne[m] = fe[u];
		he[m] = v;
		fe[u] = m++;
	}
};
struct spfa
{
	int dist[N]; bool inqu[N];
	inline void reset() {
		for (int i = 0; i < N; ++i)
			dist[i] = inf;
		memset(inqu, false, sizeof inqu);
	}
	inline void solve(const glist &g, int start)
	{
		queue<int> qu;
		qu.push(start); inqu[start] = true;
		dist[start] = 0;
		while (!qu.empty())
		{
			int u = qu.front();
			qu.pop(); inqu[u] = false;
			for (int e = g.fe[u]; e != -1; e = g.ne[e])
			{
				int v = g.he[e];
				int d = dist[u] + g.we[e];
				if (d < dist[v])
				{
					dist[v] = d;
					if (!inqu[v]) {
						qu.push(v); inqu[v] = true;
					}
				}
			}
		}
	}
};
glist graph;
spfa shortest_path;
int main()
{
	// freopen("input.txt", "r", stdin);
	while (scanf("%d", &graph.n) != EOF)
	{
		graph.reset(graph.n);
		for (int i = 0; i < graph.n; ++i)
		{
			int m, p;
			scanf("%d %d", &m, &p);
			if (p == 0)
				graph.seaside[i] = false;
			else
				graph.seaside[i] = true;
			for (int j = 0; j < m; ++j)
			{
				int s, l;
				scanf("%d %d", &s, &l);
				graph.insert(i, s, l);
			}
		}
		shortest_path.reset();
		shortest_path.solve(graph, 0);
		int result = inf;
		for (int i = 0; i < graph.n; ++i)
			if (graph.seaside[i] && shortest_path.dist[i] < result)
				result = shortest_path.dist[i];
		printf("%d\n", result);
	}
	return 0;
}

一开始不太有思路，后来 Google 到一篇文章，大致说了一下这道题和树的直径和半径有关，并且是枚举那条要拆的边。^[ALP'10]

然后终于想通：拆掉一条边，之后分别求产生的两棵树的直径、中心和半径。再将两棵树的中心以刚才被拆的边相连，得到的结果就是拆这条边能够得到的最优解。假设拆掉的边的长度为 L, 那两棵树的直径和半径分别为 D1, D2, R1, R2, 那么，得到的结果这棵树的直径是 max{D1, D2, R1 + R2 + L}.

这道题的数据规模比较大，有 10 个 cases, 每个 case 至多能有 2500 个节点。使用这种方法似乎复杂度有 O(n²) 之大，我自己写了一个数据生成器，测试了最极端的数据，也到了将近 30 秒才出解。但是我提交到了 OJ 上，还是过了。可能数据没有想象的那么夸张吧。

本题源代码

#include <queue>
#include <cstdio>
#include <climits>
#include <utility>
#include <cstring>
using namespace std;
const int N = 2555;
struct glist
{
	int va[N << 1]; // Edge weight value.
	int ne[N << 1]; // Next edge of edge.
	int he[N << 1]; // Head node of edge.
	int fe[N]; // First edge of node.
	int n; // Number of nodes, managed manually.
	int m; // Number of edges, managed by insert().
	int dis; // Disabled edge.
	inline void reset() {
		memset(fe, -1, sizeof fe);
		n = 0; m = 0; dis = -1;
	}
	inline void insert_single(int u, int v, int value) {
		va[m] = value;
		ne[m] = fe[u];
		he[m] = v;
		fe[u] = m++;
	}
	inline void insert(int u, int v, int value) {
		insert_single(u, v, value);
		insert_single(v, u, value);
	}
	inline static int reversed_edge(int e) {
		return e ^ 1;
	}
	inline int tail_vertex(int e) const {
		return he[reversed_edge(e)];
	}
	inline bool is_disabled_edge(int e) const {
		if (e == dis || e == reversed_edge(dis))
			return true;
		return false;
	}
};
struct tree_diameter
{
	int v1, v2, dist, prev[N];
	bool vst[N];
	inline void reset() {
		v1 = v2 = -1;
		dist = 0;
		memset(prev, -1, sizeof prev);
	}
	inline void find_max(const glist &g, int u, int &v, int &dist)
	{
		v = u; dist = 0;
		queue<pair<int, int> > qu;
		qu.push(make_pair(u, 0));
		memset(vst, false, sizeof vst);
		vst[u] = true;
		while (!qu.empty())
		{
			int x = qu.front().first;
			int d = qu.front().second;
			qu.pop();
			if (d > dist)
			{
				v = x;
				dist = d;
			}
			for (int e = g.fe[x]; e != -1; e = g.ne[e])
			{
				if (g.is_disabled_edge(e))
					continue;
				int y = g.he[e];
				if (vst[y])
					continue;
				vst[y] = true;
				int w = g.va[e];
				qu.push(make_pair(y, d + w));
				prev[y] = glist::reversed_edge(e);
			}
		}
	}
	inline void solve(const glist &g, int u = 0) {
		find_max(g, u, v1, dist);
		find_max(g, v1, v2, dist);
	}
};
struct tree_radius
{
	int v, dist;
	inline void reset() {
		v = -1; dist = 0;
	}
	inline void solve(const glist &g, const tree_diameter &diam)
	{
		int x = diam.v2, y = -1; v = diam.v2;
		for (int e = diam.prev[x]; e != -1; e = diam.prev[y])
		{
			if (g.is_disabled_edge(e))
				continue;
			y = g.he[e];
			dist += g.va[e];
			if ((dist << 1) >= diam.dist)
			{
				int dist2 = diam.dist - (dist - g.va[e]);
				if (dist < dist2) {
					v = y;
				} else {
					v = x;
					dist = dist2;
				}
				return;
			}
			x = y;
		}
	}
};
glist graph;
tree_diameter diameter;
tree_radius radius;
int main()
{
	// freopen("input.txt", "r", stdin);
	// freopen("output.txt", "w", stdout);
	int T, result;
	scanf("%d", &T);
	for (int i = 1; i <= T; ++i)
	{
		graph.reset();
		scanf("%d", &graph.n);
		result = INT_MAX;
		int u, v, w;
		for (int j = 1; j < graph.n; ++j)
		{
			scanf("%d %d %d", &u, &v, &w);
			graph.insert(u, v, w);
		}
		int r1, r2, d1, d2, l;
		for (int e = 0; e < graph.m; e += 2)
		{
			v = graph.he[e];
			u = graph.tail_vertex(e);
			graph.dis = e;
			l = graph.va[e];
			diameter.reset();
			diameter.solve(graph, u);
			radius.reset();
			radius.solve(graph, diameter);
			d1 = diameter.dist;
			r1 = radius.dist;
			diameter.reset();
			diameter.solve(graph, v);
			radius.reset();
			radius.solve(graph, diameter);
			d2 = diameter.dist;
			r2 = radius.dist;
			int t = r1 + r2 + l;
			if (t < d1) t = d1;
			if (t < d2) t = d2;
			if (t < result) result = t;
		}
		printf("Case %d: %d\n", i, result);
	}
	return 0;
}

自己写的极端数据生成器

#include <ctime>
#include <cstdio>
#include <cstdlib>
using namespace std;
int main()
{
	freopen("input.txt", "w", stdout);
	srand(clock());
	printf("10\n\n"); // 10 test cases.
	for (int i = 0; i < 10; ++i)
	{
		printf("2500\n");
		for (int j = 1; j < 2500; ++j)
			printf("%d %d %d\n", rand() % j, j, 1 + rand() % 1000);
		printf("\n");
	}
	return 0;
}

参考

• [ALP'10] alpc32:《天津站B题 Building Roads》

梅森素数其实比较少，可以说少得还挺可怜的。数据范围是 1 到 257. 而且本题的最大数 2²⁵⁷ 的位数也不多，而且其中没有多少素数。但是如果用打表，那就水了。

但是如果不打表，要用到高精度；不仅用到高精度，还要用到大素数的判断。这样的话传统的素数判定是不行的，要用到 Miller-Rabin 算法的高精版本。

最后我采取了一种……略无耻的做法，就是——用 Java!

这个问题上，Java 的好处就是封装了高精类，而且它居然也有 Miller-Rabin 算法。Java 的文档中说，如果迭代 k 次，那么那个算法正确的概率是 [latex]1 – (\frac{1}{2})^{k}[/latex]. 那么考虑到要判断 257 个数，我要让错误的概率在 [latex]\frac{1}{257}[/latex] 左右，我就果断迭代了 8 次。

代码如下：

import java.util.*;
import java.math.*;
public final class Main {
	private static BigInteger one = BigInteger.ONE;
	private static BigInteger two = new BigInteger("2");
	private static BigInteger[] M = new BigInteger[258];
	private static boolean[] isPrime = new boolean[258];
	public static void main(String[] args) {
		M[0] = one;
		for (int i = 1; i < 258; ++i)
			M[i] = M[i - 1].multiply(two);
		for (int i = 0; i < 258; ++i)
			M[i] = M[i].subtract(one);
		for (int i = 0; i < 258; ++i)
			isPrime[i] = M[i].isProbablePrime(8);
		// for (int i = 0; i < 258; ++i)
		// System.out.println(M[i] + ":" + (isPrime[i] ? "Prime" : "NotPrime"));
		Scanner cin = new Scanner(System.in);
		while (cin.hasNext()) {
			int n = cin.nextInt();
			if (n == 0) break;
			System.out.println(n + ":" + (isPrime[n] ? "Prime" : "NotPrime"));
		}
	}
}

代码如下：

#include <cstdio>
using namespace std;
int score_table[256] = {0};
inline void init()
{
	for (char ch = 'A'; ch <= 'Z'; ++ch)
		score_table[ch] = ch - 'A' + 1;
}
char buffer[222];
int main()
{
	init();
	while (gets(buffer))
	{
		int score = 0;
		for (char *p = buffer; *p; ++p)
			score += score_table[*p];
		if (score > 100)
			printf("INVALID\n");
		else
			printf("%d\n", score);
	}
	return 0;
}