洛谷P2296 寻找道路 (反边+dijkstra+判联通)

本题还是很有意思的QAQ~
于是本蒟蒻花了半小时A掉了(雾)

首先题面传送门：洛谷P2296

首先题目照常给了起点、终点、权重，并带有重边、自环，并需要我们找一条从起点到终点的路径，

但很容易证得：重边和自环对求最短路没有影响，是本题不必要的

该路径满足：
条件①：路径上的所有点的出边所指向的点都直接或间接与终点连通。
条件②：在满足条件1的情况下使路径最短。

首先不考虑条件①的话，这道题就是裸的最短路~

直接交个最短路板子就能混10分(逃)

最短路有dijkstra(单源)、floyd(多源)、SPFA算法(已死)

但本题的数据范围：
对于30%的数据，0<n≤10，0<m≤20;

对于60%的数据，0<n≤100，0<m≤2000;

对于100%的数据，0<n≤10000,0<m≤200000

因此我们可以很容易发现，O(n3)的Floyd是肯定会跑炸的QAQ
(评测机一般只能跑不超过1e9的数据)

然后我们分析题面：条件①需要某条最短路上的点所指向的点也必须要与终点联通

举例来说：

该图中虽然1->2->5也是一条最短路，但点2所指向的6并不与我们规定的终点5联通，因此1->2->5虽是最短路，但并不是可行解

所以我们有一个结论：如果一个点u所指向的点v与终点不连通，那么走最短路时，点u则不在考虑范围内，也相当于把点u删去

那问题来了，我们怎样知道哪些点是不能走的呢？

我们可以很快的 想到 最短路上的点必然所有都与终点联通，因此我们只需要：

①找出与终点联通的点集P_link。
②判断该点是否指向与终点不连通的点集P_unlink：若有，则该点废弃(删点或者不走它)。
③在删点后的新图上，跑一遍最短路，即是我们想要的结果。

而P_link怎么找花了本蒟蒻10分钟才想出来
(注：这里如果能建立起一个完善的思维框架，想必无论是什么问题都能迎刃而解吧~)

其实我们只需要考虑建图的基本操作(设定问题的框架范围)：
①分层图
②建反边
③建超级源点和超级汇点等…

就很容易发现从终点建立图的反边(我们把反边构成的图设定为2号图)，然后在反图上，从终点来一遍dijkstra最短路，即可知道哪些点是与终点联通的(P_link)。

然后再从P_link内跑第二遍最短路，找到P_link内，指向P_unlink的点集Pi。

最后从起点进行第三次dijkstra的时候，不考虑Pi进去，跑最短路，即可得到答案~

完结撒花~

AC_code（虽然看着多但其实三个dijkstra都是套的模板，几乎只改动了一行，实际上很容易看懂的）:

如有不足之处，欢迎批评指正~

#include<bits/stdc++.h>
#define For(i,m,n) for(register int i=m;i<n;i++)
#define rFor(i,m,n) for(register int i=m;i>n;i--)
#define r(a) read(a)
#define rr(a,b) read(a),read(b)
#define rrr(a,b,c) read(a),read(b),read(c)
using namespace std;
typedef long long ll;
typedef unsigned long long Ull;
template <class T>
inline void read(T &x)
{
	x=0;
    T f=1;
    char ch=getchar();
	while (!isdigit(ch)){if (ch=='-') f=-1;ch=getchar();}
	while (isdigit(ch)){x=x*10+ch-48;ch=getchar();}
	x=x*f;
}
const int MaxN = 10010, MaxM = 5000010;
const int INF=1e9;
struct edge{
    int next;
    int to;
    int dis;
}e[MaxM],eR[MaxM];
int head[MaxN],head2[MaxN];
int res[MaxN];
int tot=0,tot2=0;
bool vis[MaxM];
int n,m,s,t;
int IsExist[MaxM];
int cntScc[MaxN];
bool flag=false;
bool IsNoContin[MaxN];
void add_edge(int from,int to,int dis)
{
    tot++;
    e[tot].next=head[from];
    e[tot].to=to;
    e[tot].dis=dis;
    head[from]=tot;
}

void add_edge2(int from,int to,int dis)
{
    tot2++;
    eR[tot2].next=head2[from];
    eR[tot2].to=to;
    eR[tot2].dis=dis;
    head2[from]=tot2;
}

struct node{
    int dis;
    int pos;
    int minn;
    int maxx;
};
struct cmp{
    bool operator()(node &n1,node &n2)
    {
        return n1.dis>n2.dis;
    }
};

priority_queue<node,vector<node>,cmp > Q;

void dijkstraR(int s)
{
    For(i,1,n+1)   res[i]=INF;
    memset(vis,0,sizeof(vis));
    res[s]=0;
    Q.push((node){0,s});//保证从开始结点出发不断更新
    while(Q.size()){
        node now=Q.top();
        Q.pop();
        int d=now.dis;
        int x=now.pos;
        if(vis[x])    continue;
        vis[x]=1;
        for(int i=head2[x];i;i=eR[i].next){
            int v=eR[i].to;
            if(res[v]>res[x]+eR[i].dis)
                res[v]=res[x]+eR[i].dis;
            if(!vis[v])   Q.push((node){res[v],v});//保证了从起始节点往下走
        }
    }
}

void dijkstra(int s)
{
    For(i,1,n+1)   res[i]=INF;
    memset(vis,0,sizeof(vis));
    res[s]=0;
    Q.push((node){0,s});//保证从开始结点出发不断更新
    while(Q.size()){
        node now=Q.top();
        Q.pop();
        int d=now.dis;
        int x=now.pos;
        if(vis[x])    continue;
        vis[x]=1;
        for(int i=head[x];i;i=e[i].next){
            int v=e[i].to;
            if(flag&&IsNoContin[v]) continue;
            if(res[v]>res[x]+e[i].dis)
                res[v]=res[x]+e[i].dis;
            if(!vis[v])   Q.push((node){res[v],v});//保证了从起始节点往下走
        }
    }
}

void dfs_testPointState(int s)
{
    For(i,1,n+1)   res[i]=INF;
    memset(vis,0,sizeof(vis));
    res[s]=0;
    Q.push((node){0,s});//保证从开始结点出发不断更新
    while(Q.size()){
        node now=Q.top();
        Q.pop();
        int d=now.dis;
        int x=now.pos;
        if(vis[x])    continue;
        vis[x]=1;
        for(int i=head[x];i;i=e[i].next){
            int v=e[i].to;
            if(cntScc[v]==0)   IsNoContin[x]=true;
            if(res[v]>res[x]+e[i].dis)
                res[v]=res[x]+e[i].dis;
            if(!vis[v])   Q.push((node){res[v],v});//保证了从起始节点往下走
        }
    }
}

int main()
{
    rr(n,m);
    For(i,1,m+1){
        int u,v;
        rr(u,v);
        if(u==v||IsExist[u]==v)    continue;//去重边，去自环
        IsExist[u]=v;
        add_edge(u,v,1);
        add_edge2(v,u,1);
    }
    memset(IsExist,0,sizeof(IsExist));
    rr(s,t);
    int s2,t2;
    s2=t,t2=s;
    dijkstraR(s2);
    For(i,1,n+1){
        if(res[i]!=INF) cntScc[i]=1;//可联通
    }
    if(cntScc[1]==0){
        cout<<-1;
        return 0;
    }
    flag=true;
    dfs_testPointState(s);
    dijkstra(s);
    cout<<res[t];
    return 0;
}

/*
如果在不连通点集内，则跳过其做dijkstra

*/