洛谷 P2149 [SDOI2009]Elaxia的路线 Dijkstra+拓扑排序求DAG最长路

https://www.luogu.org/problem/P2149
题目描述
最近，Elaxia和w的关系特别好，他们很想整天在一起，但是大学的学习太紧张了，他们 必须合理地安排两个人在一起的时间。
Elaxia和w每天都要奔波于宿舍和实验室之间，他们 希望在节约时间的前提下，一起走的时间尽可能的长。
现在已知的是Elaxia和w所在的宿舍和实验室的编号以及学校的地图：地图上有N个路 口，M条路，经过每条路都需要一定的时间。 具体地说，就是要求无向图中，两对点间最短路的最长公共路径。
输入格式
第一行：两个整数N和M（含义如题目描述）。
第二行：四个整数x1、y1、x2、y2（1 ≤ x1 ≤ N，1 ≤ y1 ≤ N，1 ≤ x2 ≤ N，1 ≤ y2 ≤ N），分别表示Elaxia的宿舍和实验室及w的宿舍和实验室的标号（两对点分别 x1,y1和x2,y2）。
接下来M行：每行三个整数，u、v、l（1 ≤ u ≤ N，1 ≤ v ≤ N，1 ≤ l ≤ 10000），表 u和v之间有一条路，经过这条路所需要的时间为l。
输出格式
一行，一个整数，表示每天两人在一起的时间（即最长公共路径的长度）

思路：最长公共路径一定是一条链，可以计算出$Elaxia$到实验室的最短路经过的有向边组成的$DA{G}_1$，再计算出$w$到实验室的最短路经过的有向边组成的$DA{G}_2$，那么答案就是$DA{G}_1$和$DA{G}_2$的公共部分的最长链。但是还需要注意一个细节，就是并行和相遇都算公共，然而两个$DAG$的公共部分是不可能既存在并行(同向)又存在相遇(反向)的，因此我们需要分两种情况计算，具体见代码。样例如下图所示：

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define pr pair<int,int>
using namespace std;
typedef long long ll;

const int maxn=1505;

struct Edge
{
    int to,nxt,dis;
};

Edge edge1[maxn*maxn],edge2[maxn*maxn];
bool vis[maxn];
int head1[maxn],head2[maxn];
int ind[maxn],dp[maxn],Stack[maxn];
int dis[5][maxn];
int n,m,tot1,tot2,s1,e1,s2,e2;

inline void addedge1(int u,int v,int dis)
{
    edge1[++tot1].to=v,edge1[tot1].nxt=head1[u],edge1[tot1].dis=dis,head1[u]=tot1;
}

inline void addedge2(int u,int v,int dis)
{
    edge2[++tot2].to=v,edge2[tot2].nxt=head2[u],edge2[tot2].dis=dis,head2[u]=tot2,++ind[v];
}

void dijkstra(int op,int s)
{
    memset(dis[op],INF,sizeof(dis[op]));
    memset(vis,0,sizeof(vis));
    dis[op][s]=0;
    priority_queue<pr,vector<pr>,greater<pr> > q;
    q.push(pr(0,s));
    while(!q.empty())
    {
        pr p=q.top();
        q.pop();
        if(vis[p.second])
            continue;
        vis[p.second]=1;
        for(int i=head1[p.second];i;i=edge1[i].nxt)
        {
            int to=edge1[i].to;
            if(dis[op][to]>dis[op][p.second]+edge1[i].dis)
            {
                dis[op][to]=dis[op][p.second]+edge1[i].dis;
                q.push(pr(dis[op][to],to));
            }
        }
    }
}

int topo()
{
    int top=0,ans=0;
    for(int i=1;i<=n;i++)
        if(!ind[i])
            Stack[++top]=i;
    while(top)
    {
        int u=Stack[top--];
        ans=max(ans,dp[u]);
        for(int i=head2[u];i;i=edge2[i].nxt)
        {
            int v=edge2[i].to;
            dp[v]=max(dp[v],dp[u]+edge2[i].dis);
            if(--ind[v]==0)
                Stack[++top]=v;
        }
    }
    return ans;
}

int main()
{
    scanf("%d %d",&n,&m);
    scanf("%d %d %d %d",&s1,&e1,&s2,&e2);
    int u,v,d;
    for(int i=0;i<m;i++)
    {
        scanf("%d %d %d",&u,&v,&d);
        addedge1(u,v,d),addedge1(v,u,d);
    }
    dijkstra(1,s1);
    dijkstra(2,e1);
    dijkstra(3,s2);
    dijkstra(4,e2);
    for(int i=1;i<=n;i++)
    {
        for(int j=head1[i];j;j=edge1[j].nxt)//并行
        {
            int to=edge1[j].to;
            if(dis[1][i]+edge1[j].dis+dis[2][to]==dis[1][e1]&&dis[3][i]+edge1[j].dis+dis[4][to]==dis[3][e2])
                addedge2(i,to,edge1[j].dis);
        }
    }
    int ans=topo();
    memset(head2,0,sizeof(head2));
    memset(ind,0,sizeof(ind));
    memset(dp,0,sizeof(dp));
    tot2=0;
    for(int i=1;i<=n;i++)
    {
        for(int j=head1[i];j;j=edge1[j].nxt)//相遇
        {
            int to=edge1[j].to;
            if(dis[1][i]+edge1[j].dis+dis[2][to]==dis[1][e1]&&dis[4][i]+edge1[j].dis+dis[3][to]==dis[3][e2])
                addedge2(i,to,edge1[j].dis);
        }
    }
    ans=max(ans,topo());
    printf("%d\n",ans);
    return 0;
}