最小瓶颈路

题目链接：最小瓶颈路

首先，这是一道无脑题

话说我上学校正常信息课20分钟打完，然后一遍A了？

首先不难想到，这个最小瓶颈路一定在最小生成树上

然后我们建一下这棵MST，然后DFS找出S到T的权的最大值

我没这样做

发现n<=1000，感到很happy，发现K<=1000，又很happy

然后上一个大暴力的思路：

可以考虑建k次MST，然后建的时候判断Getfa(s)是否等于Getfa(t)，期间存最大值；对于-1的情况，可以考虑再建一个并查集维护连通性

所以无脑代码如下（极其好打）：

#define INF 0x7fffffff
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
const int N = 1e3 + 5,M = 1e5 + 5;
struct Edge
{
    int x,y,val;
}a[M];
int n,m,k,fa[N],Query[N];
bool cmp(Edge p,Edge q)
{
    return p.val<q.val;
}
inline int read()
{
    int x=0,w=1; char c=getchar();
    while (c>'9' || c<'0') {if (c=='-') w=-1; c=getchar();}
    while (c<='9' && c>='0') {x=(x<<1)+(x<<3)+c-'0'; c=getchar();}
    return w*x;
}
int getfa(int x)
{
    if (x!=fa[x]) fa[x]=getfa(fa[x]);
    return fa[x];
}
int finfa(int x)
{
    if (Query[x]!=x) Query[x]=finfa(Query[x]);
    return Query[x];
}
void Init()
{
    for (int i=1;i<=n;++i)
        fa[i]=i;
}
void combine(int x,int y)
{
    int t1,t2;
    t1=finfa(x); t2=finfa(y);
    if (t1!=t2) Query[t1]=t2;
    else return ;
}
int main()
{
    n=read(); m=read(); k=read();
    for (int i=1;i<=n;++i)
        Query[i]=i;
    for (int i=1;i<=m;++i)
        a[i].x=read(),a[i].y=read(),a[i].val=read(),combine(a[i].x,a[i].y);
    sort(a+1,a+m+1,cmp);
    while (k--)
    {
        int s,t;
        s=read(); t=read();
        if (finfa(s)!=finfa(t))
        {
            printf("-1");
            continue;
        }
        int ans=-INF;
        memset(fa,0,sizeof(fa));
        Init();
        for (int i=1;i<=m;++i)
        {
            int t1,t2;
            t1=getfa(a[i].x); t2=getfa(a[i].y);
            if (t1!=t2) 
            {
                fa[t1]=t2;
                ans=max(ans,a[i].val);
                if (getfa(s)==getfa(t))
                    break;
            }
        }
        printf("%d
",ans);
    }
    return 0;
}

然后跑了266ms美滋滋

发现有Dalao打的DFS（我上面说的），跑了98ms，这里一并粘上

#include <cstdio>
#include <algorithm>
using namespace std;

typedef long long ll;
inline void read (int& s) {
    s = 0;
    static char c = getchar ();
    while (c < '0' || c > '9') c = getchar ();
    while (c >= '0' && c <= '9') s = (s << 3) + (s << 1) + (c ^ 48), c = getchar ();
    return ;
}

const int N = 1003, M = 100003;
int n, m, Q, fa[N];
struct kruskal {
    int x, y, w;
    inline int operator < (const kruskal& p) const {return w < p.w;}
}r[M];

int h[N], tot;
struct stu {
    int v;
    int next;
    int w;
}s[N << 1];

inline void add (const int x, const int y, const int z) {
    ++tot;
    s[tot].v = y;
    s[tot].w = z;
    s[tot].next = h[x];
    h[x] = tot;
    return ;
}

int Find (const int p) {return fa[p] == p ? p : fa[p] = Find (fa[p]);}

int d[N], f[11][N], mx[11][N];

void dfs (const int x, const int pr) {
    d[x] = d[pr] + 1;
    int i, y; for (i = 0; i < 10; ++i) {
        mx[i + 1][x] = max (mx[i][x], mx[i][f[i][x]]);
        f[i + 1][x] = f[i][f[i][x]];
    }
    for (i = h[x]; i; i = s[i].next) {
        y = s[i].v;
        if (y == pr) continue;
        mx[0][y] = s[i].w;
        f[0][y] = x;
        dfs (y, x);
    }
    return ;
}

inline int LCA_MAX (int x, int y) {
    if (d[x] < d[y]) swap (x, y);
    int MAX = 0, i;
    for (i = 10; ~i; --i) {
        if (d[f[i][x]] >= d[y]) {
            MAX = max (MAX, mx[i][x]);
            x = f[i][x];
        }
    }
    if (x == y) return MAX;
    for (i = 10; ~i; --i) {
        if (f[i][x] != f[i][y]) {
            MAX = max (MAX, max (mx[i][x], mx[i][y]));
            x = f[i][x];
            y = f[i][y];
        }
    }
    return max (MAX, max (mx[0][x], mx[0][y]));
}

int main () {
    read (n), read (m), read (Q);
    int i, x, y, z; for (i = 1; i <= m; ++i)
        read (r[i].x), read (r[i].y), read (r[i].w);
    sort (r + 1, r + 1 + m);
    for (i = 1; i <= n; ++i) fa[i] = i;
    int now = 0, fx, fy;
    for (i = 1; i <= m; ++i) {
        fx = Find (r[i].x);
        fy = Find (r[i].y);
        if (fx != fy) {
            fa[fx] = fy;
            ++now;
            add (r[i].x, r[i].y, r[i].w);
            add (r[i].y, r[i].x, r[i].w);
            if (now == n - 1) break;
        }
    }
    for (i = 1; i <= n; ++i) if (!d[i]) dfs (i, 0);
    while (Q--) {
        read (x), read (y);
        if (Find (x) != Find (y)) puts ("-1");
        else printf ("%d
", LCA_MAX (x, y));
    }
    return 0;
}

话说我也想到了最优解，但是苦在打不好

我还是太蒟了