Floyd + 离散化 - K-th Path - CodeForces 1196F

Floyd + 离散化 - K-th Path - CodeForces 1196F

题意：

$给定一个n个点，m条边的无向带权图，$

$计算出图中任意两点之间路径长度的第k小值。$

输入：

$首行包括三个正整数：n,m,k，$

$接着m行输入m条边，包括u,v,w，表示点u和v之家有一条权值为w的无向边。$

输出：

$一个正整数，表示第k短路。$

Examples
Input

6 10 5
2 5 1
5 3 9
6 2 2
1 3 1
5 1 8
6 5 10
1 6 5
6 4 6
3 6 2
3 4 5

Output

3

Input

7 15 18
2 6 3
5 7 4
6 5 4
3 6 9
6 7 7
1 6 4
7 1 6
7 2 1
4 3 2
3 2 8
5 3 6
2 5 5
3 7 9
4 1 8
2 1 1

Output

9

数据范围：

$2\le n\le 2\cdot 10^5，n-1\le m\le min(\frac{n(n-1)}{2},2\cdot 10^5)，1\le k\le min(\frac{n(n-1)}{2},400)$

$1\le u,v\le n,1\le w\le 10^9,u\ne v$

---

分析：

$要求任意两点之间的距离，自然想到考虑Floyd算法，$

$但是本题点数n\le 2\times 10^5，非常不友好。$

$但是k\le 400，而我们要求k短路(任意点对之间的距离)，事实上仅需考虑前k短的边就够了，$

$因此，我们先将m条边排序，然后取出前min(k,m)条边，将这些边的端点离散化(不超过800个点)，$

$然后在这些点中跑floyd即可。最后输出前k短路。$

代码：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
#include<algorithm>

#define ll long long

using namespace std;

const int N=2e5+10, M=2e5+10, inf=0x3f3f3f3f;

int n,m,k;
struct edge
{
    int u,v,w;
    bool operator < (const edge &t) const
    {
        return w<t.w;
    }
}E[M];
ll d[810][810],ans[N],cnt;
int ver[N],idx;
bool st[N];

void build()
{
    int u,v,w;
    for(int i=0;i<min(k,m);i++)
    {
        u=E[i].u, v=E[i].v, w=E[i].w;
        if(!st[u]) st[u]=true, ver[u]=++idx;
        if(!st[v]) st[v]=true, ver[v]=++idx;
        d[ver[u]][ver[v]]=d[ver[v]][ver[u]]=w;
    }
}

void floyd()
{
    for(int k=1;k<=idx;k++)
        for(int i=1;i<=idx;i++)
            for(int j=1;j<=idx;j++)
                d[i][j]=min(d[i][k]+d[k][j],d[i][j]);
    
    for(int i=1;i<=idx;i++)
        for(int j=1;j<i;j++)
            ans[cnt++]=d[i][j];
}

int main()
{
    scanf("%d%d%d",&n,&m,&k);
    int u,v,w;
    for(int i=0;i<m;i++)
    {
        scanf("%d%d%d",&u,&v,&w);
        E[i]={u,v,w};
    }
    sort(E,E+m);

    memset(d,0x3f,sizeof d);
    build();
    floyd();
    sort(ans,ans+cnt);
    
    cout<<ans[k-1]<<endl;
    
    return 0;
}