2016ccpc杭州赛 hdu 5934 B.Bomb

Bomb

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 58    Accepted Submission(s): 27

Problem Description

There are  N  bombs needing exploding.

Each bomb has three attributes: exploding radius  ri , position  (xi,yi)  and lighting-cost  ci  which means you need to pay  ci  cost making it explode.

If a un-lighting bomb is in or on the border the exploding area of another exploding one, the un-lighting bomb also will explode.

Now you know the attributes of all bombs, please use the  minimum cost to explode all bombs.

 

Input

First line contains an integer  T , which indicates the number of test cases.

Every test case begins with an integers  N , which indicates the numbers of bombs.

In the following  N  lines, the ith line contains four intergers  xi ,  yi ,  ri  and  ci , indicating the coordinate of ith bomb is  (xi,yi) , exploding radius is  ri  and lighting-cost is  ci .

Limits
-  1≤T≤20
-  1≤N≤1000
-  −108≤xi,yi,ri≤108
-  1≤ci≤104

 

Output

For every test case, you should output  'Case #x: y', where  x indicates the case number and counts from  1 and  y is the minimum cost.

 

Sample Input

  

   1
5
0 0 1 5
1 1 1 6
0 1 1 7
3 0 2 10
5 0 1 4
  

 

Sample Output

  

   Case #1: 15
  

 

Source

2016年中国大学生程序设计竞赛（杭州）

 

Recommend

liuyiding   |   We have carefully selected several similar problems for you:   5947  5946  5945  5944  5943 

题意：给你n个炸弹，知道炸弹的坐标和爆炸半径，还有引爆它的费用，一个炸弹可以引爆另一个炸弹。问引爆所有炸弹的最小费用。

思路：n^2枚举一个炸弹是否可以引爆另一个炸弹，可以就建边，然后就是一个普通的强连通分量问题，跑一遍tarjan，找入度为0的强联通分量的最小费用加起来就好了。下面给代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<queue>
#include<utility>
#include<map>
#define maxn 1005
#define inf 0x3f3f3f3f
typedef long long LL;
using namespace std;
const int mod = 1e9 + 7;
int x[maxn], y[maxn], r[maxn], c[maxn], head[maxn], len, n;
int indeg[maxn]; //点的入度和出度数
int belong[maxn], low[maxn], dfn[maxn], scc, cnt;//dfn[]:遍历到u点的时间; low[]:u点可到达的各点中最小的dfn[v],ssc强连通分量数,belong表示该点在哪个联通块
int S[maxn], top, w[maxn];
bool vis[maxn];//v是否在栈中
struct node{
	int to, next;
}Edge[maxn*maxn];
void tarjan(int u)
{
	int v;
	dfn[u] = low[u] = ++cnt;//开始时dfn[u] == low[u]
	S[top++] = u;//不管三七二十一进栈
	vis[u] = true;
	for (int i = head[u]; ~i; i = Edge[i].next)
	{
		v = Edge[i].to;
		if (dfn[v] == 0)//如果v点还未遍历
		{
			tarjan(v);//向下遍历
			low[u] = low[u] < low[v] ? low[u] : low[v];//确保low[u]最小
		}
		else if (vis[v] && low[u] > dfn[v])//v在栈中，修改low[u]
			low[u] = dfn[v];
	}
	if (dfn[u] == low[u])//u为该强连通分量中遍历所成树的根
	{
		++scc;
		do
		{
			v = S[--top];//栈中所有到u的点都属于该强连通分量，退栈
			vis[v] = false;
			belong[v] = scc;
		} while (u != v);
	}

}

void solve()
{
	scc = top = cnt = 0;
	memset(dfn, 0, sizeof(dfn));
	memset(vis, false, sizeof(vis));
	for (int u = 1; u <= n; ++u)
		if (dfn[u] == 0)
			tarjan(u);
	memset(indeg, 0, sizeof(indeg));
	memset(w, inf, sizeof(w));
	for (int u = 1; u <= n; ++u){
		int x = belong[u];
		w[x] = min(w[x], c[u]);
		for (int i = head[u]; ~i; i = Edge[i].next)
		{
			int v = Edge[i].to;
			if (x != belong[v])
			{
				indeg[belong[v]]++;
			}
		}
	}
}
int main(){
	int t;
	scanf("%d", &t);
	for (int tcase = 1; tcase <= t; tcase++){
		scanf("%d", &n);
		for (int i = 1; i <= n; i++){
			scanf("%d%d%d%d", &x[i], &y[i], &r[i], &c[i]);
		}
		len = 0;
		memset(head, -1, sizeof(head));
		for (int i = 1; i <= n; i++){
			for (int j = 1; j <= n; j++){
				if (i == j)
					continue;
				if (pow(x[i] - x[j], 2) + pow(y[i] - y[j], 2) <= pow(r[i], 2)){
					Edge[len].to = j;
					Edge[len].next = head[i];
					head[i] = len++;
				}
			}
		}
		solve();
		LL ans = 0;
		for (int i = 1; i <= scc; i++){
			if (!indeg[i]){
				ans += w[i];
			}
		}
		printf("Case #%d: %lld\n", tcase, ans);
	}
}