【Noip模拟 20160929】花坛迷宫

题目描述

圣玛格丽特学园的一角有一个巨大、如迷宫般的花坛。大约有一个人这么高的大型花坛，做成迷宫的形状，深受中世纪贵族的喜爱。维多利加的小屋就坐落在这迷宫花坛的深处。某一天早晨，久城同学要穿过这巨大的迷宫花坛，去探望感冒的维多利加。

整个迷宫可以用N个路口与M条连接两个不同路口的无向通道来描述。路口被标号为1到N，每条通道有各自的长度。整个迷宫一定是连通的，迷宫中可能存在若干个环路，但是，出于美观考虑，每个路口最多只会属于一个简单环路。例如，图1所示的迷宫是非常美观的，但图2则不符合我们的描述，因为3号路口同属于两个简单环。

你需要回答多个这样的询问：假如久城处在路口x，维多利加的小屋处在路口y，久城最短需要走多少距离才能到达小屋？

输入数据

第一行2个整数N,M，表示迷宫花坛的路口数和通道数；

接下来M行，每行3个整数x,y,z，描述一条连接路口x与路口y，长度为z的通道；

再接下来1行包含一个整数Q，表示询问数量；

之后Q行，每行2个整数x,y，描述一个询问。

输出数据

对于每个询问输出一行一个整数，表示最短距离。

样例输入

样例输出

3

2

数据范围

对于30%30%的数据，N≤100N≤100；

另有30%30%的数据，保证N=MN=M；

对于100%100%的数据，1≤N≤100000，0≤Q≤200000，1≤x,y≤N，1≤z≤10001≤N≤100000，0≤Q≤200000，1≤x,y≤N，1≤z≤1000。

由于传题人比较懒，hack数据只需满足是一个仙人掌

题目分析

大家好，我是老A。我又回来了，我很不爽。我们维护这个图的强连通分量，因为SPFA会跑飞，我们用Tarjan算法，然后求LCA即可，这一题NOI第三题水平。我们可以用可持久化分块，也可以倍增树剖ST表。要是你想要用堆优化线段树，那你滚吧。

参考代码

我知道你们就等着看我的代码，那我只好给你看了。

#include<bits/stdc++.h>

using namespace std;

int n,m;

inline int abs(int x) {return x>?x:-x;}

int head[], next[], to[], tot=;

int scc=, dfn[],low[], DFN=;

vector<int> s[],son[];

int st[],stn=;

int fa[][],dep[],size[];

map<int,int> d[], f[];

int D[];

inline void add(int u, int v, int tw) {

    ++tot;

    next[tot]=head[u];

    head[u]=tot;

    to[tot]=v;

    if(f[u].find(v)==f[u].end())

        f[u][v]=tw;

    else f[u][v]=min(f[u][v], tw);

}

O2 inline int getdep(int x) {

    if(fa[x][]==) dep[x]=;

    if(dep[x]) return dep[x];

    return dep[x]=getdep(fa[x][])+;

}

inline void init() {

    memset(dep, , sizeof(dep));

    for (int i=; i<=; ++i) {

        for (int j=; j<=scc; ++j) fa[j][i] = fa[fa[j][i-]][i-];

        for (int j=n+; j<=n*; ++j) fa[j][i] = fa[fa[j][i-]][i-];

    }

    for (int i=; i<=scc; ++i) getdep(i);

    for (int i=n+; i<=n*; ++i) getdep(i);

}

int tx, ty;

O2 inline int lca(int x,int y)   {

    if(dep[x]<dep[y]) swap(x,y);

    for(int j=; j>=; --j)

        if(dep[fa[x][j]]>=dep[y]) x=fa[x][j];

    if(x==y) return x;

    for (int j=; j>=; --j)

        if(fa[x][j] != fa[y][j]) x=fa[x][j], y=fa[y][j];

    tx=x,ty=y;

    return fa[x][];

}

O2 inline void tarjan(int x) {

    low[x]=dfn[x]=++DFN;

    st[++stn]=x;

    for (int i=head[x]; i; i=next[i]) {

        if(dfn[to[i]] != ) {

            low[x] = min(low[x], dfn[to[i]]);

        }else{

            tarjan(to[i]);

            if(low[to[i]]==dfn[x]){

                ++scc;

                son[x].push_back(scc);

                s[scc].push_back(x);

                fa[scc][]=n+x;

                int t;

                do {

                    t=st[stn--];

                    s[scc].push_back(t);

                    fa[n+t][]=scc;

                } while(t != to[i]);

            }

            low[x] = min(low[x], low[to[i]]);

        }

    }

}

O2 inline void pre(int x) {

    vector<int>::iterator it,_it;

    stn=;

    for (int i=,sz=s[x].size(); i<sz; ++i) st[++stn]=s[x][i];

    st[++stn]=s[x][];

    for (int i=; i<stn; ++i) {

        size[x] += f[st[i]][st[i+]];

        if(i!=stn-) d[x][st[i+]]=d[x][st[i]]+f[st[i]][st[i+]];

    }int s1=, t=stn-;

    while(s1<=t) {

        if(D[st[s1-]]+f[st[s1-]][st[s1]]<D[st[t+]]+f[st[t+]][st[t]]){

            D[st[s1]]=D[st[s1-]]+f[st[s1-]][st[s1]];

            ++s1;

        } else {

            D[st[t]]=D[st[t+]]+f[st[t+]][st[t]];

            --t;

        }

    }

    for (it=s[x].begin(),it++; it!=s[x].end(); ++it)

        for (_it=son[*it].begin(); _it!=son[*it].end(); ++_it) pre(*_it);

}

char chh; int xx;

O2 inline int read() {

    chh=getchar();xx=;

    while(!isdigit(chh)) chh=getchar();

    while(isdigit(chh)) {

        xx=(xx<<)+(xx<<)+chh-'';

        chh=getchar();

    }

    return xx;

}

O2 int main() {

    n=read(), m=read();

    for (int i=, u, v, tw; i<=m; ++i) {

         u=read(), v=read(), tw=read();

         add(u, v, tw);

         add(v, u, tw);

    }

    tarjan(); init();

    vector<int>::iterator it;

    for(it=son[].begin();it!=son[].end();it++)

        pre(*it);

    int T=read();

    while(T--) {

        int x, y;

        x=read(), y=read();

        int LCA=lca(n+x,n+y);

        if(LCA>n) printf("%d\n", D[x]+D[y]-*D[LCA-n]);

        else {

            int ans = D[x]+D[y]-D[tx-n]-D[ty-n];

            int tmp = abs(d[LCA][tx-n]-d[LCA][ty-n]);

            ans+=min(tmp, size[LCA]-tmp);

            printf("%d\n", ans);

        }

    }

    return ;

}

代码分析

Tarjan不解释，我们用STL来记录这几个点，第一次知道map可以这样迭代。最后我们用vector跑LCA，输出的时候判断一下就好了。

PS：PS内容在下一期。。。