HDU5669-Road

题意

给一个\(n\)个点的图，标号为\(1\)到\(n\)，进行\(m\)次连边\((a,b,c,d,w)\)：

for i in range[a,b]:
    for j in range[c,d]:
        add_edge(i,j,w)

有\(K\)次机会可以消除一条边的权值（即走过但不算），问\(1\)到\(n\)的最短路。

\(n\le 5\times 10^4,m\le 10^4,0\le K\le 10,w\le 10^3\)

分析

\(K\)次消除机会用一个类似dp的东西处理（也被叫做分层图最短路），\(d[i][j]\)表示从1走到\(i\)点用了\(j\)次机会的最短路，显然这个东西是可以dp的。现在我们只需要考虑如何求最短路。

这个连边方式是区间对区间连同一种边，跟bzoj3218的可持久化线段树维护网络流的连边有点像。考虑线段树。

一个区间可以表示为线段树上的最多\(\log n\)个节点。我们一开始给线段树编号，用它来维护连边不就好啦！

一开始是这样想的，但其实只开一颗线段树是不对的，因为无法上下走，于是取看题解。

我们有两颗线段树，一颗连出去，一颗连入，分别称为出线段树和入线段树。出线段树的子节点连到父亲，入线段树的父亲连到子节点。然而如果只是这样的话，我们只能走一条边——从入线段树的某个点走到出线段树的点之后就回不来了！

所以我们把入线段树的每个点连到出线段树的相同位置的点即可。

每次连边是否需要\(\log ^2n\)条边呢？其实不需要，我们可以对每次连边建一个中间节点，出入线段树分别连出，从这个点连入即可。

这样总点数是\(4n+m\)，总边数最大为\(2m\log n+6n\)，所以使用优先队列优化Dijkstra求最短路，总复杂度为\(O(Km\log ^2n)\) 。

这题学习了两个线段树维护出入以及中间节点减少边数的方法（可能还有分层图最短路吧）。

代码

#include<cstdio>
#include<cctype>
#include<cstring>
#include<queue>
#include<utility>
#include<algorithm>
using namespace std;
int read() {
    int x=0,f=1;
    char c=getchar();
    for (;!isdigit(c);c=getchar()) if (c=='-') f=-1;
    for (;isdigit(c);c=getchar()) x=x*10+c-'0';
    return x*f;
}
const int maxn=5e4+1;
const int maxm=1e4+1;
const int maxp=4e5+1;
const int maxe=2e6+1;
const int maxk=11;
int n,m,k,ids=0,d[maxk][maxp],inf;
typedef pair<int,pair<int,int> > data;
inline int Min(int &x,int y) {x=min(x,y);}
priority_queue<data,vector<data>,greater<data> > q;
struct Graph {
    struct edge {
        int v,w,nxt;
    } e[maxe];
    int h[maxp],tot;
    Graph ():tot(0) {}
    void add(int u,int v,int w) {
        e[++tot]=(edge){v,w,h[u]};
        h[u]=tot;
    }
    void dj(int S,int T) {
        d[0][S]=0;
        q.push(make_pair(0,make_pair(S,0)));
        while (!q.empty()) {
            data dat=q.top();
            q.pop();
            int x=dat.second.first,tim=dat.second.second;
            for (int i=h[x],v=e[i].v;i;i=e[i].nxt,v=e[i].v) {
                if (tim<k && d[tim+1][v]>d[tim][x]) {
                    d[tim+1][v]=d[tim][x];
                    q.push(make_pair(d[tim+1][v],make_pair(v,tim+1)));
                }
                if (d[tim][v]>d[tim][x]+e[i].w) {
                    d[tim][v]=d[tim][x]+e[i].w;
                    q.push(make_pair(d[tim][v],make_pair(v,tim)));
                }
            }
        }
    }
} G;
struct SGT {
    int id[maxn<<2];
    void build(int x,int l,int r,bool op) {
        id[x]=++ids;
        if (l==r) return;
        int mid=(l+r)>>1;
        build(x<<1,l,mid,op),build(x<<1|1,mid+1,r,op);
        op?(G.add(id[x],id[x<<1],0),G.add(id[x],id[x<<1|1],0)):(G.add(id[x<<1],id[x],0),G.add(id[x<<1|1],id[x],0));
    }
    void link(int x,int L,int R,int l,int r,int p,int w,bool op) {
        if (L==l && R==r) {
            op?G.add(p,id[x],w):G.add(id[x],p,w);
            return;
        }
        int mid=(L+R)>>1;
        if (r<=mid) link(x<<1,L,mid,l,r,p,w,op); else 
        if (l>mid) link(x<<1|1,mid+1,R,l,r,p,w,op); else 
        link(x<<1,L,mid,l,mid,p,w,op),link(x<<1|1,mid+1,R,mid+1,r,p,w,op);
    }
    int ID(int x,int l,int r,int p) {
        if (l==r) return id[x];
        int mid=(l+r)>>1;
        return p<=mid?ID(x<<1,l,mid,p):ID(x<<1|1,mid+1,r,p);
    }
} a,b;
int main() {
#ifndef ONLINE_JUDGE
    freopen("test.in","r",stdin);
#endif
    read(),n=read(),m=read(),k=read();
    a.build(1,1,n,false);
    int tmp=ids;
    b.build(1,1,n,true);
    for (int i=1;i<=tmp;++i) G.add(tmp+i,i,0);
    while (m--) {
        int l1=read(),r1=read(),l2=read(),r2=read(),w=read();
        ++ids;
        a.link(1,1,n,l1,r1,ids,w,false);
        b.link(1,1,n,l2,r2,ids,0,true);
        ++ids;
        a.link(1,1,n,l2,r2,ids,w,false);
        b.link(1,1,n,l1,r1,ids,0,true);
    }
    memset(d,0x3f,sizeof d),inf=d[0][0];
    int S=a.ID(1,1,n,1),T=b.ID(1,1,n,n);
    G.dj(S,T); // d[S][0]=0
    int ans=inf;
    for (int i=0;i<=k;++i) Min(ans,d[i][T]);
    ans==inf?puts("Yww is our red sun!"):printf("%d\n",ans);
    return 0;
}

转载于:https://www.cnblogs.com/owenyu/p/7154105.html