题解 过路费

传送门

首先发现对于最终构成答案的路径，将其边权排序后会是 \(\leqslant lim\) 的都不选
先一遍 dij 处理掉最终答案不满 \(k\) 条边的情况
接下来枚举这个 \(lim\)，分别跑一次二维 dij 更新答案
这样是 \(O(n^3\log n)\) 的

发现最短路关于 lim 单谷但有平台：也许可以退火？

然后考虑优化：
题解神仙思路.jpg
同样是先枚举第 \(k\) 大的边权 \(x\)，但是此时我们将所有边的边权都减去 \(x\)（并与 \(0\) 取 max）。
然后直接在这张图上跑 dij，把跑出的最短路 \(+kx\) 作为答案即可
正确性：
首先第 \(k\) 大恰好为 \(x\) 的路径肯定是可以正确统计的
接下来看看剩下的情况为什么不会算少
当第 \(k\) 大 \(>x\) 时，一些本来不会被计算的边（边权在 \(x\) 和第 \(k\) 大之间）被算了贡献
当第 \(k\) 大 \(<x\) 时，一些权值在第 \(k\) 大和 \(x\) 之间的边的权值被当成了 \(k\) 来算
综上，正确性得证
复杂度 \(O(nm\log m)\)

点击查看代码

#include <bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f3f3f3f3f
#define N 1010
#define fir first
#define sec second
#define pb push_back
#define ll long long
//#define int long long

char buf[1<<21], *p1=buf, *p2=buf;
#define getchar() (p1==p2&&(p2=(p1=buf)+fread(buf, 1, 1<<21, stdin)), p1==p2?EOF:*p1++)
inline int read() {
	int ans=0, f=1; char c=getchar();
	while (!isdigit(c)) {if (c=='-') f=-f; c=getchar();}
	while (isdigit(c)) {ans=(ans<<3)+(ans<<1)+(c^48); c=getchar();}
	return ans*f;
}

int n, m, k, s, t;
int head[N], ecnt;
struct edge{int to, next; ll val;}e[N<<1];
inline void add(int s, int t, ll w) {e[++ecnt]={t, head[s], w}; head[s]=ecnt;}

namespace force{
	bool vis[N];
	ll ans=INF;
	vector<vector<ll>> sta;
	void dfs(int u, vector<ll> tem) {
		if (u==t) {sta.pb(tem); return ;}
		vis[u]=1;
		for (int i=head[u],v; ~i; i=e[i].next) {
			v = e[i].to;
			if (vis[v]) continue;
			tem.pb(e[i].val);
			dfs(v, tem);
			tem.pop_back();
		}
		vis[u]=0;
	}
	void solve() {
		dfs(s, vector<ll>());
		for (auto v:sta) {
			sort(v.begin(), v.end(), [](ll a, ll b){return a>b;});
			ll sum=0;
			for (int i=0; i<min(k, (int)v.size()); ++i) sum+=v[i];
			ans=min(ans, sum);
		}
		cout<<ans<<endl;
	}
}

namespace dijkstra{
	bool vis[N];
	ll dis[N];
	priority_queue<pair<ll, int>> q;
	ll dij(int s, int t) {
		memset(dis, 0x3f, sizeof(dis));
		dis[s]=0; q.push({0, s});
		while (q.size()) {
			pair<ll, int> u=q.top(); q.pop();
			if (vis[u.sec]) continue;
			vis[u.sec]=1;
			for (int i=head[u.sec],v; ~i; i=e[i].next) {
				v = e[i].to;
				if (dis[u.sec]+e[i].val < dis[v]) {
					dis[v]=dis[u.sec]+e[i].val;
					q.push({-dis[v], v});
				}
			}
		}
		return dis[t];
	}
}

namespace task1{
	bool vis[N][N];
	ll dis[N][N], ans;
	priority_queue<pair<ll, pair<int, int>>> q;
	ll check(ll mid) {
		// cout<<"check: "<<mid<<endl;
		memset(dis, 0x3f, sizeof(dis));
		memset(vis, 0, sizeof(vis));
		dis[s][0]=0; q.push({0, {s, 0}});
		while (q.size()) {
			pair<int, int> u=q.top().sec; q.pop();
			if (vis[u.fir][u.sec]) continue;
			vis[u.fir][u.sec]=1;
			for (int i=head[u.fir],v; ~i; i=e[i].next) {
				v = e[i].to;
				if (e[i].val<=mid) {
					if (dis[u.fir][u.sec] < dis[v][u.sec]) {
						dis[v][u.sec]=dis[u.fir][u.sec];
						q.push({-dis[v][u.sec], {v, u.sec}});
					}
				}
				if (e[i].val>=mid) {
					if (u.sec+1<=k && dis[u.fir][u.sec]+e[i].val<dis[v][u.sec+1]) {
						dis[v][u.sec+1]=dis[u.fir][u.sec]+e[i].val;
						q.push({-dis[v][u.sec+1], {v, u.sec+1}});
					}
				}
			}
		}
		return dis[t][k];
	}
	void solve() {
		ans=dijkstra::dij(s, t);
		for (int i=1; i<=m; ++i) ans=min(ans, check(e[i].val));
		cout<<ans<<endl;
	}
}

signed main()
{
	freopen("fee.in", "r", stdin);
	freopen("fee.out", "w", stdout);

	n=read(); m=read(); k=read(); s=read(); t=read();
	memset(head, -1, sizeof(head));
	for (int i=1,u,v,w; i<=m; ++i) {
		u=read(); v=read(); w=read();
		add(u, v, w);
	}
	// force::solve();
	if (n<=200 && m<=300) task1::solve();
	else cout<<dijkstra::dij(s, t)<<endl;
	
	return 0;
}