Luogu 3953[NOIP2017] 逛公园 堆优化dijkstra + 记忆化搜索

题解

首先肯定是要求出单源最短路的，我用了堆优化dijikstra ,复杂度 mlogm，值得拥有！(只不过我在定义优先队列时把greater 打成了 less调了好久

然后我们就求出了$i$到源点的最短距离$dis_i$

 

定义一个数组 $f_{i, k}$表示从源点到节点$i$的距离比$dis_i$大$k$的路径数，另外一个数组$sch_{i,k}$ 记录某条路径上 该状态是否存在， 若在某条路径上出现了第二次， 并且$k <= K$，则可判断有符合条件的$0$环

对于要求的$f_{i, k}$ 需要求出它所有的前驱状态（也就是拓扑）， 设它的某一前驱为 $f_{u,t}$则$t = dis_i + k - dis_u - w$ ，$w$为边权。

 

由于$t + dis_u + w = k + dis_i$， 所以$t - k = dis_i -dis_u - w$， 因为$dis_i$是到 $i$ 的最短距离， 则显然 $dis_i <= dis_u + w$， 得出$t  <= k$， 也就是某个点前驱的 $k$值会不断减小，只需要$k >= 0$ 即可进行转移。

有转移方程 ： $f_{i, k} = sum f_{u,t}$      $t >= 0$。 边界为 $f_{1, 0} = 1$。但是若设$f_{1, 0} = 1$为边界状态的话，对于经过 点 $1$ 的0环就无法判断了。

所以我把边界定为$f_{0,0} = 1$，再从 $1 - > 0$连一条 记忆化搜索时需要记录前驱的反向，边权为0， 这样就可以解决$0$环的问题。

最后的答案$ans = sumlimits_{k=0}^Kf_{n,k}$。

总时间复杂度为$O(MlogM + KN)$

代码

#include<cstring>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<vector>
#define rd read()
using namespace std;
typedef pair<int,int> P;//用pair来存储dis 与点， 第一个关键字优先排序

const int N = 1e5 + 1e4;

int n, m, K, T, head[N], tot, dis[N], f[N][55], mod;
vector<int>q[N], w[N];//记录前驱的反向边

bool vis[N], sch[N][55], flag = true;

priority_queue<P ,vector<P>, greater<P> > pq;//优先队列

struct edge {
    int u, v, c, nxt;
}e[N << 1];

int read() {
    int X = 0, p = 1; char c = getchar();
    for(; c > '9' || c < '0'; c = getchar() ) if( c == '-' ) p = -1;
    for(; c >= '0' && c <= '9'; c = getchar() ) X = X * 10 + c - '0';
    return X * p;
}

void add( int u, int v, int c ) {
    e[++tot].u = u;
    e[tot].v = v;
    e[tot].c = c;
    e[tot].nxt = head[u];
    head[u] = tot;
}

void dij() {//求单源最短路
    memset( vis, 0, sizeof(vis));
    memset( dis, 0x3f, sizeof(dis));
    pq.push(P(0, 1));
    dis[1] = 0;
    for( P u, v; !pq.empty(); ) {
        u = pq.top(); pq.pop();
        int x = u.second;
        if(vis[x]) continue;
        vis[x] = 1;
        for( int i = head[x], nt; i; i = e[i].nxt ) if( dis[nt = e[i].v] > dis[x] + e[i].c && !vis[nt] ) {
            dis[nt] = dis[x] + e[i].c;
            pq.push(P(dis[nt], nt));
        }
    }
}

int dp( int u, int k ) {//记忆化搜索
    if( u == 0 && k == 0 ) return 1;
    if( f[u][k] != -1 ) return f[u][k];
    f[u][k] = 0;
    sch[u][k] = 1;
    for( int i = 0; i < (int)q[u].size(); ++i ) {
        int nt = q[u][i], t = dis[u] + k - dis[nt] - w[u][i];
        if(t < 0) continue;
        if( sch[nt][t] ) flag = false;//记录路径上的状态
        f[u][k] = (f[u][k] + dp(nt, t)) % mod;
    }
    sch[u][k] = 0;//回溯
    return f[u][k];
}

int main()
{
    T = rd;
    for(; T; T-- ) {
        flag = true;
        memset(f, -1, sizeof(f));
        memset(head, 0, sizeof(head));
        memset(sch, 0, sizeof(sch));
        tot = 0;
        for( int i = 1; i <= n; ++i ) q[i].clear(), w[i].clear();
        n = rd; m = rd; K = rd; mod = rd;
        for( int i = 1; i <= m; ++i ) {
            int u = rd, v = rd, c = rd;
            add(u, v, c);
            q[v].push_back(u);
            w[v].push_back(c);
        }
        q[1].push_back(0);
        w[1].push_back(0);
        dij();
        dis[0] = 0;
        int ans = 0;
        for( int i = 0; i <= K; ++i ) ans = (ans + dp(n, i)) % mod;
        if(!flag) printf("-1
");
        else printf("%d
", ans);
    }
}