洛谷 P3953 [NOIP2017 提高组] 逛公园

最新推荐文章于 2024-07-20 08:58:24 发布

11011b

最新推荐文章于 2024-07-20 08:58:24 发布

阅读量466

点赞数 1

分类专栏： DP 文章标签：算法 c++ 数据结构

本文链接：https://blog.csdn.net/m0_56280274/article/details/124254070

版权

DP 专栏收录该内容

30 篇文章 0 订阅

订阅专栏

该博客介绍了如何利用记忆化搜索和迪杰斯特拉算法解决一道编程竞赛题目——NOIP2017提高组的‘逛公园’问题。博主首先讲解了题目背景和要求，然后详细阐述了记忆化搜索的过程，包括建立反向边、最短路径计算、状态转移方程等关键步骤，并提供了完整的C++代码实现。博客内容适合对算法竞赛感兴趣的读者和学习者。

摘要由CSDN通过智能技术生成

开始刷题单啦~，这部分的洛谷好题作为个人训练记录和以后复习用，有兴趣的可以一起做做

题目链接：P3953 [NOIP2017 提高组] 逛公园

题意都是中文就不翻译了

题解：这是一道记忆化+搜索的题目，我们可以先用迪杰斯特拉求出每个点距离起点1的最短距离，然后建反向边（e_f），因为k很小，所以我们可以枚举k，从终点往起点搜索，因为每个点距离1的最短路径都已经求出来了，那么假设当前枚举的是x，和最短路径相差len,用dis数组表示每个点距离起点的最短距离，那么有转移如下：dfs(x,len)->dfs(y,len+dis[x]-dis[y]-w)表示从当前点x通过x,y间权值为w的边时，多走了dis[x]-dis[y]-w距离,记忆化用num[i][j]表示点当前搜索到点i，和最短路径相差j的方案数，判断有无0环时可以用个ind[i][j]数组，每次搜索x儿子们前先把x当前状态即ind[x][len]标记，搜索完后取消标记，那么如果儿子们搜索到x就说明有环，若此时儿子的len恰好和x的相同，说明这个环的权值和为0；

剩下的细节都注释的很详细了：

#include<iostream>
#include<stack>
#include<list>
#include<set>
#include<vector>
#include<algorithm>
#include<math.h>
#include<numeric>
#include<map>
#include<cstring>
#include<queue>
#include<iomanip>
#include<cmath>
#include<queue>
#include <bitset>
#include<unordered_map>
	#ifndef local
	#define endl '\n'
#endif */
#define mkp make_pair
using namespace std;
using std::bitset;
typedef long long ll;
typedef long double ld;
const int inf=0x3f3f3f3f;
const ll MAXN=2e6+10;
const ll N=2e5+100;
const ll mod=1e9+7;
const ll hash_p1=1610612741;
const ll hash_p2=805306457;
const ll hash_p3=402653189;
//-----------------------------------------------------------------------------------------------------------------*/
// ll head[MAXN],net[MAXN],to[MAXN],edge[MAXN]/*流量*/,cost[MAXN]//费用;
/* 
void add(ll u,ll v,ll w,ll s){
	to[++cnt]=v;net[cnt]=head[u];edge[cnt]=w;cost[cnt]=s;head[u]=cnt;
	to[++cnt]=u;net[cnt]=head[v];edge[cnt]=0;cost[cnt]=-s;head[v]=cnt;
}
struct elemt{
	int p,v;
};
-----------------------------------
求[1,MAXN]组合式和逆元 
ll mi(ll a,ll b){
	ll res=1;
	while(b){
		if(b%2){
			res=res*a%mod;
		}	
		a=a*a%mod;
		b/=2;
	}
	return res;
}
ll fac[MAXN+10],inv[MAXN+10]
ll C(int m,int n){//组合式C(m,n); 
	if(!n){
		return 1;
	}
	return fac[m]*(inv[n]*inv[m-n]%mod)%mod;
}
fac[0]=1;inv[0]=1;
for(ll i=1;i<=MAXN;i++){
	fac[i]=(fac[i-1]*i)%mod;
	inv[i]=mi(fac[i],mod-2);
}
---------------------------------
 unordered_map<int,int>mp;
//优先队列默认小顶堆 ， greater<int> --小顶堆  less<int> --大顶堆  
priority_queue<elemt,vector<elemt>,comp>q;
struct comp{
	public:
		bool operator()(elemt v1,elemt v2){
			return v1.v<v2.v;
		}
};
	set<int>::iterator it=st.begin();
*/
//emplace_back()  等于push_back(),但效率更高,传输pair时emplace_back(i,j)==push_back({i,j}) 
// vector<vector<int>>edge; 二维虚拟储存坐标 
//-----------------------------------------------------------------------------------------------------------------*/
  //map<int,bool>mp[N]; 
  //emplace_back() 
vector<pair<int,int>>edge[N];
vector<pair<int,int>>e_f[N];
int dis[N];//距离起点的最短路径
int vis[N];
ll n,m,k,p;
void add(int u,int v,int w){//建正向边求出dis
	edge[u].emplace_back(v,w);
}
void add_f(int u,int v,int w){//建反向边方便搜索路径
	e_f[v].emplace_back(u,w);
}
struct comp{
	bool operator()(pair<int,int> v1,pair<int,int> v2){
		return v1.first>v2.first;
	}
};
void djstl(int s){//求出各点到出发点的最短路长度
	for(int i=1;i<=n;i++){
		dis[i]=inf;
		vis[i]=0;
	}
	dis[s]=0;
	priority_queue<pair<int,int>,vector<pair<int,int>>,comp>q;
	q.push({0,s});
	while(q.size()){
		pair<int,int> f=q.top();
		q.pop();
		if(vis[f.second]){
			continue;
		}
		vis[f.second]=1;
		for(int i=0;i<edge[f.second].size();i++){
			pair<int,int >tmp=edge[f.second][i];	
			if(dis[f.second]+tmp.second<dis[tmp.first]){
				dis[tmp.first]=dis[f.second]+tmp.second;
				q.push({dis[tmp.first],tmp.first});
			}
		}	
	}
}
ll num[N][51];//记忆化
bool ind[N][51];//标记是否正在搜索路径中，判断是否有0环用
ll dfs(int x,int len){//当前搜搜的点 多走的长度
    ll res=0;
	if(len>k||len<0){
		return 0;//当前路径超出限制，直接返回
	}
	if(ind[x][len]){//路径中再次遍历到x并且经过路径为0，说明在可行路径中存在0环
		return -1;
	}
	if(num[x][len]!=-1){
		return num[x][len];//记忆化
	}
	ind[x][len]=true;//当前点放入路径中
	for(int i=0;i<e_f[x].size();i++){//这里是反边，从终点倒着往回搜索
		pair<int,int> tmp=e_f[x][i];
		ll v=dfs(tmp.first,len+dis[x]-dis[tmp.first]-tmp.second);//转移下一步多走的距离
		if(v==-1){//存在0环直接返回-1
			return -1;
		}
		res=(res+v)%p;
	}
	ind[x][len]=false;//从路径中抛出
	if(x==1&&len==0){
		res++;//找到最后的点，因为枚举的是多走len的情况，所以只有当len=0时才记录答案，否则会有重叠情况
	}
	return num[x][len]=res%p;
}
int main(){
/*cout<<setiosflags(ios::fixed)<<setprecision(8)<<ans<<endl;//输出ans（float）格式控制为8位小数（不含整数部分）*/
/*cout<<setprecision(8)<<ans<<endl;//输出ans（float）格式控制为8位小数（含整数部分）*/
	ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);//同步流
	int t;
	cin>>t;
	while(t--){
		cin>>n>>m>>k>>p;
		for(int i=1;i<=n;i++){//初始化
			edge[i].clear();
			e_f[i].clear();
			for(int j=0;j<=k;j++){
				num[i][j]=-1;
				ind[i][j]=false;
			}
		}
		for(int i=1;i<=m;i++){
			int u,v,w;
			cin>>u>>v>>w;
			add(u,v,w);
			add_f(u,v,w);
		}
		djstl(1);
		ll ans=0;
		for(int i=0;i<=k;i++){
			ll tmp=dfs(n,i);//枚举多走了i距离的方案数
			if(tmp==-1){//存在可遍历0环
				ans=-1;
				break;
			}
			ans=(ans+tmp)%p;
		}
		cout<<ans<<endl;
	}	
	return 0;
}