【UR #2】跳蚤公路

【UR #2】跳蚤公路

参照yjc方法。也就是地铁环线那个题。

求每个点不在负环内的x的取值范围。然后所有1到j能到i的j的范围取交。得到答案。

每个边形如kx+b的直线，每个环也是

每个点不在负环内的x取值范围是区间，

两次二分，

第一次二分区间左端点，第二次右端点。

如果没有负环，左端点往左偏，右端点往右偏

否则，记录负环的构成：k*mid+b的k的正负，可以得到mid应该往哪里偏。

注意SPFA找负环：

记录has[x]表示到x的最短路已经经过了多少个点，

dis[x]最短路，fr[x]是最短路的前驱，pre[x]是最短路前驱指向x的边

发现has[x]>n的时候，证明出现了负环。但是x不一定在负环上！

不断跳fr[x]找到整个环重复的第一个点z。

再fr[z]找到整个环。

emmm，一个问题是，负环上的点不会被其他点松弛导致fr[*]找不到负环吗？

由于SPFA的BFS性质，以及has[x]>n才会判断出有负环，

所以整个负环上的点，在判断has[*]>n之前，要么不会被松弛、或者松弛后要么找到新的负环、要么会被这个负环再次松弛，

总之这个环确实能找出来。

代码：

目前（2019.6.17）UOJ最优解

#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 Modulo{
const int mod=;
il int ad(int x,int y){return x+y>=mod?x+y-mod:x+y;}
il int sub(int x,int y){return ad(x,mod-y);}
il int mul(int x,int y){return (ll)x*y%mod;}
il void inc(int &x,int y){x=ad(x,y);}
il void inc2(int &x,int y){x=mul(x,y);}
il int qm(int x,int y=mod-){int ret=;while(y){if(y&) ret=mul(x,ret);x=mul(x,x);y>>=;}return ret;}
template<class ...Args>il int ad(const int a,const int b,const Args &...args) {return ad(ad(a,b),args...);}
template<class ...Args>il int mul(const int a,const int b,const Args &...args) {return mul(mul(a,b),args...);}
}
// using namespace Modulo;
namespace Miracle{
const int N=;
const int M=;
const ll inf=1e14;
int n,m;
struct edge{
    int x,y,k,b;
}b[M];
struct node{
    int nxt,to;
    int k,b;
    ll val(ll x){
        return k*x+b;
    }
}e[*M];
int hd[N],cnt;
void add(int x,int y,int k,int b){
    e[++cnt].nxt=hd[x];
    e[cnt].to=y;
    e[cnt].k=k;e[cnt].b=b;
    hd[x]=cnt;
}
int c[N],df,dfn[N],low[N];
int scc;
int f[N][N];
int sta[N],top,in[N];

int sz[N];
void tarjan(int x){
    dfn[x]=low[x]=++df;
    sta[++top]=x;in[x]=;
    for(reg i=hd[x];i;i=e[i].nxt){
        int y=e[i].to;
        if(!dfn[y]){
            tarjan(y);
            low[x]=min(low[x],low[y]);
        }else if(in[y]) low[x]=min(low[x],dfn[y]);
    }
    if(low[x]==dfn[x]){
        ++scc;
        int z;
        do{
            z=sta[top--];
            in[z]=;
            c[z]=scc;
            ++sz[scc];
        }while(z!=x);
    }
}
struct seg{
    ll l,r;
    seg(){l=-inf,r=inf;}
    seg(ll le,ll ri){
        l=le;r=ri;
    }
    bool empty(){
        return l>r;
    }
    bool full(){
        return (l==-inf)&&(r==inf);
    }
    seg friend operator &(seg a,seg b){
        return seg(max(a.l,b.l),min(a.r,b.r));
    }
    seg friend operator |(seg a,seg b){
        if(a.empty()) return b;
        if(b.empty()) return a;
        return seg(min(a.l,b.l),max(a.r,b.r));
    }
}lim[N];
ll dis[N];
int pre[N];
int fr[N];
int has[N];
queue<int>q;
bool vis[N];
int spfa(int s,ll mid,int n){
    //-1 need small; 1: need big ;0 ok
    while(!q.empty()) q.pop();
    memset(dis,0x3f,sizeof dis);
    memset(vis,,sizeof vis);
    // memset(pre,0,sizeof pre);
    // memset(has,0,sizeof has);

    dis[s]=;has[s]=;
    q.push(s);
    while(!q.empty()){
        int x=q.front();q.pop();
        // cout<<" xx "<<x<<endl;
        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(mid)){
                dis[y]=dis[x]+e[i].val(mid);
                pre[y]=i;
                fr[y]=x;
                has[y]=has[x]+;

                if(has[y]>n){//has fuhuan
                    // cout<<" fuhuan !!!"<<endl;
                    int z=y;
                    int k=;
                    memset(vis,,sizeof vis);
                    do{
                        // cout<<" zz "<<z<<endl;
                        // k+=e[pre[z]].k;
                        vis[z]=;
                        z=fr[z];
                    }while(!vis[z]);

                    int lp=z;
                    do{
                        k+=e[pre[z]].k;
                        z=fr[z];
                    }while(z!=lp);

                    if(k<){
                        return -;
                    }else{
                        return ;
                    }
                }

                if(!vis[y]){
                    vis[y]=;
                    q.push(y);
                }
            }
        }
    }
    return ;
}
void calc(int s,int id){
    // cout<<" calc "<<id<<" s "<<s<<endl;
    ll al=inf+;
    ll L=-inf,R=inf;
    while(L<=R){
        ll mid=(L+R)>>;
        // cout<<L<<" "<<R<<" : "<<mid<<endl;
        int lp=spfa(s,mid,sz[id]);
        if(lp==-){
            R=mid-;
        }else if(lp==){
            L=mid+;
        }else{
            al=mid;
            R=mid-;
        }
    }
    // cout<<" al "<<al<<endl;
    ll ar=-inf-;
    L=-inf,R=inf;
    while(L<=R){
        ll mid=(L+R)>>;

        int lp=spfa(s,mid,sz[id]);
        if(lp==-){
            R=mid-;
        }else if(lp==){
            L=mid+;
        }else{
            ar=mid;
            L=mid+;
        }
    }
    // cout<<" ar "<<ar<<endl;
    lim[id]=seg(al,ar);
}
int main(){
    rd(n);rd(m);
    for(reg i=;i<=m;++i){
        rd(b[i].x);rd(b[i].y);rd(b[i].b);rd(b[i].k);
        add(b[i].x,b[i].y,,);
        // f[b[i].x][b[i].y]=1;
    }
    for(reg i=;i<=n;++i){
        if(!dfn[i]){
            tarjan(i);
        }
    }
    // cout<<" after tarjan "<<endl;
    for(reg i=;i<=scc;++i){
        int s=;
        memset(hd,,sizeof hd);
        cnt=;
        for(reg j=;j<=m;++j){
            if(c[b[j].x]==i&&c[b[j].y]==i){
                s=b[j].x;
                add(b[j].x,b[j].y,b[j].k,b[j].b);
            }
        }
        if(s) calc(s,i);
    }

    for(reg i=;i<=scc;++i) f[i][i]=;
    for(reg i=;i<=m;++i){
        f[c[b[i].x]][c[b[i].y]]=;
    }
    for(reg k=;k<=scc;++k){
        for(reg i=;i<=scc;++i){
            for(reg j=;j<=scc;++j){
                f[i][j]|=(f[i][k])&(f[k][j]);
            }
        }
    }
    for(reg i=;i<=n;++i){
        seg ans;
        for(reg j=;j<=scc;++j){
            if(f[c[]][j]&&f[j][c[i]]){
               ans=ans&lim[j];
            }
        }
        if(ans.empty()){
            puts("");
        }
        else if(ans.l==-inf||ans.r==inf){
            puts("-1");
        }else{
            printf("%lld\n",ans.r-ans.l+);
        }
    }
    return ;
}   

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

/*
   Author: *Miracle*
*/

普通二分+判负环

因为整个值域都有单调性。知道不合法往哪里走。

区间二分？+找负环

二分左端点，二分右端点。

麻烦的是，第一次不合法，该往哪里走？（显然之后不合法其实是知道往哪里走的）

因为并没有单调性。

本题提供的思路是，考虑不合法的构成，来限制往哪里走才可能合法。

也就是额外记录一些东西

（好像这个套路暂时只出现于k*mid+b的k正负判断？）

---

upda：2019.6.21

官方题解：

利用Bellman-ford的思想进行判断负环。

简介Bellman-ford的方法：

不断枚举边数，用所有的边更新点的dis。

设f[i][j]走了i条边，到达j点，最短路

如果存在负环，则一定存在一个负环上的点u，使得f[u][n]<f[u][n-1]

扩展一下

f[i][j][k]表示，走了i条边，到达j点，斜率是k的最小的b值。

找到每个点不在负环的x的取值范围。

min(f[u][n][k1]+k1*x)>=min(f[u][n-1][k2]+k2*x)的x的个数。

枚举每个k1,求f[u][n][k1]+k1*x>=min(f[u][n-1][k2]+k2*x)的x区间，再求并。

转化为：求f[u][n][k1]+k1*x<min(f[u][n-1][k2]+k2*x)的x区间，求并，再求补集。

再枚举k2，解出的所有不等式f[u][n][k1]+k1*x<f[u][n-1][k2]+k2*x求交。

由于最后答案补集一定是[-inf,l],[l,r],[r,inf]，空集，的一种。所以过程中求交求并不会有奇怪情况。

求并的时候sort一下就好了。

然后floyd，从1到u到x的u的区间求交。

虽然不是所有的负环上的点都会考虑到，但是每个负环上至少有一个点可以得到限制，使得没有负环。

最后是求交，所以不影响正确性。