HDU 1599 find the mincost route （无向图的最小环）

题意：

　　给一个带权无向图，求其至少有3个点组成的环的最小权之和。

思路：

　　（1）DFS可以做，实现了确实可以，只是TLE了。量少的时候应该还是可以水一下的。主要思路就是，深搜过程如果当前点搜到一个点访问过了，而其不是当前点的父亲，则肯定有环，可以更新答案。深搜过程要记录路径和，父亲，是否访问过等等信息，因为图可能有多个连通分量。

#include <bits/stdc++.h>
#define INF 0x7f7f7f7f
#define pii pair<int,int>
#define LL unsigned long long
using namespace std;
const int N=110;
struct node
{
    int from, to, cost;
    node(){};
    node(int from,int to,int cost):from(from),to(to),cost(cost){};
}edge[N*N];
int edge_cnt;
vector<int> vect[N];

void add_node(int from,int to,int cost)
{
    edge[edge_cnt]=node(from, to, cost);
    vect[from].push_back(edge_cnt++);
}

int sum[N], vis[N], inq[N], pre[N], ans;

void DFS(int x)
{
    vis[x]=1;
    inq[x]=1;
    for(int i=0; i<vect[x].size(); i++)
    {
        node e=edge[vect[x][i]];
        if( inq[e.to] && pre[x]!=e.to )
        {
            ans=min(ans, sum[x]+e.cost-sum[e.to]);
        }
        if( !inq[e.to] )
        {
            pre[e.to]=x;
            sum[e.to]=sum[x]+e.cost;
            DFS(e.to);
            sum[e.to]=0;
            pre[e.to]=0;
        }
    }
    inq[x]=0;
}

int cal(int n)
{
    ans=INF;
    memset(vis,0,sizeof(vis));
    memset(inq,0,sizeof(inq));
    memset(pre,0,sizeof(pre));
    memset(sum,0,sizeof(sum));
    for(int i=1; i<=n; i++)
    {
        if(!vis[i])
            DFS(i);
    }
    return ans==INF? 0: ans;
}

int main()
{
    freopen("input.txt", "r", stdin);
    int t, a, b, c, n, m;
    while(~scanf("%d %d", &n, &m))
    {
        edge_cnt=0;
        for(int i=0; i<=n; i++) vect[i].clear();

        for(int i=0; i<m; i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            add_node(a, b, c);
            add_node(b, a, c);
        }
        
        int ans=cal(n);
        if(ans) printf("%d
", ans);
        else    printf("It's impossible.
");
    }
    return 0;
}

　　（2）dijkstra。枚举删除某一条边，求该边两点间的最短距离。要注意的是，重边只留1条权最小的，其他删掉，这样就能保证至少出现3个点。

　　608ms

#include <bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <vector>
#include <cstring>
#include <deque>
#define INF 0x7f7f7f7f
#define pii pair<int,int>
#define LL unsigned long long
using namespace std;
const int N=110;
struct node
{
    int from, to, cost, tag;
    node(){};
    node(int from,int to,int cost):from(from),to(to),cost(cost),tag(1){};
}edge[N*N];
int edge_cnt;
vector<int> vect[N];
int g[N][N];
void add_node(int from,int to,int cost)
{
    edge[edge_cnt]=node(from, to, cost);
    vect[from].push_back(edge_cnt++);
}


int vis[N], cost[N];
int dijkstra(int s,int e)
{
    memset(cost, 0x7f, sizeof(cost));
    memset(vis, 0, sizeof(vis));
    cost[s]=0;
    priority_queue<pii,vector<pii>,greater<pii> > que;
    que.push(make_pair(0, s));

    while(!que.empty())
    {
        int x=que.top().second;
        que.pop();
        if(vis[x])  continue;
        vis[x]=1;
        for(int i=0; i<vect[x].size(); i++)
        {
            node e=edge[vect[x][i]];
            if( e.tag && cost[e.to]>cost[x]+e.cost )
            {
                cost[e.to]=cost[x]+e.cost;
                que.push(make_pair(cost[e.to], e.to));
            }
        }
    }
    return cost[e];

}

int cal()
{
    int ans=INF;
    for(int i=0; i<edge_cnt; i+=2)
    {
        edge[i].tag=0;
        edge[i^1].tag=0;
        ans=min(ans, edge[i].cost+dijkstra(edge[i].from, edge[i].to));
        edge[i].tag=1;
        edge[i^1].tag=1;
    }
    return ans==INF? 0: ans;
}

int main()
{
    freopen("input.txt", "r", stdin);
    int t, a, b, c, n, m;
    while(~scanf("%d %d", &n, &m))
    {
        edge_cnt=0;
        for(int i=0; i<=n; i++) vect[i].clear();
        memset(g, 0x7f, sizeof(g));

        for(int i=0; i<m; i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            g[b][a]=g[a][b]=min(g[a][b], c);
        }
        for(int i=1; i<=n; i++) //为了去重边
        {
            for(int j=i+1; j<=n; j++)
            {
                if(g[i][j]<INF)
                {
                    add_node(i, j, g[i][j]);
                    add_node(j, i, g[i][j]);
                }
            }
        }
        int ans=cal();
        if(ans) printf("%d
", ans);
        else    printf("It's impossible.
");
    }
    return 0;
}

　　（3）floyd。dijkstra是枚举删某条边，而floyd是枚举相连的两条边。先理解floyd的思想，穷举每个点k作为中间节点来更新其他点a和b之间的距离，而当某个点未被k枚举到时，是不可能有一条路径将其包含在中间的，它顶多可以作为路径的起点或者终点。利用这点，在未枚举到某点k作为中间点时，可以枚举一下与k相连的两条边，即i->k->j。

 　　78ms

#include <bits/stdc++.h>
#define INF 0x7f7f7f7f
#define pii pair<int,int>
#define LL unsigned long long
using namespace std;
const int N=110;
int g[N][N], dist[N][N];


int cal(int n)  //floyd
{
    int ans=INF;
    for(int k=1; k<=n; k++) //注意枚举顺序。
    {
        //枚举两条边i->k->j。
        for(int i=1; i<=n; i++ )
        {
            if(g[i][k]==INF || k==i) continue;
            for(int j=i+1; j<=n; j++)   //i和j不能相等，才能保证至少3个点。
            {
                if(g[k][j]==INF || dist[i][j]==INF || k==j )    continue;
                int dis=g[i][k] + g[k][j] + dist[i][j];
                ans=min(ans, dis);
            }
        }
        for(int i=1; i<=n; i++)
        {
            for(int j=1; j<=n; j++)
            {
                if(dist[i][k]==INF || dist[k][j]==INF) continue;
                dist[i][j]=min(dist[i][j], dist[i][k]+dist[k][j]);
            }
        }
    }

    return ans==INF? 0: ans;
}

int main()
{
    freopen("input.txt", "r", stdin);
    int t, a, b, c, n, m;
    while(~scanf("%d %d", &n, &m))
    {
        memset(g, 0x7f, sizeof(g));
        for(int i=0; i<m; i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            g[b][a]=g[a][b]=min(g[a][b], c);
        }
        memcpy(dist, g, sizeof(g));
        for(int i=1; i<=n; i++) dist[i][i]=0;

        int ans=cal(n);
        if(ans) printf("%d
", ans);
        else    printf("It's impossible.
");
    }
    return 0;
}