蓝桥杯：出差

问题描述

A 国有 N 个城市, 编号为 1……N 。小明是编号为 1 的城市中一家公司的员工, 今天突然接到了上级通知需要去编号为 N 的城市出差。

由于疫情原因, 很多直达的交通方式暂时关闭, 小明无法乘坐飞机直接从 城市 1 到达城市 N, 需要通过其他城市进行陆路交通中转。小明通过交通信息 网, 查询到了 M 条城市之间仍然还开通的路线信息以及每一条路线需要花费的 时间。

同样由于疫情原因, 小明到达一个城市后需要隔离观察一段时间才能离开 该城市前往其他城市。通过网络, 小明也查询到了各个城市的隔离信息。(由于 小明之前在城市 1 , 因此可以直接离开城市 1 , 不需要隔离）

由于上级要求, 小明希望能够尽快赶到城市 NN, 因此他求助于你, 希望你 能帮他规划一条路线, 能够在最短时间内到达城市 N 。

输入格式

第 1 行: 两个正整数 N,M,N 表示 A 国的城市数量, M 表示末关闭的路 线数量

第 2 行: N 个正整数, 第 i 个整数 Ci​ 表示到达编号为 i 的城市后需要隔离 的时间

第 3……M+2 行: 每行 3 个正整数,u,v,c, 表示有一条城市 u 到城市 v 的 双向路线仍然开通着, 通过该路线的时间为 c

输出格式

第 1 行: 1 个正整数, 表示小明从城市 1 出发到达城市 N 的最短时间（到 达城市 N, 不需要计算城市 N 的隔离时间）

样例输入

4 4
5 7 3 4
1 2 4
1 3 5
2 4 3
3 4 5

样例输出

13

评测用例规模与约定

对于 100% 的数据, 1≤N≤1000,1≤M≤10000,1≤Ci≤200,1≤u,v≤1≤N≤1000,1≤c≤1000

运行限制

• 最大运行时间：1s
• 最大运行内存: 512M

首先是我的DFS（只过了30%），有没有大佬帮我看看错在哪里，想哭！

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
using namespace std;
const int M = 1005;
int m, n;//N 表示 A 国的城市数量, M 表示末关闭的路线数量
bool sle[M];
int road[M][M] = { 0 };
int g[M];
int ans=1<<30;
void dfs(int sum, int c)
{
    if (sle[c])
        return;
    else
        sle[c] = 1;
    if (c == n)
    {
        ans = min(ans, sum);
        sle[c] = 0;
        return;
    }
    if (c != 1)
        sum += g[c];
    if (sum > ans)
    {
        sle[c] = 0;
        return;
    }
    for (int i = 1; i <= n; i++)
    {
        if (road[c][i] != 0)
        {
            int t = 0;
            t = sum + road[c][i];
            dfs(t, i);
        }
    }
}
int main()
{
    cin >> n >> m;
    memset(sle, false, sizeof(sle));
    memset(g, 0, sizeof(g));
    for (int i = 1; i <= n; i++)
        cin >> g[i];
    for (int i = 1; i <= m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        road[a][b] = c;
        road[b][a] = c;
    }
    int sum = 0;
    dfs(sum, 1);
    cout << ans;
    return 0;
}

 然后大佬告诉我用迪杰斯特拉，这是大佬的代码（100%）

#include<bits/stdc++.h>
using namespace std;
const int N=1010;

//邻接矩阵
int gra[N][N];
int dist[N];
int g[N];
bool st[N];
int n,m;
//朴素版dijkstra
int dijkstra()
{
     memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    for (int i = 0; i < n - 1; i ++ )
    {
        int t = -1;
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;
        for (int j = 1; j <= n; j ++ )
            dist[j] = min(dist[j], dist[t] + gra[t][j]);
        st[t] = true;
    }
    return dist[n];
}
int main() 
{
    cin>>n>>m;
    for(int i=1;i<=n;++i) cin>>g[i];
    g[n]=0;
    memset(gra, 0x3f, sizeof gra);
    for(int i=1;i<=m;++i){
        int u,v,c;
        cin>>u>>v>>c;
        gra[u][v]=g[v]+c;
        gra[v][u]=g[u]+c;
    }
    cout<<dijkstra()<<endl;
    return 0;
}

然后大佬想用动态规划做，但是做错了，那么请问屏幕前的各位大佬可以用动规做出来吗？求