题解 [51nod1340]地铁环线

Posted 2020-11-24 zsq259

题解 [51nod1340]地铁环线

题面

解析

本文参考这篇博客

一开始看到只有120行就打算写一写,

结果一刚就是三个星期摆摆摆

本来是当查分约束入门学的.

step 1

首先来考虑下如果已知总长度(s)如何判断是否合法.

显然差分约束

• 对于(dis(x,y)>=w)

  这个式子等价于(dis[x]+w<=dis[y]),

  即(dis[y]+(-w)>=dis[x]).

  因此,

  • 若(x<y),则(y)向(x)连一条边权为(-w)的边.

  • 若(x>y),则(y)向(x)连一条边权为(s-w)的边(要绕一圈,yy一下就知道了).

• 对于(dis(x,y)<=w)

  这个式子就是(dis[x]+w>=dis[y]).

  • 若(x<y),则(x)向(y)连一条边权为(w)的边.
  • 若(x>y),则(x)向(y)连一条边权为(s+w)的边.

又因为边权至少为(1),即(dis[x]+1<=dis[y]).

(dis[y]+(-1)>=dis[x]).

因此(i+1)要向(i)连一条边权为(-1)的边(n-1要特判)

最后,跑n-1边Bellman_Ford,

若还能进行松弛操作,即存在边((x,y,w)),使(dis[x]+w<=dis[y]),

则存在负环,就不合法.

step 2

差分约束还只是判断,

但我们要统计方案数啊.

注意到每个点的(dis)都是(k*s+b)的形式((k,b)为常数).

因此,我们可以设(dis[x][k])表示(s)前的系数为(k)时(dis[x])只计算(b)的最小值.

那么(dis[x])就等于(min(k*s+dis[x][k]).)

然后,对于每一条边(x,y,w),我们都可以把(s)的值域化为若干段,

使每一段都是取一个(k)使(s)取这一段值时的(dis)值最小.

这个可以用单调栈维护.

那么我们维护两个单调栈,

一个是(dis[x]+w)的,一个是(dis[y])的.

然后对于一段值域若(dis[x]+w>dis[y])则合法.

对每条边都这么来一次,用前缀和+差分来统计这一段权值的合法边数.

若合法边数等于总边数,则这一段值域合法,统计答案.

code(代码中的inf不知道是什么情况希望dalao指点):

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#define ll long long
#define int ll
using namespace std;

inline int read(){
    int sum=0,f=1;char c=getchar();
    while(c>'9'||c<'0'){if(c=='-') f=-1;c=getchar();}
    while(c<='9'&&c>='0'){sum=sum*10+c-'0';c=getchar();}
    return f*sum;
}

const int N=55;
struct list{ll x,v;}lis[N*N*N<<1];
int T,n,m1,m2,cnt,tot;
ll dis[N][N*2],inf;

inline ll up(ll tb,ll tk){
    if(tk<0) tk=-tk,tb=-tb;
    ll tt=tb/tk;
    return tt+(tt*tk<tb);
}/*向上取整*/

inline ll down(ll tb,ll tk){
    if(tk<0) tk=-tk,tb=-tb;
    ll tt=tb/tk;
    return tt-(tt*tk>tb);
}/*向下取整*/


struct line{
    ll l,r,k,b;
    inline ll f(int x){return k*x+b;}
}s1[N*N*N<<1],s2[N*N*N<<1];

inline void push(line *a,int &num,line t){
    while(num&&a[num].f(a[num].l)>=t.f(a[num].l)) num--;
    if(num) t.l=down(-(t.b-a[num].b),t.k-a[num].k)+1,a[num].r=t.l-1;
    a[++num]=t;
}

inline void put(ll l,ll r){
    lis[++tot]=(list){l,1};
    lis[++tot]=(list){r+1,-1};
}

inline void check(line s1,line s2){
    ll l=max(s1.l,s2.l),r=min(s1.r,s2.r);
    if(l>r) return ;
    line t=(line){0,0,s1.k-s2.k,s1.b-s2.b};
    if(t.f(l)<0&&t.f(r)<0) return ;
    put(t.f(l)>=0? l:up(-t.b,t.k),t.f(r)>=0? r:down(-t.b,t.k)); 
}

struct edge{
    ll x,y,w,k;
    inline void bf(){
        for(int i=0;i<=(n<<1);i++)
            if(i+k>=0&&i+k<=(n<<1)) dis[y][i+k]=min(dis[y][i+k],dis[x][i]+w);
    }
    inline void clac(){
        int n1=0,n2=0;
        for(int i=(n<<1);i>=0;i--){
            if(dis[x][i]<(inf>>1)) push(s1,n1,(line){n,inf,i+k-n,dis[x][i]+w});
            if(dis[y][i]<(inf>>1)) push(s2,n2,(line){n,inf,i-n,dis[y][i]});         
        }
        for(int k1=1,k2=1;k1<=n1&&k2<=n2;s1[k1].r<=s2[k2].r? k1++:k2++)
            check(s1[k1],s2[k2]);
    }
}e[N<<2];

inline void add(ll x,ll y,ll w,ll k){
    e[++cnt]=(edge){x,y,w,k};
}

inline bool cmp(list a,list b){return a.x<b.x;}

signed main(){
    T=read();
    while(T--){
        n=read(),m1=read(),m2=read();
        memset(dis,1,sizeof(dis));
        memset(lis,0,sizeof(lis));
        inf=dis[0][0];dis[0][n]=0;
        cnt=tot=0;
        for(int i=0;i<n;i++) add((i+1)%n,i,-1,i==n-1);
        for(int i=1;i<=m1;i++){
            int x=read(),y=read(),w=read();
            add(y,x,-w,(x>y));
        }
        for(int i=1;i<=m2;i++){
            int x=read(),y=read(),w=read();
            add(x,y,w,-(x>y));
        }
        for(int i=1;i<n;i++)
            for(int j=1;j<=cnt;j++) e[j].bf();
        for(int i=1;i<=cnt;i++) e[i].clac();        
        ll sum=0,ans=0;
        lis[++tot]=(list){inf,0};
        sort(lis+1,lis+tot+1,cmp);
        for(int i=1;i<tot;i++){
            ans+=((sum+=lis[i].v)==cnt)*(lis[i+1].x-lis[i].x);
        }
        printf("%lld
",ans<inf>>1? ans:-1);
    }   
    return 0;
}