HDU - 5934 Bomb （强连通分量缩点）

【题解】

题意：有n个炸弹，每个炸弹具有三个属性值：坐标（x,y）引爆半径r以及引爆成本c。当引爆一枚炸弹时，这枚炸弹会同时引爆其爆炸半径内的所有炸弹，问引爆所有炸弹的最小成本。

思路：一个炸弹引爆另一个炸弹可以看做是一条有向边，那么所有炸弹的引爆关系就是一个有向图。对于有向图只要引爆入度为0的点就可以将整个炸弹图全部引爆，也就是最小成本。但是当有向图成环的时候，这个环没有一个入度为0的点，但是需要引爆环中任意一点才可以引爆所有炸弹。因此，我们需要对有向图进行强连通分量缩点，再将所有入度为0的点的成本相加。

【代码】

#include<bits/stdc++.h>
using namespace std;
#define maxn 1005
#define maxm 1000005
#define inf 0x3f3f3f3f
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
int ea=1;
struct node{
    ll x,y,r,c;
}f[maxn];
ll cost[maxn];
struct Edge{
    int to,next;
}edge[maxm];
int n,cnt,head[maxn];
int low[maxn],dfn[maxn],Stack[maxn],belong[maxn],in[maxn];
bool instack[maxn];
int index,top,scc;
int num[maxn];
void add(int u,int v) //建有向边
{
    edge[cnt].to=v;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}
void tarjan(int u) //强连通图缩点
{
    int v;
    low[u]=dfn[u]=++index;
    Stack[top++]=u;
    instack[u]=true;
    for(int i=head[u];i!=-1;i=edge[i].next){
        v=edge[i].to;
        if(!dfn[v]){
            tarjan(v);
            if(low[u]>low[v])low[u]=low[v];
        }
        else if(instack[v]&&low[u]>dfn[v])low[u]=dfn[v];
    }
    if(low[u]==dfn[u]){
        scc++;
        do{
            v=Stack[--top];
            cost[scc]=min(cost[scc],f[v].c);
            instack[v]=false;
            belong[v]=scc;
            num[scc]++;
        }while(v!=u);
    }
}
void solve()
{
    mem(dfn,0),mem(instack,0);
    mem(num,0),mem(in,0);
    for(int i=1;i<=maxn;i++)
        cost[i]=inf;
    index=scc=top=0;
    for(int i=1;i<=n;i++)
        if(!dfn[i])
            tarjan(i);
}
int main()
{
    int t; scanf("%d",&t);
    for(int k=1;k<=t;k++){
        cnt=0; mem(head,-1);
        scanf("%d",&n);
        for(int i=1;i<=n;i++){
            scanf("%lld%lld%lld%lld",&f[i].x,&f[i].y,&f[i].r,&f[i].c);
        }
        //判断i是否能引爆j
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(i==j) continue;
                if((f[i].x-f[j].x)*(f[i].x-f[j].x)+(f[i].y-f[j].y)*(f[i].y-f[j].y)<=f[i].r*f[i].r)
                    add(i,j);
            }
        }
        solve();
        for(int i=1;i<=n;i++){
            for(int j=head[i];j!=-1;j=edge[j].next){
                int v=edge[j].to;
                if(belong[i]!=belong[v]){
                    in[belong[v]]++;
                }
            }
        }
        ll ans=0;
        for(int i=1;i<=scc;i++)
            if(!in[i])
                ans+=cost[i];
        printf("Case #%d: %lld\n",k,ans);
    }
    return 0;
}