矩阵乘法（快速幂）
为说明方便，这里让(k)为点数，(n)为路径长度。
先将点都离散化，这样最后的点只有(2k)个。
先考虑一种暴力，每次用(O(k^3))的复杂度来暴力更新，设当前长度(l)点的两两最短路矩阵为(S)，现在要转移到(l+1)时的最短路矩阵(T)。我们考虑用每条边更新，对于某条从(x)连向(y)的长度为(z)的边，对于任一点(i),有：
[T[i][y]=min(T[i][y],T[i][x]+z)
]
另外，每次更新时，(T)矩阵的初始值为无限大。
然后我们就可以用(O(nk^3))的复杂度去做这道题了。但这明显不行。
我们设没有直接连通的两个点距离为无限大，构建出邻接矩阵(D),就可以魔改一下上面的式子，改成：
[T[i][j]=min(T[i][x]+D[x][j])
]
其中(x)为自己枚举的中间节点，然后就出现的如下的代码：
for(int i=0;i<k;++i){
for(int j=0;j<k;++j){
for(int l=0;l<k;++l){
ret.a[i][j]=min(ret.a[i][j],a.a[i][l]+b.a[l][j]);
}
}
}
发现，这不是就是矩阵乘法吗？
因为取最小值满足可加性，所以使用矩阵快速幂是可行的。这样，我们就能把复杂度优化为(O(lognk^3))
然后，我就不开O2过不了了。
我们发现从源点能到达的点数最多只有(k+1)（因为即使走过每条边都发现一个新节点，也只能发现这么多点。）所以我们可以只用源点能到的点进行离散化，可以将点数从(2k)到(k)，从而在矩阵乘法时省掉8倍常数，然后就可以不开O2AC了。
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N=1000010,M=200;
int n,k,s,t;
struct data{
ll a[M][M];
data(){memset(a,0,sizeof a);}
}a;
data operator*(const data&a,const data&b){
data ret;
memset(ret.a,0x3f,sizeof ret.a);
for(int i=0;i<k;++i){
for(int j=0;j<k;++j){
for(int l=0;l<k;++l){
ret.a[i][j]=min(ret.a[i][j],a.a[i][l]+b.a[l][j]);
}
}
}
return ret;
}
data mpow(data a,int n){
data ret=a;
n--;
while(n){
if(n&1)ret=ret*a;
n/=2;
a=a*a;
}
return ret;
}
int tot,bian[N],nxt[N],head[N];
void add(int x,int y){
tot++,bian[tot]=y,nxt[tot]=head[x],head[x]=tot;
}
struct edge{
int x,y;
ll z;
}e[M];
int vis[N];
vector<int>v;
void dfs(int x){
if(vis[x])return;
v.push_back(x);
vis[x]=1;
for(int i=head[x];i;i=nxt[i]){
int y=bian[i];
dfs(y);
}
}
int main(){
cin>>n>>k>>s>>t;
memset(a.a,0x3f,sizeof a.a);
for(int i=1;i<=k;++i){
scanf("%lld%d%d",&e[i].z,&e[i].x,&e[i].y);
add(e[i].x,e[i].y);
add(e[i].y,e[i].x);
}
dfs(s);
sort(v.begin(),v.end());
for(int i=1;i<=k;++i){
if(!vis[e[i].x])continue;
int x=lower_bound(v.begin(),v.end(),e[i].x)-v.begin(),
y=lower_bound(v.begin(),v.end(),e[i].y)-v.begin();
a.a[y][x]=a.a[x][y]=min(a.a[x][y],e[i].z);
}
data ret=mpow(a,n);
s=lower_bound(v.begin(),v.end(),s)-v.begin();
t=lower_bound(v.begin(),v.end(),t)-v.begin();
cout<<ret.a[s][t]<<endl;
}