POJ 1328 解题报告

这道题看似无从下手，实际很简单，就是贪心的思路。所有小岛都在x轴上有个range，只有灯塔在这个range内才能覆盖到小岛。这个range就是求个直角形的边。然后按照range的左边界排序，逐一处理：如果灯塔的总range和当前小岛的range有重叠，则将这两个range取交集作为灯塔的总range；否则，将灯塔的总range替换为当前灯塔的range。

做法虽简单，但是这道题的数据边界条件需要考虑到，不然就是WA。比如d <= 0的情况需要输出-1，另外如果一个小岛的y < 0，那么这个小岛就可以不考虑。

discuss上面有测试数据：http://poj.org/showmessage?message_id=141734。粘贴如下：

input.txt

2 5
-3 4
-6 3




4 5
-5 3
-3 5
2 3
3 3


20 8
-20 7
-18 6
-5 8
-21 8
-15 7
-17 5
-1 5
-2 3
-9 6
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 7
9 6
10 5
0 0


2 3
0 2
2 3


2 3
0 2
1 3


3 3
1 2
-3 2
2 4


8 5
2 4
-4 4
-3 3
-3 1
-3 0
-1 0
0 5
6 0


3 0
1 2
-3 1
2 1


3 2
1 2
-3 1
2 1


1 2
0 2




2 3
0 2
2 3


4 -5
4 3
4 3
2 3
6 -9






3 -3
1 2
-3 2
2 1


6 2
1 2
1 2
1 2
-3 1
2 1
0 0


1 2
0 2


2 3
0 2
1 3


3 10
1 10
2 3
4 5


3 5
1 10
2 3
4 5


4 7
1 10
2 3
4 5
0 0


3 9
1 10
2 3
4 5
0 0

output.txt

Case 1: 1
Case 2: 2
Case 3: 4
Case 4: 1
Case 5: 1
Case 6: -1
Case 7: 3
Case 8: -1
Case 9: 2
Case 10: 1
Case 11: 1
Case 12: -1
Case 13: -1
Case 14: 2
Case 15: 1
Case 16: 1
Case 17: 1
Case 18: -1
Case 19: -1
Case 20: -1

1328

Accepted

240K

47MS

C++

1847B

/* 
ID: thestor1 
LANG: C++ 
TASK: poj1328 
*/
#include <iostream>
#include <fstream>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <limits>
#include <string>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>
#include <cassert>

using namespace std;

const int MAXN = 1000;

class Point
{
public:
	int x, y;
	double left, right;

	Point() {}
	Point(int x, int y) : x(x), y(y) {}

	bool operator< (const Point &rhs) const
	{
		return this->left < rhs.left;
	}
};

int main()
{
	std::ios::sync_with_stdio(false);
	
	std::vector<Point> points(MAXN);

	int n, d;
	int caseno = 1;
	while (cin >> n >> d && n)
	{
		int k = 0, dx, dy;
		for (int i = 0; i < n; ++i)
		{
			cin >> dx >> dy;
			if (dy >= 0)
			{
				points[k].x = dx;
				points[k].y = dy;
				k++;
			}
		}
		n = k;

		bool impossible = (d <= 0);
		for (int i = 0; i < n && !impossible; ++i)
		{
			if (points[i].y > d)
			{
				impossible = true;
				break;
			}
			double range = sqrt((double)(d * d - points[i].y * points[i].y));
			points[i].left = points[i].x - range;
			points[i].right = points[i].x + range;
		}

		if (impossible)
		{
			cout << "Case " << caseno << ": " << -1 << endl;
			caseno++;
			continue;
		}

		sort(points.begin(), points.begin() + n);

		int cnt = 1;
		double lx = points[0].left, rx = points[0].right;
		for (int i = 1; i < n; ++i)
		{
			// points[i].left, points[i].right;
			if (rx < points[i].left)
			{
				lx = points[i].left;
				rx = points[i].right;
				cnt++;
			}
			else
			{
				lx = max(lx, points[i].left);
				rx = min(rx, points[i].right);
			}
		}

		cout << "Case " << caseno << ": " << cnt << endl;
		caseno++;
	}

	return 0;  
}