BZOJ 2725: [Violet 6]故乡的梦 最短路+线段树

2725: [Violet 6]故乡的梦

Time Limit: 20 Sec  Memory Limit: 128 MB
Submit: 678  Solved: 204
[Submit][Status][Discuss]

Description

Input

Output

Sample Input

6 7
1 2 1
2 3 1
3 4 2
4 5 1
5 6 1
1 3 3
4 6 3
1 6
4
1 2
1 3
4 3
6 5

Sample Output

7
6
Infinity
7

HINT

Source

interviewstreet--Going office

想法：

先跑出一条最短路径(S,T)，如果没删除上面的边就直接输出最短路。

如果枚举一条边(x,y)，那么最短路一定能被(S-x)+(x,y)+(y,T)表示出来。所以如果要删(u,v)，那就要枚举一条边(x,y),要求dis(x)<=dis(u)&&dis(y)>=dis(v)，这样就保证(S,x),(y,T)不经过(u,v)了。于是按dis()顺序枚举(S,T)路径上的边，用线段树维护合法的最小值。

当然如果是有向图，就不能只用dis(x)<=dis(u)&&dis(y)>=dis(v)来限制不经过这条边了。

#include<cstdio>
#include<algorithm>

typedef long long ll;
const int len(),lem();
const ll INF(0x7fffffffffffffff);
struct Node{int nd,nx,co;}bot[lem*+];int tot=,first[len+];
int flag[len+],last[len+],tmp[len+],Fr[len+],To[len+];
ll dis[len+],Go[len+],Bk[len+],ans[len+];
struct Data{int num;ll dis;}h[lem*+];int top;
struct ABC{int a,b,pos;ll c;}Edge[lem*+];
int n,m,x,y,c,S,T,Q;

ll min(ll a,ll b){return a>b?b:a;}
bool cmp(Data A,Data B){return A.dis>B.dis;}
bool cmp2(ABC A,ABC B){return Go[A.a]<Go[B.a];}
void swap(int &a,int &b){if(a==b)return;a^=b;b^=a;a^=b;}
void add(int a,int b,int c){bot[++tot]=(Node){b,first[a],c};first[a]=tot;}
template <class T>void read(T &x)
{
    x=;int f=;char c=getchar();
    while((c<''||c>'')&&c!='-')c=getchar(); if(c=='-')f=,c=getchar();
    while(c>=''&&c<=''){x=x*+c-'';c=getchar();}
    x=f?-x:x;
}
struct MAP
{
    ll axle[len*+]; int up;
    void ins(ll x){axle[++up]=x;}
    void deal()
    {
        std::sort(axle+,axle++up);
        int _up=;//偷懒专用变量命名
        for(int i=;i<=up;i++)if(axle[i]!=axle[i-])axle[++_up]=axle[i];
        up=_up;
    }
    int two(ll x)
    {
        int num=up;
        for(int mid,l=,r=up;l<=r;)(axle[mid=(l+r)>>]<=x)?num=mid,l=mid+:r=mid-;
        return num;
    }
}Map;
struct SMT
{
    int nx[lem*+][],K,stot; ll small[lem*+];
    void build(int &k,int L,int R)
    {
        k=++stot; small[k]=INF;
        if(L==R)return; int MID=(L+R)>>;
        build(nx[k][],L,MID),build(nx[k][],MID+,R);
    }
    void change(int k,int L,int R,int x,ll y)
    {
        small[k]=min(small[k],y);    if(L==R)return;    int MID=(L+R)>>;
        (x<=MID)?change(nx[k][],L,MID,x,y):change(nx[k][],MID+,R,x,y);
    }
    ll query(int k,int L,int R,int x)
    {
        if(L==x)return small[k]; int MID=(L+R)>>;
        return (x>MID)?query(nx[k][],MID+,R,x):
        min(small[nx[k][]],query(nx[k][],L,MID,x));
    }
}tree;

int dfs(int x)
{
    if(tmp[x])return tmp[x]; if(flag[x])return x;
    tmp[last[x]]=dfs(last[x]);
    return tmp[last[x]];
}
void Dij(int s,int t,int ty)
{
    for(int i=;i<=n;i++)dis[i]=INF; dis[s]=;
    h[top=]=(Data){s,}; Data now;
    while(top)
    {
        now=h[],std::pop_heap(h+,h++top,cmp),top--;
        while(dis[now.num]!=now.dis&&top)now=h[],std::pop_heap(h+,h++top,cmp),top--;
        if(dis[now.num]!=now.dis&&!top)break;
        for(int v=first[now.num];v;v=bot[v].nx)
        if(dis[bot[v].nd]>now.dis+bot[v].co)
        {
            dis[bot[v].nd]=now.dis+bot[v].co;
            last[bot[v].nd]=now.num;
            h[++top]=(Data){bot[v].nd,dis[bot[v].nd]};
            std::push_heap(h+,h++top,cmp);
        }
    }
    if(ty==)
        for(int v=t;v;v=last[v])flag[v]=;
    if(ty==)
        for(int i=;i<=n;i++)
        if(dis[i]!=INF)tmp[i]=dfs(i);//O(n)
}//O(mlogm)
void Get()
{
    int x=S,Ei=;
    while(x!=T)
    {
        if(!flag[x])break;flag[x]=;
        for(int v=first[x];v;v=bot[v].nx)
        if(flag[bot[v].nd]&&Go[x]+bot[v].co==Go[bot[v].nd])
        {
            while(Go[Edge[Ei].a]<=Go[x]&&Ei<=tot)
            {
                if((Edge[Ei].pos^)!=v&&Edge[Ei].pos!=v&&(Edge[Ei].pos^)!=Edge[Ei-].pos)
                tree.change(tree.K,,Map.up,Map.two(Go[Edge[Ei].b]),Edge[Ei].c);
                Ei++;
            }
            ans[bot[v].nd]=tree.query(tree.K,,Map.up,Map.two(Go[bot[v].nd]));
            if(ans[bot[v].nd]==INF)ans[bot[v].nd]=-;
            last[bot[v].nd]=x;     x=bot[v].nd;
            break;
        }
    }
}//O(m+nlogn)
int main()
{
//    freopen("C.in","r",stdin);
//    freopen("C.out","w",stdout);
    read(n);read(m);
    for(int i=;i<=m;i++)
    {
        read(x),read(y),read(c);
        add(x,y,c),add(y,x,c);
    }
    read(S),read(T);
    Dij(S,T,);flag[]=;
    if(dis[T]!=INF)Dij(S,T,);for(int i=;i<=n;i++)Fr[i]=tmp[i],Go[i]=dis[i],tmp[i]=;
    if(dis[T]!=INF)Dij(T,S,);for(int i=;i<=n;i++)To[i]=tmp[i],Bk[i]=dis[i],tmp[i]=;
    for(int i=;i<=n;i++)
        for(int v=first[i];v;v=bot[v].nx)
        {
            Edge[v]=(ABC){i,bot[v].nd,v,};
            if(Go[Edge[v].a]>Go[Edge[v].b])swap(Edge[v].a,Edge[v].b);
//            if(Go[Edge[v].a]!=INF&&Bk[Edge[v].b]!=INF)
            Edge[v].c=Go[Edge[v].a]+Bk[Edge[v].b]+bot[v].co;
            Edge[v].a=Fr[i]; Edge[v].b=To[bot[v].nd];
            if(Go[Edge[v].a]>Go[Edge[v].b])swap(Edge[v].a,Edge[v].b);
//            else Edge[v].c=INF;
        }
    std::sort(Edge+,Edge++tot,cmp2);
    for(int i=;i<=n;i++)Map.ins(Go[i]); Map.deal();
    tree.build(tree.K,,Map.up);
    for(int i=;i<=n;i++)last[i]=;
    Get();
    if(Go[T]==INF)Go[T]=-;
    read(Q);
    for(int i=;i<=Q;i++)
    {
        read(x),read(y);
        if(last[x]==y)swap(x,y);
        ll sum=(last[y]==x)?ans[y]:Go[T];
        if(sum==-)printf("Infinity\n");else printf("%lld\n",sum);
    }
    return ;
}