【HDU 6005】Pandaland（Dijkstra）

Problem Description

Mr. Panda lives in Pandaland. There are many cities in Pandaland. Each city can be treated as a point on a 2D plane. Different cities are located in different locations.

There are also M bidirectional roads connecting those cities. There is no intersection between two distinct roads except their endpoints. Besides, each road has a cost w.

One day, Mr. Panda wants to find a simple cycle with minmal cost in the Pandaland. To clarify, a simple cycle is a path which starts and ends on the same city and visits each road at most once.

The cost of a cycle is the sum of the costs of all the roads it contains.

Input

The first line of the input gives the number of test cases, T. T test cases follow.

Each test case begins with an integer M.

Following M lines discribes roads in Pandaland.

Each line has 5 integers x1,y1,x2,y2, w, representing there is a road with cost w connecting the cities on (x1,y1) and (x2,y2).

Output

For each test case, output one line containing Case #x: y, where x is the test case number (starting from 1) and y is the cost Mr. Panda wants to know.

If there is no cycles in the map, y is 0.

limits

∙1≤T≤50.

∙1≤m≤4000.

∙−10000≤xi,yi≤10000.

∙1≤w≤105.

Sample Input

Sample Output

Case #1: 8

Case #2: 4

Source

2016 CCPC-Final

题解

题意：给出一个无向图，问其中的最小简单环（经过每条边仅一次），若找不到环，输出0。

枚举每一条边，删除它，再求这两点之间的最短路即可。

当然，直接这么做，时间\(O(m(n+m)logn)\)，因此需要剪枝：

若当前最小环值为ans，那么在最短路过程中，当前最小边的长度大于ans，直接退出即可。

参考代码

#include <map>

#include <queue>

#include <cmath>

#include <cstdio>

#include <complex>

#include <cstring>

#include <cstdlib>

#include <iostream>

#include <algorithm>

#define ll long long

#define inf 5000000000LL

#define PI acos(-1)

#define REP(i,x,n) for(int i=x;i<=n;i++)

#define DEP(i,n,x) for(int i=n;i>=x;i--)

#define mem(a,x) memset(a,x,sizeof(a))

using namespace std;

ll read(){

    ll x=0,f=1;char ch=getchar();

    while(ch<'0'||ch>'9'){if(ch=='-') f=-1;ch=getchar();}

    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}

    return x*f;

}

void Out(ll a){

    if(a<0) putchar('-'),a=-a;

    if(a>=10) Out(a/10);

    putchar(a%10+'0');

}

const int N=80005;

map<int,map<int,int> >pos,vis;

int sz;

int find(int x,int y){

    if(!pos[x][y]) pos[x][y]=++sz;

    return pos[x][y];

};

struct node{

    int to,nxt;

    ll cost;

    node(){}

    node(int s1,int s2,ll s3){

        to=s1;nxt=s2;cost=s3;

    }

    bool operator < (const node &an) const{

        return cost>an.cost;

    }

}Path[N];

int head[N],e;

void Addedge(int u,int v,int w){

    Path[++e]=node(v,head[u],(ll)w);

    head[u]=e;

}

void Init(){

    sz=0;e=0;

    mem(head,0);

    pos.clear();

    vis.clear();

}

ll dis[N],ans;

bool book[N];

ll Dijkstra(int s,int t,ll w){

    priority_queue<node>que;

    REP(i,0,sz) dis[i]=inf;

    mem(book,false);

    dis[s]=0;

    que.push(node(s,-1,0));

    int u,v;

    struct node cur;

    while(!que.empty()){

        cur=que.top();

        que.pop();u=cur.to;

        if(cur.cost>=w) break;;

        if(book[u]) continue;

        book[u]=true;

        for(int i=head[u];i;i=Path[i].nxt){

              v=Path[i].to;

              if(dis[v]>dis[u]+Path[i].cost){

                    dis[v]=dis[u]+Path[i].cost;

                    que.push(node(v,-1,dis[v]));

              }

        }

    }

    return dis[t];

}

int main(){

    int T=read();

    REP(i,1,T){

       Init();

       int m=read();

       int u,v,w,x1,y1,x2,y2;

       REP(i,1,m){

           x1=read();y1=read();

           x2=read();y2=read();

           w=read();

           u=find(x1,y1);v=find(x2,y2);

           Addedge(u,v,w);

           Addedge(v,u,w);

       }

       ans=inf;ll tmp;

       REP(i,1,sz){

           for(int k=head[i];k;k=Path[k].nxt){

                u=i;v=Path[k].to;

                if(vis[u][v]||vis[v][u]) continue;

                vis[u][v]=vis[v][u]=1;

                tmp=Path[k].cost;

                Path[k].cost=inf;

                ans=min(ans,Dijkstra(u,v,ans-tmp)+tmp);

                Path[k].cost=tmp;

           }

       }

       printf("Case #%d: %lld\n",i,ans==inf?0:ans);

    }

    return 0;

}