给定图，求经过N条边的最短路，采用矩阵乘法求解，或者倍增+floyd

#include <bits/stdc++.h>

using namespace std;
#define ll long long
#define mem(a, b) memset(a,b,sizeof(a))
#define INF 0x3f3f3f3f
#define DBG printf("this is a input\n")
#define fi first
#define se second
#define mk(a, b) make_pair(a,b)
#define p_queue priority_queue

ll gcd(ll a, ll b) {
    return b == 0 ? a : gcd(b, a % b);
}

ll lcm(ll a, ll b) {
    return a / gcd(a, b) * b;
}
int n, m, s ,e, len;
struct e
{
    ll u , v, w;
}edge[250];
struct node
{
    ll dp[250][250];
}start;
int vertex[250], tot;
node mul(node x, node y)
{
    node ans;
    for(int i = 1 ; i <= len ; i ++){
        for(int j = 1; j <= len ; j ++){
            ans.dp[i][j] = INF;
            for(int k = 1 ; k <= len ; k ++){
                ans.dp[i][j] = min(ans.dp[i][j],x.dp[i][k]+y.dp[k][j]);
            }
        }
    }
    return ans;
}
node pow(node a, int p)
{
    node res = a;
    p -= 1; //经过p条边，等于经过p-1个顶点
    while(p)
    {
        if(p & 1)
            res = mul(res,a);
        a = mul(a,a);
        p >>= 1;
    }
    return res;
}
int main(void)
{
    cin>>n>>m>>s>>e;
    mem(start.dp,0x3f);
    for(int i = 1 ; i <= m ; i ++) {
        cin >> edge[i].w >> edge[i].u >> edge[i].v;
        vertex[++tot] = edge[i].u , vertex[++tot] = edge[i].v;
    }
    //是离散化呀
    sort(vertex+1,vertex+1+tot);
    len = unique(vertex+1,vertex+1+tot)-vertex-1;
    for(int i = 1 ; i <= m ; i ++)
    {
        int u = lower_bound(vertex+1,vertex+1+len,edge[i].u)-vertex;
        int v = lower_bound(vertex+1,vertex+1+len,edge[i].v)-vertex;
        start.dp[u][v] = start.dp[v][u] = min(start.dp[u][v],edge[i].w);
    }
    s = lower_bound(vertex+1,vertex+1+len,s)-vertex;
    e = lower_bound(vertex+1,vertex+1+len,e)-vertex;
    //是矩阵快速幂呀（矩阵乘法求最短路，详细参见算法导论）
    node ans = pow(start,n);
    cout<<ans.dp[s][e]<<endl;
}