【考试总结】2022-03-06

高维游走

首先使用 库默尔定理 发现将 $t_0$ 划分成 $\{a_0\dots a_m\},\forall i\neq j,a_i\cap a_j=\emptyset,\forall i,a_i\subseteq t_0\cap t_i$ 才能在组合数中构成奇数

最朴素的想法是直接 std::bitset 来对每个 $f(i)$ 计算奇偶性，但是可以通过划分阶段来将问题简化

逐二进制位转移是个不错的选择，设 $g_{i,x}$ 表示已经转移了前 $0\sim i$ 位，$f(x)\bmod 2$ 的值，转移枚举第 $i+1$ 位这个 $1$ 被哪个 $a_j$ 选走了，就可以让 $g_{i+1,j\times2^{i+1}+x}$ 产生更新

这时如果将 $x\bmod 2^{i+1}$ 分组，那么 $x+j\times 2^{i+1}\equiv x\mod 2^{i+1}$，也就是说奇偶性的变化只会在组内发生

那么由于已经转移的权值不超过 $2^i$ 每组非零的 $x$ 的数量不会超过 $m\times 2^i$，即每个组里面的元素不超过 $m$ 个，又根据权值是 $0/1$，可以使用二进制位压缩

本质上 $0/1$ 表示不相同的组是 $\Theta(2^m)$ 数量级的，所以每个余数都开个变量非常蠢，再开桶 $ton_S$ 表示压缩后是 $S$ 的组的数量

对于 $t_0$ 不包含的位，从 $S\bmod\ 2_i\to x \bmod\ 2^{i+1}$ 发生的变化就是商是奇数的和商是偶数的分开了，这样子的变化可以预处理

对于 $t_0$ 包含的位需要先枚举 同样包含这位的 $t_i$ 把方案数变成偶数的异或掉再转移即可

Code Display

const int N=2000010;
int t[N],n,m,dp[2][N],ev[N],od[N];
signed main(){
    freopen("travel.in","r",stdin); freopen("travel.out","w",stdout);
    for(int i=1;i<=N-10;++i){
        ev[i]=(ev[i>>2]<<1)|((i>>1)&1);
        od[i]=(od[i>>2]<<1)|(i&1);
    }
    int T=read(); while(T--){
        n=read(); rep(i,0,n) t[i]=read();
        int cur=0,S=(1<<(n+1)); --S;
        dp[cur][1]=1;
        for(int i=0;i<31;++i){
            if(t[0]>>i&1){
                for(int st=0;st<=S;++st) if(dp[cur][st]){
                    int nxt=st;
                    for(int j=1;j<=n;++j) if(t[j]>>i&1) nxt^=(st<<j);
                    dp[cur^1][ev[nxt]]+=dp[cur][st];
                    dp[cur^1][od[nxt]]+=dp[cur][st];
                    dp[cur][st]=0;
                }
            }else{
                for(int st=0;st<=S;++st) if(dp[cur][st]){
                    dp[cur^1][ev[st]]+=dp[cur][st];
                    dp[cur^1][od[st]]+=dp[cur][st];
                    dp[cur][st]=0;
                }
            }
            cur^=1;
        }
        int ans=0;
        for(int i=1;i<=S;++i) ans+=dp[cur][i]*__builtin_popcount(i),dp[cur][i]=0;
        print(ans);
    }
    return 0;
}

过山车

如果只判定合法性的做法就是将每个点拆成横向/竖向两个点并再拉一个本原点出来

黑白染色之后本原点向源点/汇点连流量为 $2$ 的边，同时向横向、竖向两个点都连流量为 $2$ 的边

根据网格图将各个点的横向/纵向点连起来看看最大流是不是点数即可

如果附加权值考虑 “减少竖直边” 这样的求解方式，从本原点连向横向/纵向点流量为 $2$ 边中一个带 $0$ 权，另一个带 $a_{i,j}$ 的权值即可

由于是最小费用最大流，那么一定先选择两个 $0$ 权边，也就是拐弯的方法

Code Display

const int N=1e5+10,inf=0x3f3f3f3f;
struct edge{int to,nxt,lim,cst;}e[N<<2];
int head[N],dst[N],pre[N],incf[N];
int tot,id1[200][200],id[200][200],id2[200][200],S,T;
int n,m,cnt=1,ban[200][200],val[200][200];
bool inq[N];
inline bool spfa(){
    for(int i=1;i<=tot;++i) incf[i]=0,dst[i]=inf; dst[S]=0; incf[S]=inf;
    queue<int> q; q.push(S);
    while(q.size()){
        int fr=q.front(); q.pop(); inq[fr]=0;
        for(int i=head[fr];i;i=e[i].nxt) if(e[i].lim){
            int t=e[i].to; if(dst[fr]+e[i].cst<dst[t]){
                dst[t]=dst[fr]+e[i].cst; incf[t]=min(incf[fr],e[i].lim); pre[t]=i;
                if(!inq[t]) inq[t]=1,q.push(t);
            }
        }
    }
    return dst[T]!=inf;   
}
inline void adde(int u,int v,int w,int c){
    e[++cnt]={v,head[u],w,c}; head[u]=cnt;
    return ;
}
inline void add(int u,int v,int w,int c){return adde(u,v,w,c),adde(v,u,0,-c);}
signed main(){
    freopen("roller.in","r",stdin); freopen("roller.out","w",stdout);
    n=read(); m=read();
    int sum=0,block=0;
    S=++tot; T=++tot;
    rep(i,1,n) rep(j,1,m) ban[i][j]=read();
    rep(i,1,n) rep(j,1,m){
        val[i][j]=read();
        sum+=(!ban[i][j])*val[i][j];
        block+=!ban[i][j];
        if(!ban[i][j]){
            id1[i][j]=++tot,id2[i][j]=++tot,id[i][j]=++tot;
            if((i+j)&1){
                add(S,id[i][j],2,0);
                add(id[i][j],id1[i][j],1,0);
                add(id[i][j],id1[i][j],1,val[i][j]);
                add(id[i][j],id2[i][j],1,0);
                add(id[i][j],id2[i][j],1,val[i][j]);
            }else{
                add(id[i][j],T,2,0);
                add(id1[i][j],id[i][j],1,0);
                add(id1[i][j],id[i][j],1,val[i][j]);
                add(id2[i][j],id[i][j],1,0);
                add(id2[i][j],id[i][j],1,val[i][j]);
            }
        }
    }
    for(int i=1;i<=n;++i){
        for(int j=1;j<=m;++j) if(!ban[i][j]&&(i+j)%2){
            if(i+1<=n&&!ban[i+1][j]) add(id1[i][j],id1[i+1][j],1,0);
            if(i-1&&!ban[i-1][j]) add(id1[i][j],id1[i-1][j],1,0);
            if(j+1<=m&&!ban[i][j+1]) add(id2[i][j],id2[i][j+1],1,0);
            if(j-1&&!ban[i][j-1]) add(id2[i][j],id2[i][j-1],1,0);
        }   
    }
    int flow=0;
    while(spfa()){
        int x=T;
        while(x!=S){
            e[pre[x]].lim-=incf[T];
            e[pre[x]^1].lim+=incf[T];
            x=e[pre[x]^1].to;
        }
        flow+=incf[T]; sum-=incf[T]*dst[T];
    }
    if(flow==block) print(sum);
    else print(-1);
    return 0;
}

木棍

将线段转化成左端点（也就是让限制的右端点 $-k$），同时记 $s_i$ 表示前 $i$ 个整点上左端点数量

那么线段长度是 $k\Leftrightarrow$ $\forall l,r,s_r-s_{l}\le \lceil\frac{r-l}k\rceil$

对于 $m$ 条限制中也就是 $s_{x-1}\ge s_y-c$；$n$ 个木棍的位置可以表达成 $s_{b_i}\ge s_{a-1}+1$，最后根据实际含义还还有 $s_{i}\ge s_{i+1}-1$

先考察 $s_{b}\ge s_a+1$，设 $U(l,r)$ 表示区间 $[l,r]$ 里面的线段数量，使用 $\rm Hall$ 定理发现 $(a,b)$ 的限制需要表示为 $s_r-s_{l-1}\ge U(l,r)$

$n$ 较大时这样子的连边方式接受不了，尝试只保留 “限制区间” 的左端点$-1$ 和右端点作为 关键点 及关键点所涉及到的边（也就是导出子图）来进行差分约束

对于原图上的一个不全是关键点的正环，找到一个非关键点，它在环上的连边不能是 $m$ 条限制中的边，如果有连续的 $\ge U(l,r)$ 或者 $\le -\lceil\frac {len}k\rceil$ 边，合并起来并不会让环的权值减小

那么保持 $U(l,r)$ 不变，让这个点所对应的区间缩小一定会让环上的权值不降，所以可以只对导出子图做差分约束

在进行差分约束的过程中，观察边的构成，容易使用 $\Theta(n+m)$ 来处理 $s_i\le s_{i+1},s_{x-1}\ge s_y-c$

对于 $s_r-s_{l-1}\ge U(l,r)$ 这是经典的扫描线问题，在我的 chkmax 式差分约束中可以表示为 $s_r\ge \max\limits_{l<r}\{s_{l-1}+U(l,r)\}$

第四种 $s_r-s_{l}\le \lceil\frac{r-l}k\rceil\Rightarrow s_l\ge s_r-\lceil\frac rk\rceil+\lceil\frac lk\rceil-(r\bmod \ k>l\bmod \ k)$ 可以将 $i\in[1,n]$ 按照模 $k$ 的余数排序之后，使用 $\text {Fenwick Tree}$ 维护后缀最大值即可

注意更新是有顺序的，在正序扫描的时候对于同余数的先都插入再查询，而倒序时要先都查询再插入，来避免漏转移或者错误的转移

如果把线段树换成 zkw 线段树 之后感觉没有常数优化余地了，不知道 $\text{std}$ 是怎么做的，只能把正环长度卡到 $3000$ 了

Code Display

const int N=4010,inf=0x3f3f3f3f;
int n,m,k,x[N],y[N],c[N],a[N],b[N];
int num,ar[N];
vector<int> inter[N];
int now[N],nxt[N];
struct Fenwick{
    int c[N];
    inline void clear(){memset(c,-0x3f,sizeof(c));}
    inline void insert(int x,int v){
        for(;x;x-=x&(-x)) ckmax(c[x],v);
        return ;
    }
    inline int query(int x){
        int Mx=0;
        for(;x<=num;x+=x&(-x)) ckmax(Mx,c[x]);
        return Mx;
    }
}T;
struct Seg{
#define ls p<<1
#define rs p<<1|1
    int Mx[N<<2],tag[N<<2],bit;
    inline void push_up(int p){Mx[p]=max(Mx[ls],Mx[rs])+tag[p];}
    inline void build(int n){
        bit=1; while(bit<=n+1) bit<<=1;
        for(int i=bit+1;i<=bit+n;++i) Mx[i]=now[i-bit],tag[i]=0;
        for(int i=bit-1;i>=1;--i) Mx[i]=max(Mx[i<<1],Mx[i<<1|1]),tag[i]=0;
        return ;
    }
    inline void upd(int st,int ed){
        st+=bit-1; ed+=bit+1;
        while(st!=ed-1){
            if(!(st&1)) Mx[st^1]++,tag[st^1]++;
            if(ed&1) Mx[ed^1]++,tag[ed^1]++;
            push_up(st>>=1); push_up(ed>>=1);
        } 
        while(st>>1) push_up(st>>=1);
        return ;
    }
    inline int query(int st,int ed){
        st+=bit-1; ed+=bit+1;
        int lef=0,rig=0;
        while(st!=ed-1){
            if(!(st&1)) ckmax(lef,Mx[st^1]);
            if(ed&1) ckmax(rig,Mx[ed^1]);
            lef+=tag[st>>=1]; rig+=tag[ed>>=1];
        }
        int Mx=max(lef,rig);
        while(st>>1) Mx+=tag[st>>=1];
        return Mx;
    }
#undef ls
#undef rs
}seg;
int quo[N],rem[N],id[N];
signed main(){
    freopen("stick.in","r",stdin); freopen("stick.out","w",stdout);
    n=read(); m=read(); k=read(); 
    rep(i,1,n){
        a[i]=read(),b[i]=read()-k;
        ar[++num]=a[i]-1; ar[++num]=b[i];
    }
    rep(i,1,m){
        x[i]=read(),y[i]=read()-k,c[i]=read();
        ar[++num]=x[i]-1; ar[++num]=y[i];
    }
    sort(ar+1,ar+num+1); num=unique(ar+1,ar+num+1)-ar-1;
    rep(i,1,num){
        quo[i]=ar[i]/k,rem[i]=(ar[i]%k+k)%k,id[i]=i;
        while(k*quo[i]>ar[i]) quo[i]--;
    }
    sort(id+1,id+num+1,[&](const int &x,const int &y){return rem[x]<rem[y];});
    rep(i,1,n){
        a[i]=lower_bound(ar+1,ar+num+1,a[i]-1)-ar;
        b[i]=lower_bound(ar+1,ar+num+1,b[i])-ar;
        inter[b[i]].push_back(a[i]);
    }
    rep(i,1,m){
        x[i]=lower_bound(ar+1,ar+num+1,x[i]-1)-ar;
        y[i]=lower_bound(ar+1,ar+num+1,y[i])-ar;
    }
    //four kinds of edges
    // first -> s[x[i]-1]>=s[y[i]]+c;
    // second-> s[i]<=s[i+1]
    // third -> s[i]>=s[j]-(i-j+k-1)/k
    // fourth-> scaning line
    memset(now,-0x3f,sizeof(now)); now[0]=0;
    memset(nxt,-0x3f,sizeof(nxt));
    for(int turn=1;turn<=num;++turn){
        nxt[0]=now[0];
        for(int i=1;i<=num;++i) nxt[i]=max(nxt[i-1],now[i]);
        //second type
        for(int i=1;i<=m;++i) ckmax(nxt[x[i]],now[y[i]]-c[i]);
        //first type
        seg.build(num);
        for(int i=1;i<=num;++i){
            for(auto t:inter[i]) seg.upd(1,t);
            if(i-1) ckmax(nxt[i],seg.query(1,i-1));
        }
        //scaning line
        T.clear();
        for(int i=1;i<=num;++i){
            int rig=i;
            while(rig<num&&rem[id[rig+1]]==rem[id[i]]) ++rig;
            for(int j=i;j<=rig;++j) T.insert(id[j],now[id[j]]-quo[id[j]]);   
            for(int j=i;j<=rig;++j) ckmax(nxt[id[j]],T.query(id[j]+1)+quo[id[j]]);
            i=rig;
        }
        T.clear();
        for(int i=num;i>=1;--i){
            int rig=i;
            while(rig>1&&rem[id[rig-1]]==rem[id[i]]) --rig;
            for(int j=i;j>=rig;--j) ckmax(nxt[id[j]],T.query(id[j]+1)+quo[id[j]]-1);
            for(int j=i;j>=rig;--j) T.insert(id[j],now[id[j]]-quo[id[j]]);
            i=rig;
        }
        //third type
        bool updd=0;
        for(int i=1;i<=num;++i) if(now[i]!=nxt[i]){updd=1; break;}
        if(!updd) break;
        if(turn==num) puts("No"),exit(0);
        for(int i=1;i<=num;++i) now[i]=nxt[i],nxt[i]=-inf;
    }
    puts("Yes");
    return 0;
}