Earth Hour

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 125536/65536 K (Java/Others) Problem Description Earth Hour is an annual international event created by the WWF (World Wide Fund for Nature/World Wildlife Fund), held on the last Saturday of March, that asks households and businesses to turn off their non-essential lights and electrical appliances for one hour to raise awareness towards the need to take action on climate change.
To respond to the event of this year, the manager of Hunan University campus decides to turn off some street lights at night. Each street light can be viewed as a point in a plane, which casts flash in a circular area with certain radius.
What's more, if two illuminated circles share one intersection or a point, they can be regarded as connected.
Now the manager wants to turn off as many lights as possible, guaranteeing that the illuminated area of the library, the study room and the dormitory are still connected(directly or indirectly). So, at least the lights in these three places will not be turned off.

Input The first line contains a single integer T, which tells you there are T cases followed.
In each case:
The first line is an integer N( 3<=N<=200 ), means there are N street lights at total.
Then there are N lines: each line contain 3 integers, X,Y,R,( 1<=X,Y,R<=1000 ), means the light in position(X,Y) can illuminate a circle area with the radius of R. Note that the 1st of the N lines is corresponding to the library, the 2nd line is corresponding to the study room, and the 3rd line is corresponding to the dorm.

Output One case per line, output the maximal number of lights that can be turned off.
Note that if none of the lights is turned off and the three places are still not connected. Just output -1.

Sample Input 3 5 1 1 1 1 4 1 4 1 1 2 2 1 3 3 1 7 1 1 1 4 1 1 2 4 1 1 3 1 3 1 1 3 3 1 4 3 1 6 1 1 1 5 1 1 5 5 1 3 1 2 5 3 2 3 3 1
Sample Output -1 2 1

解題思路：這道題要刪點，使得編號為1,2,3的頂點連通。這道題讓我想起了之前做的hdu 2833，它是找兩條最短路之間有多少個重複的點。如何將它應用到本道題上呢？我的想法是在1,2,3三個頂點之間找兩條路，假定為1->2和1->3，這樣我們就可以找1->2和1->3這兩條最短路的重複點，這個是需要我們保留的點，即我們需要儘量多的重複點來使得1,2,3都依靠這些點進行連通。由於只有1,2,3三個頂點，所以只需要列舉三次即可。這個演算法的核心是依賴於Floyd演算法，這裡的資料量似乎行不通，TLE啦。。

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

const int maxn = 205;
const int inf = 0x3f3f3f3f;
struct Node
{
	int x,y,r;
}light[maxn];
int n,ans,map[maxn][maxn],dp[maxn][maxn];

int dist(Node a,Node b)
{
	return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}

void floyd()
{
	for(int k = 1; k <= n; k++)
		for(int i = 1; i <= n; i++)
			for(int j = 1; j <= n; j++)
			{
				if(map[i][j] > map[i][k] + map[k][j])
				{
					map[i][j] = map[i][k] + map[k][j];
					dp[i][j] = dp[i][k] + dp[k][j] - 1;
				}
				else if(map[i][j] == map[i][k] + map[k][j] && dp[i][j] < dp[i][k] + dp[k][j])
					dp[i][j] = dp[i][k] + dp[k][j] - 1;
			}
}

void solve(int s1,int e1,int s2,int e2)
{
	int res = 0;
	for(int i = 1; i <= n; i++)
		for(int j = 1; j <= n; j++)
			if(map[s1][i] + map[i][j] + map[j][e1] == map[s1][e1] && map[s2][i] + map[i][j] + map[j][e2] == map[s2][e2])
				res = max(res,dp[i][j]);
	ans = max(ans,n - (map[s1][e1] + map[s2][e2] + 2 - res));
}

int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d",&n);
		for(int i = 1; i <= n; i++)
			scanf("%d%d%d",&light[i].x,&light[i].y,&light[i].r);
		for(int i = 1; i <= n; i++)
		{
			for(int j = 1; j <= n; j++)
			{
				map[i][j] = inf;
				dp[i][j] = 2;
			}
			map[i][i] = 0;
			dp[i][i] = 1;
		}
		for(int i = 1; i < n; i++)
			for(int j = i + 1; j <= n; j++)
			{
				if(dist(light[i],light[j]) <= (light[i].r + light[j].r) * (light[i].r + light[j].r))
					map[i][j] = map[j][i] = 1;
			}
		floyd();
		ans = 0;
		solve(1,2,1,3);
		solve(2,1,2,3);
		solve(3,1,3,2);
		if(ans == 0) ans = -1;
		printf("%d\n",ans);
	}
	return 0;
}
 

參考了別人的部落格，大多數都是分別以1,2,3為起點，去找最短路，接下來就是列舉頂點，使得該頂點為連線1,2,3的中心點，即1->i、2->i、3->i，三條路之間沒有公共點。最開始在想這樣會算重複，但仔細想想是不會的。因為只要1,2,3是連通的，就一定可以找到這樣的i。做完這題給我的感覺就是：有些圖已經是連通的了，那麼它的結構形態似乎不那麼重要了，可以將其重構成我們需要的樣子。