HDU2121

HDU2121

Description：

一個女王的國家由N 個城市和M 條單向路組成，城市從0 到N−1 編號，每條路若要美化都有一個花費。現在女王要你選一個點爲國都，並選擇N−1 條路進行美化，使其能從國都沿美化了的路到達每一個城市，且總花費最少。

Input：

第一行：兩個數字N 、M 。

接下來M行：每行三個數字S 、T 、C ，分別表示這條路的起點編號、終點編號和美化花費。

Output：

一行：兩個數字，分別表示最小總花費和國都編號。

Solution：

最小樹形圖，每個點選入邊中邊權最小的那個，縮點。

但是沒有根怎麼辦？

自己建一個根，並使根連向每個點，且花費爲INF，這樣可以保證只有一個點會連到你建的這個根，這個點就是實際的國都。

Code：

#include<cstdio>
#include<cstdlib>
#include<string.h>
#include<algorithm>
#include<queue>
#include<stack>
#define INF 0x3f3f3f3f

using namespace std;
const int maxn=1010;
const int maxm=10100;
int n,m,root,ans1,ans2;
bool asd;

struct EDGE
{
    int u,v,cost,num,pointto;
    EDGE *next,*fenext;
}edge[maxm+maxn],*ind[maxn],*feind[maxn];
int el=-1;
void input(int u,int v,int cost)
{
    edge[++el].u=u;
    edge[el].pointto=v;
    edge[el].num=el;
    edge[el].v=v;
    edge[el].cost=cost;
    edge[el].next=ind[u];
    ind[u]=&edge[el];
    edge[el].fenext=feind[v];
    feind[v]=&edge[el];
}

bool vis[maxn],scc[maxn];
int fa[maxn],mc[maxn],cedge[maxn];
bool MST()
{
    memset(vis,0,sizeof(vis));

    for(int i=0;i<=el;i++)
    {
        int u=edge[i].u,v=edge[i].v,c=edge[i].cost;
        if(!scc[u]&&!scc[v])
            if(mc[v]>=c)
            {
                fa[v]=u,mc[v]=c;cedge[v]=edge[i].num;
            }
    }
    int sumr=0;
    for(int i=n-1;i>=0;i--)
    {
        if(fa[i]==root)
        {
            if(sumr) return asd=0;
            else sumr++;
        }
        if(!scc[i]&&fa[i]==-1)
        {
            return asd=0;
        }
    }

    for(int i=n;i>=0;i--)
        if(!scc[i])
        {
            memset(vis,0,sizeof(vis));
            vis[root]=1;
            int v=i;
            for(;!vis[v];v=fa[v])
                vis[v]=true;
            if(v==root) continue;

            int u=v;
            do
            {
                scc[v]=1;
                v=fa[v];
            }while(u!=v);
            do
            {
                ans1+=mc[v];
                EDGE *k1;
                for(EDGE *k=ind[v];k!=NULL;k=k1)
                {
                    k1=k->next;
                    if(scc[k->v]||k->u==u) continue;
                    k->u=u;
                    k->next=ind[u];
                    ind[u]=k;
                }
                for(EDGE *k=feind[v];k!=NULL;k=k1)
                {
                    k1=k->fenext;
                    if(scc[k->u]) continue;
                    k->cost-=mc[v];
                    if(k->v==u) continue;
                    k->v=u;
                    k->fenext=feind[u];
                    feind[u]=k;
                }
                if(v!=u)
                {
                    ind[v]=NULL;
                    feind[v]=NULL;
                }
                mc[v]=0;
                v=fa[v];
            }while(u!=v);
            scc[u]=0;
            mc[u]=INF+1;
            fa[u]=-1;
            return 1;
        }
    for(int i=n-1;i>=0;i--)
        if(!scc[i]) ans1+=mc[i];
    return 0;
}

void init();
int main()
{
    while(scanf("%d%d",&n,&m)==2)
    {
        init();
        for(int i=n-1;i>=0;i--) input(root,i,INF);
        for(int i=1;i<=m;i++)
        {
            int x,y,c;
            scanf("%d%d%d",&x,&y,&c);
            input(x,y,c);
        }
        if(n==0) printf("-1 0\n\n");
        else if(n==1) printf("0 0\n\n");
        else
        {
            while(MST());
            if(asd)
                for(int i=0;i<n;i++)
                    if(!scc[i]&&fa[i]==root)
                        ans2=edge[cedge[i]].pointto;
            if(!asd) printf("impossible\n\n");
            else printf("%d %d\n\n",ans1-int(INF),ans2);
        }
    }
    return 0;
}
void init()
{
    root=n;
    asd=1;
    ans1=0;ans2=0;
    el=-1;
    for(int i=0;i<=n;i++) ind[i]=NULL,feind[i]=NULL,mc[i]=INF+1;
    memset(scc,0,sizeof(scc));
    memset(fa,n+1,sizeof(fa));
}