【JZOJ 5430】【NOIP2017提高A组集训10.27】图

Description

有一个n个点的无向图，给出m条边，每条边的信息形如<x,y,c,r>
给出q组询问形如<u,v,l,r>
接下来解释询问以及边的意义
询问表示，一开始你在点u上，然后按顺序处理编号从l到r的边
对于一条边<x,y,c,r>，你可以进行两种操作：
1. 如果你当前在x点或者y点上，那么你可以走这条边（从x到y或从y到x）并付出c的代价（当然你也可以不走，看操作2）
2. 如果你不走这条边或者不可以走这条边（即你当前不在x或y上），那么你需要付出r的代价

询问如果要从u点开始，按顺序处理完编号从l到r的边之后到达v点的最小代价，如果不能到达v，那么输出-1。
边和点的编号从1开始

Solution

这种题的套路就是：你先算出合并答案所要的复杂度，再算出查询答案的复杂度，再用合适的处理方法来暴力做，
比如这题就是套在分治上，

首先，暴力的话，就维护一个数组f，$f_i$表示从起点走到i的最小代价，
套到分治上，按边分治，计算$l_i\leq mid$且$mid<r_i$的询问的答案，
枚举经过mid时在那个点，由mid向两边DP，

复杂度：$O(n^2m\log(m))$

Code

#include <cstdio>
#include <algorithm>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fod(i,a,b) for(int i=a;i>=b;i--)
#define efo(i,q) for(int i=A[q];i;i=B[i][0])
#define min(q,w) ((q)>(w)?(w):(q))
#define max(q,w) ((q)<(w)?(w):(q))
using namespace std;
typedef long long LL;
const int N=200500,M=32;
int read(int &n)
{
    char ch=' ';int q=0,w=1;
    for(;(ch!='-')&&((ch<'0')||(ch>'9'));ch=getchar());
    if(ch=='-')w=-1,ch=getchar();
    for(;ch>='0' && ch<='9';ch=getchar())q=q*10+ch-48;n=q*w;return n;
}
int m,n,ans,m1;
int Ans[N];
struct qqww
{
    int x,y,c,r;
}a[N];
struct qwqw
{
    int x,y,l,r,i;
}b[N];
int f[M];
int Has[N];
int B[2*N][2],A[N],B0;
bool PX(qwqw q,qwqw w){return q.l<w.l||(q.l==w.l&&q.r<w.r);}
void link(int q,int w){B[++B0][0]=A[q];A[q]=B0,B[B0][1]=w;}
void divide(int l,int r,int l1,int r1)
{
    if(l1>r1||l>r)return;
    if(l==r)
    {
        fo(i,l1,r1)if(b[i].x==b[i].y)Ans[b[i].i]=a[l].r;
        else if((b[i].x==a[l].x||b[i].x==a[l].y)&&(b[i].y==a[l].x||b[i].y==a[l].y))
            Ans[b[i].i]=min(a[l].r,a[l].c);
        return;
    }
    int mid=(l+r)>>1;
    int mid1=l1-1;
    B0=0;
    fo(i,l1,r1)if(b[i].l<=mid&&b[i].r>mid)
    {
        mid1++;
        swap(b[i],b[mid1]);
        link(b[mid1].r,mid1);
        link(b[mid1].l,mid1);
    }
    fo(I,1,n)
    {
        fo(i,0,n)f[i]=1e9;
        f[I]=0;
        int q=mid1;
        fod(i,mid,l)
        {
            int t=f[a[i].x],t1=f[a[i].y];
            fo(j,1,n)f[j]+=a[i].r;
            f[a[i].x]=min(f[a[i].x],t1+a[i].c);
            f[a[i].y]=min(f[a[i].y],t+a[i].c);
            efo(j,i)Has[B[j][1]]=f[b[B[j][1]].x];
            if(I==n)A[i]=0;
        }
        fo(i,0,n)f[i]=1e9;
        f[I]=0;
        fo(i,mid+1,r)
        {
            int t=f[a[i].x],t1=f[a[i].y];
            fo(j,1,n)f[j]+=a[i].r;
            f[a[i].x]=min(f[a[i].x],t1+a[i].c);
            f[a[i].y]=min(f[a[i].y],t+a[i].c);
            efo(j,i)
            {
                int w=B[j][1];
                Ans[b[w].i]=min(Ans[b[w].i],Has[w]+f[b[w].y]);
            }
            if(I==n)A[i]=0;
        }
    }
    l1=mid1+1;  
    fo(i,l1,r1)if(b[i].r<=mid)
    {
        mid1++;
        swap(b[mid1],b[i]);
    }
    divide(l,mid,l1,mid1);
    divide(mid+1,r,mid1+1,r1);
}
int main()
{
    freopen("graph.in","r",stdin);
    freopen("graph.out","w",stdout);
    int q,w;
    read(n),read(m),read(m1);
    fo(i,1,m)read(a[i].x),read(a[i].y),read(a[i].c),read(a[i].r);
    fo(i,1,m1)read(b[i].x),read(b[i].y),read(b[i].l),read(b[i].r),b[i].i=i,Ans[i]=1e9;
    sort(b+1,b+1+m1,PX);
    divide(1,m,1,m1);
    fo(i,1,m1)printf("%d\n",(Ans[i]>=1e9?-1:Ans[i]));
    return 0;
}