P5304 [GXOI/GZOI2019]旅行者
总的思路
要求给定的二元点对中距离最小的那个
非常神奇的思路，我不会。。。
可以建立超级源点，与所有给定点连权值为1的边，把多个源点的最短路缩短为一个源点的最短路，这样，复杂度可以大大降低。
从超级源点开始跑正反两次，同时染色，颜色是给定点的编号，当为最短路是标号。
最后枚举边数，两个顶点的颜色不一，更新答案。
考虑答案中的最短路径（假设从v到u），一定有一条边的两端颜色不一样，因为这条路径一定存在且仅存在两个颜色，那就是v和u，两者不能互相染色。
一开始写的没考虑清楚的次短路
#include <bits/stdc++.h>
using namespace std;
struct node
{
int d,w;
bool operator < (const node &y)const
{
return w > y.w;
}
};
int n,m,k;
int lik[100001],vis[100001];
int Fdisf[100001],Rdisf[100001],Fdiss[100001],Rdiss[100001];
int Foriginf[100001],Roriginf[100001],Forigins[100001],Rorigins[100001];
vector <node> Fe[100001],Re[100001];
int ans;
void update(int u,int v,int orf[],int ors[],int diss[],int d)
{
if(!orf[u])orf[u] = v;//没有过
else //到达过，要更新
{
if(orf[u] == v)return ;//重合了，不需要
else
{
ors[u] = orf[u];
orf[u] = v;//向下推
diss[u] =
}
}
}
void dij(int disf[],int diss[],vector <node> e[],int originf[],int origins[])
{
memset(disf,0x3f,sizeof(disf));
memset(vis,0,sizeof(vis));
priority_queue <node> q;
q.push(node{0,0});
while(!q.empty())
{
node v = q.top();
q.pop();
if(vis[v.d])continue;
vis[v.d] = 1;
for (int i = 0; i < e[v.d].size(); i++)
{
node u = e[v.d][i];
if(!vis[u.d] && disf[u.d] > disf[v.d] + u.w)
{
disf[u.d] = disf[v.d] + u.w;
q.push(node{u.d,disf[u.d]});
}
if(v.d == 0)originf[u.d] = u.d;
else update(u.d,originf[v.d],originf,origins,diss);
}
}
}
int main()
{
cin >> n >> m >> k;
int a,b,c;
for (int i = 1; i <= m; i++)
{
cin >> a >> b >> c;
Fe[a].push_back(node{b,c}),Re[b].push_back(node{a,c});
}
for (int i = 1; i <= k; i++)
{
cin >> lik[i];
}
for (int i = 1; i <= k; i++)
{
Re[ lik[i] ].push_back(node{0,0}),Fe[ lik[i] ].push_back(node{0,0});//super source
}
dij(Fdis,Fe,Foriginf,Forigins);
dij(Rdis,Re,Roriginf,Rorigins);
for (int i = 1; i <= n; i++)//起始点
{
for (int j = 0; j < Fe[i].size(); j++)
{
int u = Fe[i][j].d;//到达的点
if(Foriginf[i] && Roriginf[u])//可以到达
{
if(Foriginf[i] == Roriginf[u])//最短路连接同一个点，此状态是不需要的
{
if(Forigins[i])ans = min(ans,Fdis[i] + Rdis[u] + Fe[i][j].w);//存在次短路
if(Rorigins[u])ans = min(ans,Fdis[i] + Rdis[u] + Fe[i][j].w);
}
}
}
}
return 0;
}
这就是没想到最短路径颜色一定不一的时候写的，非常麻烦，还没写对。
正解
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
struct node
{
int d;
ll w;
bool operator < (const node &y)const
{
return w > y.w;
}
};
int n,m,k;
int lik[100001],vis[100001];
ll Fdis[100001],Rdis[100001];
int Forigin[100001],Rorigin[100001];//color
vector <node> Fe[100001],Re[100001];
ll ans;
int T;
void dij(ll dis[],vector <node> e[],int origin[])
{
memset(vis,0,sizeof(vis));
priority_queue <node> q;
q.push(node{0,0});
dis[0] = 0;
while(!q.empty())
{
node v = q.top();
q.pop();
if(vis[v.d])continue;
vis[v.d] = 1;
for (int i = 0; i < e[v.d].size(); i++)
{
node u = e[v.d][i];
if(!vis[u.d] && dis[u.d] > dis[v.d] + u.w)
{
dis[u.d] = dis[v.d] + u.w;
origin[u.d] = origin[v.d];
q.push(node{u.d,dis[u.d]});
}
if(v.d == 0)origin[u.d] = u.d;
}
}
}
void work()
{
memset(Forigin,0,sizeof(Forigin));
memset(Rorigin,0,sizeof(Rorigin));
cin >> n >> m >> k;
int a,b;
ll c;
for (int i = 1; i <= m; i++)
{
cin >> a >> b >> c;
if(a == b)continue;
Fe[a].push_back(node{b,c}),Re[b].push_back(node{a,c});
}
for (int i = 1; i <= k; i++)
{
cin >> lik[i];
}
for (int i = 1; i <= k; i++)
{
Re[ 0 ].push_back(node{lik[i],0}),Fe[ 0 ].push_back(node{lik[i],0});//super source
}
memset(Fdis,0x3f,sizeof(Fdis));
dij(Fdis,Fe,Forigin);
memset(Rdis,0x3f,sizeof(Rdis));
ans = Rdis[0];
dij(Rdis,Re,Rorigin);
for (int i = 1; i <= n; i++)//起始点
{
for (int j = 0; j < Fe[i].size(); j++)
{
int u = Fe[i][j].d;//到达的点
if(Forigin[i] && Rorigin[u] && Forigin[i] != Rorigin[u])//可以到达
{
ans = min(ans,Fdis[i] + Fe[i][j].w + Rdis[u]);
}
}
Fe[i].clear(),Re[i].clear();
}
Fe[0].clear(),Re[0].clear();
cout << ans << endl;
}
int main()
{
cin >> T;
while(T--)work();
return 0;
}
注意：
建立超级源点
染色关系在边上体现
一个错误的初始化方式
void dij(ll dis[],vector <node> e[],int origin[])
{
memset(dis,0x3f,sizeof(dis));
ans = 1000000000000;
memset(vis,0,sizeof(vis));
priority_queue <node> q;
q.push(node{0,0});
dis[0] = 0;
while(!q.empty())
{
node v = q.top();
q.pop();
if(vis[v.d])continue;
vis[v.d] = 1;
for (int i = 0; i < e[v.d].size(); i++)
{
node u = e[v.d][i];
if(!vis[u.d] && dis[u.d] > dis[v.d] + u.w)
{
dis[u.d] = dis[v.d] + u.w;
origin[u.d] = origin[v.d];
q.push(node{u.d,dis[u.d]});
}
if(v.d == 0)origin[u.d] = u.d;
}
}
}
这里面第一个memset中的dis只是传了地址，原来是Fdis或Rdis，这样memset是错误的，原因猜想：不能间接使用sizeof()，真正的原因有待研究
关于官方题解
https://www.luogu.com.cn/blog/xht37/p5304-gxoigzoi2019-lv-xing-zhe
虽然官方题解比较慢，但仍是值得学习的
这里是多次将给定点分成两组，按点的序号的二进制位第i为来分，这样最多log(n)，就能把答案中的点对分别分到不同的组，建立超级源点向两边连有向边，再跑两次，dijkstra
浙公网安备 33010602011771号