Codevs3287 货车运输

• 题目大意：给定一张无向图，求出两点间所有路径中最小边的最大值。
• 思路：首先我们需要求出一个能连通所有点且能使各边满足题意的简化图，那么它是什么呢？显然是最大生成树。最大生成树既能联通所有点，又能使边符合题意，因为如果存在一个更大的边，该边便会被纳入最大生成树，从而保证了最小边最大化。这样处理后的图是一棵无根树，需要运用dfs确定父子关系。最后处理询问时，找到两个询问点的LCA即能解决问题。
• 解决方案：将kruskal( )反过来按边权从大到小排序，询问时如果find(u)!=find(v)则输出-1，否则进入query( )。在query( )中，如果使用暴力找LCA，只需让两节点在中途记录下边权的最小值最后输出；若使用倍增法，需要利用数组g[i,j]表示从节点i向上跳2j步中载重最小的道路权值，则有g[i,j]=min(g[i,j-1],g[fa[i,j-1],j-1])。
• 代码如下：

  先上暴力版：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
struct edgetype
{
    int u,v,len;
    edgetype(int u=0,int v=0,int len=0):u(u),v(v),len(len){}
};
struct node
{
    int id,len;
    node(int id=0,int len=0):id(id),len(len){}
};
int n,m,q,cnt=0,ans;
edgetype edge[50005];
int fa[10005],f[10005],g[10005],dep[10005];
bool vis[10005];
vector<node> son[10005];

int getfa(int x)
{
    if (fa[x]==x)
      return x;
    fa[x]=getfa(fa[x]);
    return fa[x];
}

void unite(int a,int b)
{
    fa[getfa(a)]=getfa(fa[b]);
}

int comp(edgetype a,edgetype b)
{
    return a.len>b.len;
}

void kruskal()
{
    sort(edge+1,edge+m+1,comp);
    int ingraph=0,p=0;
    while (ingraph<=n-1 && p<m)
    {
        p++;
        if (getfa(edge[p].u)!=getfa(edge[p].v))
        {
            unite(edge[p].u,edge[p].v);
            son[edge[p].u].push_back(node(edge[p].v,edge[p].len));
            son[edge[p].v].push_back(node(edge[p].u,edge[p].len));
            ingraph++;
        }
    }
}

void build(int root,int depth)
{
    dep[root]=depth;
    vis[root]=1;
    vector<node>::iterator it;
    for (it=son[root].begin();it!=son[root].end();++it)
    {
        if (!vis[(*it).id])
        {
            f[(*it).id]=root;
            g[(*it).id]=(*it).len;
            build((*it).id,depth+1);
        }
    }
}

void query(int u,int v)
{
    ans=1000000000;
    if (dep[u]<dep[v])
      swap(u,v);
    while (dep[u]!=dep[v])
    {
        ans=min(ans,g[u]);
        u=f[u];
    }
    if (u==v)
    {
        printf("%d\n",ans);
    }
    else
    {
        while (u!=v)
        {
            ans=min(ans,min(g[u],g[v]));
            u=f[u];
            v=f[v];
        }
        printf("%d\n",ans);
    }

}

void init()
{
    scanf("%d%d",&n,&m);
    int u,v,len;
    memset(vis,0,sizeof(vis));
    for (int i=1;i<=n;++i)
      for (int j=0;j<=20;++j)
        g[i]=1000000000;
    for (int i=1;i<=n;++i)
      fa[i]=i;
    for (int i=1;i<=m;++i)
    {
        scanf("%d%d%d",&u,&v,&len);
        edge[i]=edgetype(u,v,len);
    }
    kruskal();
    build(1,1);
    scanf("%d",&q);
    int x,y;
    while (q--)
    {
        scanf("%d%d",&x,&y);
        if (getfa(x)!=getfa(y))
        {
            printf("-1\n");
            continue;
        }
        query(x,y);
    }
}

int main()
{
    init();
    return 0;
}

然后是t14t41t大神的倍增版（自己的总是WA……）：

#include <cstdio>
#include <cstring>
#include <algorithm>
#define maxm 10005
#define maxn 100005
#define oo 1000000000
#define nil 0
using namespace std;
int n, m, q;
int anc[maxm], ufs[maxm];
struct edges
{
    int s, t, maxi;
    edges(int s = 0, int t = 0, int maxi = 0) :s(s), t(t), maxi(maxi) {}
    bool operator < (const edges& b) const
    {
        return maxi > b.maxi;
    }
}edge[maxn >> 1];
int u[maxn], v[maxn], w[maxn], nxt[maxn], pnt[maxm], e;
int fa[15][maxm], g[15][maxm], dep[maxm];
bool vis[maxm];
int findanc(int x) { return x == anc[x] ? x : anc[x] = findanc(anc[x]); }
int findufs(int x) { return x == ufs[x] ? x : ufs[x] = findufs(ufs[x]); }
void add(edges& a)
{
    u[++e] = a.s; v[e] = a.t; w[e] = a.maxi;
    nxt[e] = pnt[a.s]; pnt[a.s] = e;
    u[++e] = a.t; v[e] = a.s; w[e] = a.maxi;
    nxt[e] = pnt[a.t]; pnt[a.t] = e;
}
void dfs(int rot)
{
    vis[rot] = true;
    for(int j = pnt[rot]; j != nil; j = nxt[j])
    {
        if(!vis[v[j]])
        {
            fa[0][v[j]] = rot;
            g[0][v[j]] = w[j];
            dep[v[j]] = dep[rot] + 1;
            dfs(v[j]);
        }
    }
}
void init()
{
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; ++i) ufs[i] = anc[i] = i;
    for(int i = 0; i < m; ++i)
    {
        scanf("%d%d%d", &edge[i].s, &edge[i].t, &edge[i].maxi);
        if(findufs(edge[i].s) != findufs(edge[i].t))
        {
            ufs[findufs(edge[i].s)] = findufs(edge[i].t);
        }
    }
    sort(edge, edge + m);
    int tot = 0;
    for(int i = 0; i < m && tot < n - 1; ++i)
    {
        if(findanc(edge[i].s) != findanc(edge[i].t))
        {
            anc[findanc(edge[i].s)] = findanc(edge[i].t);
            add(edge[i]);
            ++tot;
        }
    }
    memset(vis, 0, sizeof(vis));
    memset(g, 0x3f, sizeof(g));
    for(int i = 1; i <= n; ++i) if(!vis[i])
    {
        fa[0][i] = nil;
        dep[i] = 1;
        dfs(i);
    }
    for(int j = 1; j <= 14; ++j) for(int i = 1; i <= n; ++i)
    {
        fa[j][i] = fa[j - 1][fa[j - 1][i]];
        g[j][i] = min(g[j][i], min(g[j - 1][i], g[j - 1][fa[j - 1][i]]));
    }
    scanf("%d", &q);
}
void work()
{
    int a, b, ans;
    while(q--)
    {
        ans = oo;
        scanf("%d%d", &a, &b);
        if(findufs(a) != findufs(b))
        {
            puts("-1");
            continue;
        }
        if(dep[a] < dep[b]) swap(a, b);
        for(int j = 14; j >= 0; --j)
        {
            if(dep[fa[j][a]] >= dep[b])
            {
                ans = min(ans, g[j][a]);
                a = fa[j][a];
            }
        }
        if(a != b)
        {
            for(int j = 14; j >= 0; --j)
            {
                if(fa[j][a] != fa[j][b])
                {
                    ans = min(ans, g[j][a]);
                    a = fa[j][a];
                    ans = min(ans, g[j][b]);
                    b = fa[j][b];
                }
            }
            ans = min(ans, g[0][a]);
            ans = min(ans, g[0][b]);
        }
        printf("%d\n", ans);
    }
}
int main()
{
    init();
    work();
    return 0;
}

版权声明：本文为博主原创文章，未经博主允许不得转载。