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 = \sum\limits_{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][], mod;
 vector<int>q[N], w[N];//记录前驱的反向边

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

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

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

 int read() {
     int X = , p = ; char c = getchar();
     for(; c > '' || c < ''; c = getchar() ) if( c == '-' ) p = -;
     for(; c >= '' && c <= ''; c = getchar() ) X = X *  + c - '';
     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, , sizeof(vis));
     memset( dis, 0x3f, sizeof(dis));
     pq.push(P(, ));
     dis[] = ;
     for( P u, v; !pq.empty(); ) {
         u = pq.top(); pq.pop();
         int x = u.second;
         if(vis[x]) continue;
         vis[x] = ;
         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 ==  && k ==  ) return ;
     if( f[u][k] != - ) return f[u][k];
     f[u][k] = ;
     sch[u][k] = ;
     for( int i = ; i < (int)q[u].size(); ++i ) {
         int nt = q[u][i], t = dis[u] + k - dis[nt] - w[u][i];
         if(t < ) continue;
         if( sch[nt][t] ) flag = false;//记录路径上的状态
         f[u][k] = (f[u][k] + dp(nt, t)) % mod;
     }
     sch[u][k] = ;//回溯
     return f[u][k];
 }

 int main()
 {
     T = rd;
     for(; T; T-- ) {
         flag = true;
         memset(f, -, sizeof(f));
         memset(head, , sizeof(head));
         memset(sch, , sizeof(sch));
         tot = ;
         for( int i = ; i <= n; ++i ) q[i].clear(), w[i].clear();
         n = rd; m = rd; K = rd; mod = rd;
         for( int i = ; 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[].push_back();
         w[].push_back();
         dij();
         dis[] = ;
         int ans = ;
         for( int i = ; i <= K; ++i ) ans = (ans + dp(n, i)) % mod;
         if(!flag) printf("-1\n");
         else printf("%d\n", ans);
     }
 }