NOIP2017 逛公园（最短路+记忆化搜索）

两手成林

于 2022-05-09 15:11:11 发布

阅读量457

点赞数 1

文章标签：图论深度优先动态规划

本文链接：https://blog.youkuaiyun.com/qq_44719030/article/details/124666212

版权

该博客主要讨论了一种求解最短路径问题的方法——Dijkstra算法，并给出了一段C++实现代码。文章通过举例说明了如何在有限的路径长度内寻找从起点到终点的路线数量，涉及图的表示、记忆化搜索和递推公式。在解决过程中，注意检查是否存在0环以避免无限循环，同时使用了优先队列进行最短路径搜索。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Description

在这里插入图片描述

Input

在这里插入图片描述

Output

在这里插入图片描述

Example

input

output

3
-1

思路

本题题意为求长度为 $d, d + 1, d + 2 . . . . . ., d + k$ 的路线数量，我们发现 $k$ 的范围非常小，可以枚举 $k$ 的值。
对于一个点 $x$ ，到终点的最短距离为 $d i s [x]$ ，对于一个点 $y$ ，到终点的最短距离为 $d i s [y]$ ，它们之间的距离为 $x$ 到 $y$ 边的权重 $w$ ，即可得出从 $x$ 经过 $y$ 到达终点多余的花费为 $c o s t = d i s [y] + w - d i s [x]$
即可得到递推公式 $\sum dp[y][j-cost]$ ，其中 $j$ 代表当前状态下剩余可消耗的路径长度，然后记忆化搜索即可，如果一个点在同一条路径中被判断了多次，则出现了0环直接退出即可

代码

#include <bits/stdc++.h>
#define ll long long
#define mem(s,i) memset(s,i,sizeof s)
#define pii pair<long long,long long>
#define endl "\n"
using namespace std;
const int N = 1e5+4;
const int inf = 1e9;
int head[N],cnt=0,n,m,k,p,u[N<<1],v[N<<1],w[N<<1];
int dp[N][55],vis1[N][55];
struct edge
{
    int to,next,w;
} e[N<<1];
bool huan;
struct node
{
    int dis;
    int pos;
    bool operator <( const node &x )const
    {
        return x.dis < dis;
    }
};
int dis[N],vis[N];
void dijkstra(int s)
{
    mem(dis,0x3f);
    priority_queue<node> pq;
    dis[s] = 0;
    pq.push({0, s});
    while (!pq.empty())
    {
        node t = pq.top();
        pq.pop();
        int x = t.pos, d = t.dis;
        if (vis[x]) continue;
        vis[x] = 1;
        for (int i = head[x]; i != -1; i = e[i].next)
        {
            int y = e[i].to;
            if (dis[y] > dis[x] + e[i].w)
            {
                dis[y] = dis[x] + e[i].w;
             //   if (!vis[y])
            //    {
                    pq.push({dis[y], y});
             //   }
            }
        }
    }
}

void add(int u,int v,int w)
{
    e[cnt].to=v,e[cnt].next=head[u],e[cnt].w=w,head[u]=cnt++;
}

ll dfs(int pos,int d)
{
    if(vis1[pos][d])
    {
        huan = true;
        return 0;
    }
    if(dp[pos][d] != -1) return dp[pos][d];
    vis1[pos][d] = 1;
    ll res = 0;
    for(int i = head[pos]; i!=-1; i = e[i].next)
    {
        int v = e[i].to;
        int cost = dis[v] + e[i].w - dis[pos];
        if(d - cost < 0 || d - cost > k) continue;
        res = (res + dfs(v,d-cost))%p;
        if(huan) return 0;
    }
    vis1[pos][d] = 0;
    if(pos == n && d == 0) res = 1;
    dp[pos][d] = res%p;
    return res%p;
}

void solve()
{
    huan = false;
    mem(head,-1);
    cin >> n >> m >> k >> p;
    for(int i = 1; i <= m; i++)
    {
        cin >> u[i] >> v[i] >> w[i];
        add(v[i],u[i],w[i]);
    }
    mem(vis,0);
    dijkstra(n);
    cnt = 0;
    mem(head,-1);
    mem(dp,-1);
    mem(vis1,0);
    for(int i = 1; i <= m; i++)
    {
        add(u[i],v[i],w[i]);
    }
    ll res = 0;
    for(int i = 0; i <= k; i++)
    {
        res = (res + dfs(1,i))%p;
        if(huan) break;
    }
    if(huan) cout << -1 << endl;
    else cout << res << endl;
}

int main()
{
    int t = 1;
    cin>>t;
    while(t--)
    {
        solve();
    }
    return 0;
}