[bzoj4144]Petrol——最小生成树+最短路

题目大意：

给定一个n个点、m条边的带权无向图，其中有s个点是加油站。
每辆车都有一个油量上限b，即每次行走距离不能超过b，但在加油站可以补满。
q次询问，每次给出x,y,b，表示出发点是x，终点是y，油量上限为b，且保证x点和y点都是加油站，请回答能否从x走到y。

思路：

不难发现如果要顺利地完成旅程，一定是从一个加油站跑到另外一个加油站去，并且任意两个加油站之间地距离不可以超过b。
于是便转化成了这样一个问题：加油站为关键点，求一条路径使得两两关键点之间地路径长度的最大值最小
这个时候最小生成树的性质便起到了作用，将两两加油站之间的最短距离计算出来，并且只对关键点求解最小生成树，生成树上的路径一定是最优方案，具体地证明可以参照Kruskal算法的运行过程。
显然关键点的个数太多了，如果我们两两关键点之间求解最短路会T。。
此时就要考虑最小生成树的性质，最大化地减少连接无用的边。
考虑关键点s到关键点t的路径，若它们中途经过了另外一个关键点u，那么\(s->u,u->t\)一定会更优。
如果s到t的路径可以被\(s->a1,a1->a2...an->t,\)这样的路径所取代，并且其中任意一条路径的长度均小于\(s->t\)，那么\(s->t\)还是不要选择的好。
于是我们可以对于每一个点求出离它最近的关键点，记为f[u]，如果一条边(u,v)的f[u],f[v]不同，那么则将(f[u],f[v])加入候选边。
如果一条关键点之间的路径不可以被上述方法得到，那么它肯定不能加入最小生成树中，即不满足上面的几个条件。
即这条不符合条件的路径，要么路径中有其它的关键点，要么可以被一条其它的路径取代。
具体地实现可以将所有关键点加入堆中跑Djkstra，然后对于所有询问离线即可。

#include<bits/stdc++.h>

#define REP(i,a,b) for(int i=a,i##_end_=b;i<=i##_end_;++i)
#define DREP(i,a,b) for(int i=a,i##_end_=b;i>=i##_end_;--i)
#define debug(x) cout<<#x<<"="<<x<<endl
#define pii pair<ll,int>
#define fi first
#define se second
#define mk make_pair
typedef long long ll;

using namespace std;

void File(){
    freopen("bzoj4144.in","r",stdin);
    freopen("bzoj4144.out","w",stdout);
}

template<typename T>void read(T &_){
    T __=0,mul=1; char ch=getchar();
    while(!isdigit(ch)){
        if(ch=='-')mul=-1;
        ch=getchar();
    }
    while(isdigit(ch))__=(__<<1)+(__<<3)+(ch^'0'),ch=getchar();
    _=__*mul;
}

const int maxn=2e5+10;
int n,s,m,tot;
int beg[maxn],to[maxn<<1],las[maxn<<1],cnte=1,fr[maxn];
ll dis[maxn],w[maxn<<1];
bool ans[maxn];
priority_queue< pii,vector<pii>,greater<pii> >qu;

void add(int u,int v,ll val){
    las[++cnte]=beg[u]; beg[u]=cnte; to[cnte]=v; w[cnte]=val;
    las[++cnte]=beg[v]; beg[v]=cnte; to[cnte]=u; w[cnte]=val;
}

struct Edge{
    int u,v;
    ll len;
    int id;
    bool operator < (const Edge & tt) const {
        return len<tt.len;
    }
}E[maxn],Q[maxn];

void Dijkstra(){
    while(!qu.empty()){
        int u=qu.top().se; ll d=qu.top().fi;
        qu.pop();
        if(d!=dis[u])continue;
        for(int i=beg[u];i;i=las[i]){
            int v=to[i];
            if(d+w[i]<dis[v]){
                fr[v]=fr[u];
                dis[v]=d+w[i];
                qu.push(mk(dis[v],v));
            }
        }
    }
}

int q,fa[maxn];
int find(int x){return fa[x]==x ? x : fa[x]=find(fa[x]);}

void Kruskal(){
    for(int i=2;i<=cnte;i+=2)
        if(fr[to[i]]!=fr[to[i^1]])
            E[++tot]=(Edge){fr[to[i]],fr[to[i^1]],dis[to[i]]+dis[to[i^1]]+w[i],0};
    sort(E+1,E+tot+1);
    REP(i,1,n)fa[i]=i;
    read(q);
    REP(i,1,q)read(Q[i].u),read(Q[i].v),read(Q[i].len),Q[i].id=i;
    sort(Q+1,Q+q+1);
    int p=0;
    REP(i,1,q){
        while(p<tot && E[p+1].len<=Q[i].len){
            ++p;
            fa[find(E[p].u)]=find(E[p].v);
        }
        ans[Q[i].id]=(find(Q[i].u)==find(Q[i].v));
    }
    REP(i,1,q)if(ans[i])puts("TAK");
    else puts("NIE");
}

void init(){
    read(n); read(s); read(m);
    memset(dis,63,sizeof(dis));
    int u,v; ll val;
    REP(i,1,s)read(u),qu.push(mk(0,u)),dis[u]=0,fr[u]=u;
    REP(i,1,m)read(u),read(v),read(val),add(u,v,val);
    Dijkstra();
}

int main(){
    File();
    init();
    Dijkstra();
    Kruskal();
    return 0;
}

转载于:https://www.cnblogs.com/ylsoi/p/9861110.html