CF1163F Indecisive Taxi Fee

NOIP之前留的坑

CF1163F Indecisive Taxi Fee

经典问题：删边最短路

在Ta的博客查看

任意找一条最短路E，给E上的点和边新加入一个1~len的编号

最短路上的边变大麻烦

维护l[x],r[x]，从1到x最短路最后一个，x到n最短路第一个 在E上的点的编号

特别地，当x在E上时，显然有l[x]=r[x]=id[x]

然后枚举不在最短路上的边，线段树进行覆盖即可

不经过边e的最短路一定会覆盖到e上的（也不取决于最短路树什么样）

所以三遍dij

只要回来重新把在E上的x，l[x]=r[x]=id[x]即可

注意必须这样！

否则可能把经过的边也尝试最小化了。

#include<bits/stdc++.h>
#define reg register int
#define il inline
#define fi first
#define se second
#define mk(a,b) make_pair(a,b)
#define numb (ch^'0')
#define pb push_back
#define solid const auto &
#define enter cout<<endl
#define pii pair<int,int>
using namespace std;
typedef long long ll;
template<class T>il void rd(T &x){
    char ch;x=;bool fl=false;
    while(!isdigit(ch=getchar()))(ch=='-')&&(fl=true);
    for(x=numb;isdigit(ch=getchar());x=x*+numb);
    (fl==true)&&(x=-x);
}
template<class T>il void output(T x){if(x/)output(x/);putchar(x%+'');}
template<class T>il void ot(T x){if(x<) putchar('-'),x=-x;output(x);putchar(' ');}
template<class T>il void prt(T a[],int st,int nd){for(reg i=st;i<=nd;++i) ot(a[i]);putchar('\n');}

namespace Miracle{
const int N=2e5+;
const int M=2e5+;
const ll inf=0x3f3f3f3f3f3f3f3f;
int n,m,Q;
struct edge{
    int x,y,z;
}b[M];
int vis[N];
int pre[N];
int on[N],is[M];
int up,id[N],bi[M];
struct node{
    int nxt,to,val;
}e[*M];
int hd[N],cnt=;
void add(int x,int y,int z){
    e[++cnt].nxt=hd[x];e[cnt].to=y;e[cnt].val=z;
    hd[x]=cnt;
}
struct po{
    int id;ll val;
    po(){}
    po(int dd,ll vv){
        id=dd;val=vv;
    }
    bool friend operator <(po a,po b){
        return a.val>b.val;
    }
};
priority_queue<po>q;
ll dis[][N];
void init(){
    memset(dis[],0x3f,sizeof dis[]);
    dis[][n]=;
    q.push(po(n,));
    while(!q.empty()){
        po now=q.top();q.pop();
        if(vis[now.id]) continue;
        int x=now.id;
        vis[x]=;
        for(reg i=hd[x];i;i=e[i].nxt){
            int y=e[i].to;
            if(dis[][y]>dis[][x]+e[i].val){
                dis[][y]=dis[][x]+e[i].val;
                pre[y]=i;
                q.push(po(y,dis[][y]));
            }
        }
    }
}

int lim[N][];
void dij(int typ){
    memset(dis[typ],0x3f,sizeof dis[typ]);
    memset(vis,,sizeof vis);
    while(!q.empty()) q.pop();
    if(typ) q.push(po(n,)),dis[][n]=;
    else q.push(po(,)),dis[][]=;

    while(!q.empty()){
        po now=q.top();q.pop();
        if(vis[now.id]) continue;
        int x=now.id;
        vis[x]=;
        for(reg i=hd[x];i;i=e[i].nxt){
            int y=e[i].to;
            if(dis[typ][y]>dis[typ][x]+e[i].val){
                dis[typ][y]=dis[typ][x]+e[i].val;
                if(on[x]){
                    lim[y][typ]=id[x];
                }else{
                    lim[y][typ]=lim[x][typ];
                }
                q.push(po(y,dis[typ][y]));
            }
        }
    }
}
struct tr{
    ll mi;
    tr(){mi=inf;}
}t[*N];
#define mid ((l+r)>>1)
void chan(int x,int l,int r,int L,int R,ll c){
    if(L<||R>up) return;
    if(L<=l&&r<=R){
        t[x].mi=min(t[x].mi,c);return ;
    }
    if(L<=mid) chan(x<<,l,mid,L,R,c);
    if(mid<R) chan(x<<|,mid+,r,L,R,c);
}
void query(int x,int l,int r,int p,ll &ans){
    if(l==r) {
        ans=min(ans,t[x].mi);return;
    }
    ans=min(ans,t[x].mi);
    if(p<=mid) query(x<<,l,mid,p,ans);
    else query(x<<|,mid+,r,p,ans);
}
int main(){
    rd(n);rd(m);rd(Q);
    int x,y,z;
    for(reg i=;i<=m;++i){
        rd(x);rd(y);rd(z);
        add(x,y,z);add(y,x,z);b[i].x=x;b[i].y=y;b[i].z=z;
    }
    init();
    x=;
    while(x){
        on[x]=;
        is[pre[x]/]=;
        ++up;
        id[x]=up;
        bi[pre[x]/]=up;
        x=e[pre[x]^].to;
    }
    dij();dij();
    for(reg i=;i<=n;++i){
        if(on[i]){
            lim[i][]=lim[i][]=id[i];
        }
    }
    lim[][]=;lim[n][]=up;
    for(reg i=;i<=m;++i){
        int x=b[i].x,y=b[i].y;
        if(!is[i]){
            ll len=dis[][x]+dis[][y]+b[i].z;
            if(lim[x][]<=lim[y][]-) chan(,,up,lim[x][],lim[y][]-,len);
            len=dis[][x]+dis[][y]+b[i].z;
            if(lim[y][]<=lim[x][]-) chan(,,up,lim[y][],lim[x][]-,len);
        }
    }
    while(Q--){
        rd(x);rd(z);
        ll ans=inf;
        if(is[x]){
            if(z<=b[x].z){
                ans=dis[][n]-(b[x].z-z);
            }else{
                query(,,up,bi[x],ans);
                ans=min(ans,min(dis[][b[x].x]+dis[][b[x].y]+z,dis[][b[x].x]+dis[][b[x].y]+z));
            }
        }else{
            ans=min(dis[][n],min(dis[][b[x].x]+dis[][b[x].y]+z,dis[][b[x].x]+dis[][b[x].y]+z));
        }
        printf("%lld\n",ans);
    }
    return ;
}

}
signed main(){
    Miracle::main();
    return ;
}

/*
   Author: *Miracle*
*/