思路:
因为每个打卡点都要去一遍,每个打卡点一定是从家到这,再从这到家,中间不能碰其他打卡点,所以对每个打卡点,我们都是贪心地跑最短路过去,再跑一个回来的最短路。
但是 n log n n\log n nlogn 级别的算法只有单源最短路,从每个打卡点回来都要跑一个最短路肯定超时。考虑到 其实把回来的路径上的边方向都翻一下的话,就变成了从家到打卡点的路径了。那么我们找回来的最短路,可以把所有边的方向翻一下,然后再跑一个到打卡点的最短路就行了。
因此这个题先正着跑一边最短路,把距离加起来,再反着跑一遍,再把距离加起来就好了。
code:
#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;
const int maxn=1e6+5;
const int inf=1e9;
int n,m,d[maxn];
struct EDGE{
int u,v,w;
}E[maxn];
int head[maxn],ent;
struct edge{
int v,w,nxt;
}e[maxn];
void add(int u,int v,int w){
e[++ent]={v,w,head[u]};
head[u]=ent;
}
void init(){
for(int i=1;i<=n;i++)d[i]=inf,head[i]=0;
d[1]=ent=0;
}
void dijkstra(){
struct node{
int val,id;
node(int val=0,int id=0):val(val),id(id){};
bool operator<(const node x)const{return val>x.val;}
};
priority_queue<node> heap;
heap.push(node(0,1));
while(!heap.empty()){
auto [val,u]=heap.top();
heap.pop();
if(val<d[u])continue;
for(int i=head[u],v,w;i;i=e[i].nxt){
v=e[i].v;w=e[i].w;
if(d[u]+w<d[v]){
d[v]=d[u]+w;
heap.push(node(d[v],v));
}
}
}
return;
}
int main(){
cin>>n>>m;
init();
for(int i=1;i<=m;i++){
auto &[u,v,w]=E[i];
cin>>u>>v>>w;
add(u,v,w);
}
int ans=0;
dijkstra();
for(int i=1;i<=n;i++)ans+=d[i];
init();
for(auto [u,v,w]:E)add(v,u,w);
dijkstra();
for(int i=1;i<=n;i++)ans+=d[i];
cout<<ans<<endl;
return 0;
}