HDU 4479 权递增的最短路问题

题目大意：

找一条节点 1 到节点 N 的最短路，保证这条路上每一条边都比前一条边长

dp[i] 表示在当前状态下1到i的最小值

先将所有边根据边的长度排一个序，再每次取出同一段相同长度的边去更新当前图中的每一个点可以更新的dp值，当然我们不能不能因为这相同的边长相互影响，所以不能边找边的同时边松弛dp值，因为可能 1-2:1  2-3:1，也就是说第一次其实不能由1到3这个点，但是你先更新1-2，那么2-3会因为2的dp值存在而可以松弛，所以，先找到所有可行的能进行迟缓的边记录在rec[]数组中，再把里面所有的边弛缓一遍

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
const int N = 10005;
typedef long long LL;
LL dp[N];
int n , m , k;

struct Path{
    int x,y,d;
    bool operator<(const Path &m)const{
        return d < m.d;
    }
}p[100005];

struct Rec{
    int x,y;
    LL d;
    Rec(int x=0,int y=0,LL d=0):x(x),y(y),d(d){}
}rec[100005];

void update(int l , int r)
{
    int t = 0;

    for(int i=l;i<=r;i++){
        int u = p[i].x , v = p[i].y;
        if(dp[u] >= 0 && (dp[v] > dp[u] + p[i].d || dp[v] < 0))
        {
            rec[t++] = Rec(u,v, dp[u] + p[i].d);
        }
        if(dp[v] >= 0 && (dp[u] > dp[v] + p[i].d || dp[u] < 0))
        {
            rec[t++] = Rec(v,u, dp[v] + p[i].d);
        }
    }

    for(int i=0;i<t;i++){
        int u = rec[i].x , v = rec[i].y;
        if(dp[v] > rec[i].d || dp[v] < 0)
        {
            dp[v] = rec[i].d;
        }
    }
}

void add_edge(int x,int y,int d)
{
    p[k].x = x , p[k].y = y , p[k++].d = d;
}

void solve()
{
    sort(p,p+k);
    memset(dp,-1,sizeof(dp));
    dp[1] = 0;
    int l=0;
    for(int r=1 ; r<k;r++){
        if(p[r].d != p[r-1].d){
            update(l , r-1);
            l=r;
        }
    }
    update(l,k-1);
    if(dp[n] < 0)
        puts("No answer");
    else
        printf("%I64d
",dp[n]);
}

int main()
{
   // freopen("test.in","rb",stdin);

    int T,a,b,d;
    scanf("%d",&T);
    while(T--){
        scanf("%d%d",&n,&m);

        k=0;
        memset(G , -1 , sizeof(G));
        for(int i=0;i<m;i++){
            scanf("%d%d%d",&a,&b,&d);
            add_edge(a,b,d);
        }
        solve();
    }
    return 0;
}