回归——Tj1

csp-s2019考的不是很好，D1还可以，210`，D2就GG了（据说有洛谷黑题），然后只有80+（本来有一个O(n^2)的dp都没写，自己的贪心是错了）

总共才289是不是很菜啊。。。

但是出来一看竟然不算太低，打算冲击省队了(heiheihei)

好久没法博客了，感觉过去了一个世纪，自己最近一直在补知识点（平衡树，各种流，点分治，数据结构。。。）

总算补齐了，开始giao数学

1.多项式

定义，基本性质。。。(自行百度)

Duan2baka dalao的讲解十分细致，请翻转

https://blog.csdn.net/WADuan2/article/details/79529900

FFT：快速傅里叶变换，听起来好牛逼的亚子 

原理：通过复数的性质实现快速插值，最后利用复数的性质求值的过程

具体步骤和模板：见上文博客

下面讲解最关键的部分：

蝴蝶变换（迭代写法）

目前比较流行的写法有两种:

1.递推法:

for(int i=1;i<n-1;i++){
        rev[i]=(rev[i>>1]>>1)|((i&1)&(n>>1));
    }

2.名字忘了:

inline void rader(Complex a[],int len){//二进制翻转 
    int j=len>>1;
    for(int i=1;i<len-1;i++){
        if(i<j)swap(a[i],a[j]);
        int k=len>>1;
        while(j&k){
            j^=k;
            k>>=1;
        }
        j|=k;//位运算便于理解 
    }
}

本蒟蒻当初学的时候就是看不懂蝴蝶变换，甚至背了板子

 

 

 

 

 

 

 

 

那么好，蝴蝶变化是干什么的？

在写FFT的 时候，大家应该从递归版本开始写，就会发现，你传入的是系数，返回的就成了插入（n/2）次单位根的值时的点值(!!!Rechardluan 一开始也懵逼)，所以上面图片中只有最底下的step3中的W是有意义的，又因为到最后的时候n=1,Wn=1，所以点值直接就是系数了，

至于为什么这样是对的，考虑当前的系数，递归时，把偶数按次放左边，奇数按次放右边

实际上就是二进制的最后一位为0（左边）或者为1（右边）

之后的过程相当于将所有的数 >>1 比较二进制下的第2位

到最后就会出现二进制翻转的情况了

所以蝴蝶变换本质上就是递归过程的加快，没什么特殊的性质

完整代码一只：

#include<bits/stdc++.h>
using namespace std;
char C_[50];
int TEMP;
template<typename T>
inline void write(T a){
    if(a<0){
         putchar('-');
         a=-a;
    }
    do{
         C_[++TEMP]=a%10+'0';
         a/=10;
    }while(a);
    while(TEMP)putchar(C_[TEMP--]);
    putchar(' ');
}
const int maxn=1e7+5;
const long double pi=acos(-1);
struct Complex{
    double r,i;
    Complex(double R=0.0,double I=0.0):r(R),i(I){}
    Complex operator+(const Complex&C)const{
        Complex ans;
        ans.r=r+C.r;
        ans.i=i+C.i;
        return ans;
    }
    Complex operator-(const Complex&C)const{
        Complex ans;
        ans.r=r-C.r;
        ans.i=i-C.i;
        return ans;
    }
    Complex operator*(const Complex&C)const{
        Complex ans;
        ans.r=r*C.r-i*C.i;
        ans.i=r*C.i+i*C.r;
        return ans;
    }
}a[maxn],b[maxn];
int rev[maxn];
inline void rader(Complex a[],int len){//二进制翻转 
    int j=len>>1;
    for(int i=1;i<len-1;i++){
        if(i<j)swap(a[i],a[j]);
        int k=len>>1;
        while(j&k){
            j^=k;
            k>>=1;
        }
        j|=k;//位运算便于理解 
    }
}
inline void FFT(Complex a[],int len,int v){
    //rader(a,len);
    for(int i=1;i<len-1;i++)if(i<rev[i])swap(a[i],a[rev[i]]);
    
    for(int l=2,mid=1;l<=len;mid<<=1,l<<=1){
    //mid是当前长度的一半 l是当前长度 
        Complex Wn=Complex(cos(2.0*pi/l),v*sin(2.0*pi/l));//n次单位根 
        for(int i=0;i<len;i+=l){
            Complex W=Complex(1.0,0.0);
            for(int j=i;j<i+mid;j++,W=W*Wn){
                Complex A1=a[j],A2=W*a[j+mid];
                a[j]=A1+A2;
                a[j+mid]=A1-A2;
            }
        }
    }
}
int n,m;
int main(){
    scanf("%d%d",&n,&m);n++,m++;
    for(int i=0;i<n;i++)scanf("%lf",&a[i].r);
    for(int i=0;i<m;i++)scanf("%lf",&b[i].r);
    int len=1,L=0;
    n=n+m-1;//项数 
    while(len<=n)len<<=1,L++;//保证2^n项 
    for(int i=1;i<len-1;i++){
        rev[i]=(rev[i>>1]>>1)|((i&1)<<(L-1));
    }
    FFT(a,len,1.0);
    FFT(b,len,1.0);//转化成点值表示 
    for(int i=0;i<len;i++)a[i]=a[i]*b[i];//相乘 
    
    FFT(a,len,-1.0);//INFT 插值 
    for(int i=0;i<n;i++)write(int(a[i].r/len+0.5));
    return 0;
}

例题的话不太多，FFT加速字符串匹配？

基本推出式子就可以了

NTT：差不多吧。把复数单位根换成原根

#include<bits/stdc++.h>
#define LL long long
#define rep(i,l,r) for(int i=(l);i<=(r);i++)
using namespace std;
const LL P=998244353ll;
const int maxn=1e6;
const LL g=3ll;
const LL invg=332748118ll;
inline LL quickpow(LL a,LL n){
    LL ans=1ll;
    while(n){
        if(n&1)ans=ans*a%P;
        a=a*a%P;
        n>>=1;
    }
    return ans%P;
}
int n,m,len,L,rev[maxn<<2];
LL a[maxn<<2],b[maxn<<2];
inline void NTT(LL a[],int len,int b){
    rep(i,0,len-1)if(i<rev[i])swap(a[i],a[rev[i]]);
    for(int mid=1,l=2;l<=len;l<<=1,mid<<=1){
        LL Wn=quickpow( b==1 ? g : invg , (P-1)/l);
        for(int i=0;i<len;i+=l){
            LL W=1;
            for(int j=i;j<i+mid;j++,W=(W*Wn)%P){
                LL A1=a[j]%P,A2=W*a[j+mid]%P;
                a[j]=(A1+A2)%P;
                a[j+mid]=((A1-A2)%P+P)%P;
            }
        }
    }
}
int main(){
    scanf("%d%d",&n,&m);
    rep(i,0,n)scanf("%lld",&a[i]);//n次多项式 
    rep(i,0,m)scanf("%lld",&b[i]);//m次多项式 
    len=1;L=0;
    while(len<n+m+1){//n+m次多项式 [0,n+m]
        len<<=1;
        L++;
    }
    rep(i,0,len-1)rev[i]=( (rev[i>>1]>>1) | ((i&1)<<(L-1)) );
    NTT(a,len,1);
    NTT(b,len,1);
    rep(i,0,len-1)a[i]=a[i]*b[i]%P;
    NTT(a,len,-1);
    LL invl=quickpow(1ll*len,P-2);
    rep(i,0,(n+m))printf("%lld ",a[i]*invl%P);
    return 0;
}

 

ps：自己真的好懒，很多东西都没讲，Duan2baka讲的挺详细的（我会告诉你们我不会用markdown编辑器么）

平衡树：这东西就像segtree一样，是个工具，用于处理 区间问题，然后自己总结了一下板子，以供参考

#include<bits/stdc++.h>
using namespace std;
//splay  
const int maxn=1e5+5;
int n,m,root,tot;
struct Node{
    int val,lazy,ch[2],size,fa;
    Node(){val=lazy=ch[0]=ch[1]=size=fa=0;}
    inline void modify(){
        swap(ch[0],ch[1]);
        lazy^=1;
    }
}t[maxn];
inline int drc(int x){//0->leftson,1->rightson
    if(t[x].fa)    return x == t[ t[x].fa ].ch[1] ;
    else return -1;
}
inline void down(int x){
    if(t[x].lazy){
        if(t[x].ch[0])t[t[x].ch[0]].modify();
        if(t[x].ch[1])t[t[x].ch[1]].modify();
        t[x].lazy=0;
    }
}
inline void maintain(int x){if(!x)return;t[x].size=t[t[x].ch[0]].size+t[t[x].ch[1]].size+1;}
inline void rtt(int &x){//将x上旋 
    int f=t[x].fa;int b=drc(x);
    t[f].ch[b]=t[x].ch[b^1];t[x].ch[b^1]=f;
    t[x].fa=t[f].fa;
    if(drc(f)!=-1)t[t[f].fa].ch[drc(f)]=x;
    if(t[f].ch[b])t[ t[f].ch[b] ].fa=f;
    t[f].fa=x;
    maintain(f);maintain(x);
}
inline void splay(int x,int &target){
    while(t[x].fa && x!=target){//还不是根 
        if(t[x].fa!=target && drc(x)==drc(t[x].fa) )//能构成3点1线 
        rtt(t[x].fa);
        else rtt(x);
    }
    target=x;
}
void build(int &k,int fa,int l,int r){
    if(l>r)return;
    
    k=++tot;
    t[k].fa=fa;
    t[k].val=(l+r)>>1;
    
    build(t[k].ch[0],k,l,t[k].val-1);
    build(t[k].ch[1],k,t[k].val+1,r);
    
    maintain(k);
}
inline int rank_k(int k){//找到第k大的位置 
    int x=root;
    while(x){
        down(x);
        
        if(t[t[x].ch[0]].size+1==k)return x;
        bool b=t[t[x].ch[0]].size+1 <= k;
        if(b)k-=(t[t[x].ch[0]].size+1);
        x=t[x].ch[b];
    }
}
void print(int x){
    if(!x)return;
    down(x);
    
    print(t[x].ch[0]);
    if(1<=t[x].val && t[x].val<=n )printf("%d ",t[x].val);
    print(t[x].ch[1]);
}
int main(){
    scanf("%d%d",&n,&m);
    build(root,0,0,n+1);
    while(m--){
        int l,r;
        scanf("%d%d",&l,&r);
        l=rank_k(l);splay(l,root);
        r=rank_k(r+2);splay(r,t[root].ch[1]);
        t[ t[r].ch[0] ].modify();
    }
    print(root);
    return 0;
}
//无旋treap
const int maxn=1e5+5;
struct Node{
    int val,rd,ch[2],lazy,size;
    Node(){val=rd=ch[1]=ch[0]=lazy=size=0;}
    inline void over(){
        lazy^=1;
        swap(ch[0],ch[1]);
    }
}t[maxn];
int root,tot;
inline void New(int &x,int val){
    x=++tot;
    t[x].rd=rand();
    t[x].val=val;
    t[x].size=1;
}
inline void down(int x){
    if(t[x].lazy){
        if(t[x].ch[0])t[t[x].ch[0]].over();
        if(t[x].ch[1])t[t[x].ch[1]].over();        
        t[x].lazy=0;
    }
}
inline void maintain(int x){t[x].size=t[t[x].ch[0]].size+t[t[x].ch[1]].size+1;}
void split(int x,int k,int &r1,int &r2){
    if(!x){r1=r2=0;return;}
    
    down(x);
    
    if(k<=t[t[x].ch[0]].size){
        r2=x;
        split(t[x].ch[0],k,r1,t[x].ch[0]);
    }
    else{
        r1=x;
        split(t[x].ch[1],k-t[t[x].ch[0]].size-1,t[x].ch[1],r2);
    }
    maintain(x);
}
int merge(int r1,int r2){
    if(!r1 || !r2)return r1+r2;
    if(t[r1].rd<t[r2].rd){
        
        down(r1);
        
        t[r1].ch[1]=merge(t[r1].ch[1],r2);
        maintain(r1);
        return r1;
    }
    else{
        
        down(r2);
        
        t[r2].ch[0]=merge(r1,t[r2].ch[0]);
        maintain(r2);
        return r2;
    }
}
void print(int x){//中序遍历 
    if(!x)return;
    
    down(x);
    
    print(t[x].ch[0]);
    printf("%d ",t[x].val);
    print(t[x].ch[1]);
}
int n,m;
int main(){
    srand(time(0));

    scanf("%d%d",&n,&m);
    for(int i=1,rt;i<=n;i++){
        New(rt,i);
        root=merge(root,rt);
        //O(??)构建treap 
    }
    for(int i=1,l,r;i<=m;i++){
        scanf("%d%d",&l,&r);
        int r1,r2,r3;
        split(root,r,r2,r3);//[1~r][r+1~n]
        split(r2,l-1,r1,r2);//[1~l-1][l~r][r+1~n]
        t[r2].over();
        root=merge(merge(r1,r2),r3);
    }
    print(root);
    return 0;
} 
//完整版 带旋treap
#include<bits/stdc++.h>
using namespace std;
const int maxn=3e5+5;
const int INF=1e9;
int tot,root;
struct Node {
    int val,size,cnt,to[2],key;
    Node(){
        size=cnt=0;
        to[0]=to[1]=0;
        key=rand();
    }
}t[maxn];
inline void update(int x){
    t[x].size=t[ t[x].to[0] ].size+t[ t[x].to[1] ].size+t[x].cnt;
}
inline void rtt(int &x,bool b){
    //作为父亲的节点 旋转方向
    int s=t[x].to[b];
    t[x].to[b]=t[s].to[b^1];
    t[s].to[b^1]=x;
    update(x);update(x=s);//维护节点信息,并且转移父子关系 
}
void insert(int &x,int val){
    if(!x){
        x=++tot;
        t[x].size=t[x].cnt=1;
        t[x].to[0]=t[x].to[1]=0;
        t[x].val=val;
        return;
    }
    t[x].size++;
    if(t[x].val==val){
        t[x].cnt++;
        return;
    }
    bool b=(val>t[x].val);insert(t[x].to[b],val);
    
    if(t[ t[x].to[b] ].key>t[x].key)rtt(x,b);//维护一个小跟堆 
}
void del(int &x,int val){
    if(!x)return;

    if(t[x].val==val){
        if(t[x].cnt>1){
            t[x].cnt--;
            t[x].size--;
            return;
        }
        bool b=(t[ t[x].to[0] ].key>t[ t[x].to[1] ].key);

        if(!t[x].to[0] || !t[x].to[1])x=t[x].to[0]+t[x].to[1];
        else{
            rtt(x,b);
            del(x,val);
        }
    }
    else{
        t[x].size--;
        del(t[x].to[ val > t[x].val ],val);
    }
}
int rank(int val){
    int x=root,ans=0;
    while(x){
        if(t[x].val==val){
            ans+=t[ t[x].to[0] ].size+1;
            break;
        }
        bool b=(val>t[x].val);
        if(b)ans+=t[ t[x].to[0] ].size+t[x].cnt;
        x=t[x].to[b];
    }
    return ans;
}
int pre(int val){
    int ans=-INF,x=root;
    while(x){
        bool b=(val>t[x].val);
        if(b)ans=max(ans,t[x].val);
        x=t[x].to[b];
    }
    return ans== -INF ? -1 : ans ;
}
int suf(int val){
    int ans=INF,x=root;
    while(x){
        bool b=(val>=t[x].val);
        if(!b)ans=min(ans,t[x].val);
        x=t[x].to[b];
    }
    return ans== INF ? -1 : ans ;
}
/*int kth(int k){
    int x=root;
    while(x){
        
        if(t[ t[x].to[0] ].size+1==k)return t[x].val;
        bool b=(k>t[ t[x].to[0] ].size+t[x].cnt);
        if(b)k-=(t[ t[x].to[0] ].size+t[x].cnt);
        x=t[x].to[b];
    }
}*/
int kth(int k){
    int x=root;
    while(1){
        if(k<=t[ t[x].to[0] ].size)x=t[x].to[0];
        else if(k>t[ t[x].to[0] ].size+t[x].cnt){
            k-=t[ t[x].to[0] ].size+t[x].cnt;
            x=t[x].to[1];
        }
        else return t[x].val;
    }
}
int n,op,x;
int main(){
    srand(time(0));
    
    scanf("%d",&n);
    while(n--){
        scanf("%d%d",&op,&x);
        switch(op){
            case 1:{
                insert(root,x);
                break;
            }
            case 2:{
                del(root,x);
                break;
            }
            case 3:{
                printf("%d\n",rank(x));
                break;
            }
            case 4:{
                printf("%d\n",kth(x));
                break;
            }
            case 5:{
                printf("%d\n",pre(x));
                break;
            }
            case 6:{
                printf("%d\n",suf(x));
                break;
            }
        }
    }
    return 0;
} 
//完整版 无旋treap
#include<bits/stdc++.h>
using namespace std;
const int maxn=1e5+5;
struct Node{
    int val,ls,rs,cnt,size,rd;
    Node(){val=ls=rs=cnt=size=rd=0;}
}t[maxn];
int root,tot;
int n,op,x;
inline void maintain(int x){t[x].size=t[ t[x].ls ].size+t[ t[x].rs ].size+t[x].cnt;}
void split(int x,int val,int &r1,int &r2){
    //r1是应该划分到T1中的点，r2是应该划分到T2中的点 
    if(!x){r1=r2=0;return;}
    if(t[x].val<=val){
        r1=x;
        split(t[x].rs,val,t[x].rs,r2);
    }
    else{
        r2=x;
        split(t[x].ls,val,r1,t[x].ls);
    }
    
    maintain(x);
}
void dvd(int x,int k,int &r1,int &r2){
    if(!x){r1=r2=0;return;}
    if(t[ t[x].ls ].size>=k){
        r2=x;
        dvd(t[x].ls,k,r1,t[x].ls);
    }
    else{
        r1=x;
        dvd(t[x].rs,k-t[ t[x].ls ].size-t[x].cnt,t[x].rs,r2);
    }
    
    maintain(x);
}
int merge(int r1,int r2){
    //合并两棵树
     if(!r1 || !r2)return r1+r2;
     if(t[r1].rd<t[r2].rd){
          t[r1].rs=merge(t[r1].rs,r2);
          
          maintain(r1);
          return r1;
     }
     else{
          t[r2].ls=merge(r1,t[r2].ls);
          
          maintain(r2);
          return r2;
     }
}
int End(int x){//查询树x里最大的  节点 
    while(t[x].rs)x=t[x].rs;
    return x;
}
int Begin(int x){//查询树x里最小的  节点 
    while(t[x].ls)x=t[x].ls;
    return x;
}
void insert(int val){
    int r1=0,r2=0,r3=0,r4=0;
    split(root,val,r1,r2);
    split(r1,val-1,r3,r4);
    
    if(t[r4].val==val){
        t[r4].cnt++;
        t[r4].size++;
        root=merge(merge(r3,r4),r2);
    }
    else{
        r3=++tot;
        t[r3].val=val;
        t[r3].ls=t[r3].rs=0;
        t[r3].cnt=t[r3].size=1;
        //注意size赋初值合并的时候不一定能更新 
        t[r3].rd=rand();
        
        root=merge(merge(r1,r3),r2);
    }
}
void del(int val){
    int r1=0,r2=0,r3=0,r4=0;
    split(root,val,r1,r2);
    split(r1,val-1,r3,r4);
    if(t[r4].cnt>1){
        t[r4].cnt--;
        t[r4].size--;
        root=merge(merge(r3,r4),r2);
    }
    else{
        root=merge(r3,r2);
    }
}
int rank(int val){
    int r1=0,r2=0;
    split(root,val-1,r1,r2);
    int ans=t[r1].size+1;
    root=merge(r1,r2);
    return ans;
}
int kth(int k){
    int r1=0,r2=0;
    dvd(root,k,r1,r2);
    int ans=t[End(r1)].val;
    root=merge(r1,r2);
    return ans;
}
int pre(int val){
    int r1=0,r2=0;
    split(root,val-1,r1,r2);
    int ans = r1 ? t[End(r1)].val : -1 ;
    root=merge(r1,r2);
    return ans;
}
int suf(int val){
    int r1=0,r2=0;
    split(root,val,r1,r2);
    int ans = r2 ? t[Begin(r2)].val : -1 ;
    root=merge(r1,r2);
    return ans;
}
int main(){    
    srand(time(0));
    
    scanf("%d",&n);
    while(n--){
        scanf("%d%d",&op,&x);
        switch(op){
            case 1:{
                insert(x);
                break;
            }
            case 2:{
                del(x);
                break;
            }
            case 3:{
                printf("%d\n",rank(x));
                break;
            }
            case 4:{
                printf("%d\n",kth(x));
                break;
            }
            case 5:{
                printf("%d\n",pre(x));
                break;
            }
            case 6:{
                printf("%d\n",suf(x));
                break;
            }
        }
    }
    return 0;
} 

！！！网络流 网络流！！！（无比重要的算法，就是O(能过)）

最大流（Dinic）

这东西挺好理解的吧。[NOI2006]最大获利

code:

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e5+5;
const int INF=1e9;
int fst[maxn],nxt[maxn],to[maxn],w[maxn],edge_count;
inline void add(int x,int y,int z){
    edge_count++;
    to[edge_count]=y;
    nxt[edge_count]=fst[x];
    w[edge_count]=z;
    fst[x]=edge_count;
}
inline void insert(int x,int y,int z){add(x,y,z);add(y,x,0);}
int S,T,dis[maxn];
queue<int >q;
inline bool bfs(){
    while(q.size())q.pop();
    memset(dis,0,sizeof dis);
    
    q.push(S);
    dis[S]=1;
    while(q.size()){
        int u=q.front();
        q.pop();
        for(int i=fst[u];i;i=nxt[i]){
            if(!w[i])continue;
            int v=to[i];
            if(!dis[v]){
                dis[v]=dis[u]+1;
                q.push(v);
            }
        }
    }
    return dis[T];
}
int dfs(int u,int fl){
    if(!fl || u==T)return fl;
    int f,flow=0;
    for(int i=fst[u];i;i=nxt[i]){
        int v=to[i];
        if(( dis[v]==dis[u]+1 ) && (f=dfs(v,min(fl,w[i]) ) ) ){
            flow+=f;
            fl-=f;
            w[i]-=f;
            w[i^1]+=f;
            
            if(!fl)break;
        }
    }
    return flow;
}
int n,m,ans;
inline void dinic(){
    while(bfs())ans-=dfs(S,INF);
}
int main(){    
    edge_count=1;
    S=maxn-2;T=maxn-3;

    scanf("%d%d",&n,&m);
    for(int i=1,p;i<=n;i++){
        scanf("%d",&p);
        insert(i,T,p);
    }
    for(int i=1,x,y,z;i<=m;i++){
        scanf("%d%d%d",&x,&y,&z);
        ans+=z;//最大权闭合子图 
        insert(S,i+n,z);
        
        insert(i+n,x,INF);
        insert(i+n,y,INF);
    }
    dinic();
    printf("%d",ans);
    return 0;
}

没有当前弧优化。找不到别的板子了。

 

费用流（原版zkw【注意是原版】，改版zkw，KM）

说一下自己的理解：

Edmond-Karp ，改进之后（用spfa代替bfs）一般的题还是可以的（往往不会卡这个 。吧），然而还是有一道题令我开了O2+O3+O4才过。。。

zkw[original]%zkw,本人blog：https://artofproblemsolving.com/community/c1368h1020435

大致思想说的非常全面（我也不想复制粘贴，毕竟多次翻到同一内容的blog挺烦人的）

至于为什么一直dfs，然后bfs是对的，可能非常玄学吧。

zkw[new]大家好像都写的这个吧。

思路和原版非常像（dinic？），但是是先spfa再增广，不断扩大可行点集，引入新最短路算法：连续最短路。据说可以处理负边权（原版不能）

 【在此，我想作为oier发声：希望一些人不要抄袭别人的blog了，学知识点的时候，翻10多篇才有一篇不一样的，剩下的都是一个模子出来的，复制粘贴？为啥不直接把原博文地址贴上？哪怕是点开+关闭也是需要时间的吧，而且心态也炸了，刚刚一直想矫正一下，zkw能不能负边权，结果翻到好多一样的博客，心态炸了，浪费了1h啥都没干，还有，希望大家写板子的时候，弄清到底是哪个算法。有好几个打着zkw的名号写的别的算法。】

T1:SDOI2017 新生舞会

emmmmmm自己写的多路增广（就不瞎jb起名字了，我也不知道是smjb算法），就是spfa求出最短路，dfs实现多路增广（和 ek有区别么？）

code(和dinic几乎完全相同):

#include<bits/stdc++.h>
#define boy(x) (x<<1)
#define girl(x) (x<<1|1)
using namespace std;
const int maxn=1e2+5;
const double inf=10000000000.0;
const double eps=1e-6;
inline bool equal(double a,double b){return fabs(a-b)<=eps;}
int a[maxn][maxn],b[maxn][maxn],n;
int cur[maxn<<1],fst[maxn<<1],to[maxn*maxn<<2],nxt[maxn*maxn<<2],w[maxn*maxn<<2],edge_count;
double c[maxn*maxn<<2];
inline void add(int x,int y,int flow,double cost){
    edge_count++;
    nxt[edge_count]=fst[x];
    fst[x]=edge_count;
    w[edge_count]=flow;
    c[edge_count]=cost;
    to[edge_count]=y;
}
double maxcost;
inline void add_edge(int x,int y,int flow,double cost){add(x,y,flow,cost);add(y,x,0,-cost);}
inline void clear(){
    memset(fst,0,sizeof fst);
    edge_count=1;
    maxcost=0.0;
}
int S=1,T=(maxn-1)<<1;
bool vis[maxn<<1];
double dis[maxn<<1];
queue<int > q;
inline bool SPFA(){
    for(int i=boy(1);i<=girl(n);i++)dis[i]=-inf,cur[i]=fst[i],vis[i]=0;
    dis[T]=-inf;cur[T]=fst[T];vis[T]=0;
    dis[S]=0.0;cur[S]=fst[S];
    
    q.push(S);vis[S]=1;
    while(q.size()){
        int u=q.front();q.pop();
        vis[u]=0;
        for(int i=fst[u];i;i=nxt[i]){
            int v=to[i];
            if(w[i] && ( dis[u]+c[i] > dis [v] ) ){
                dis[v]=dis[u]+c[i];
                if(!vis[v]){
                    q.push(v);
                    vis[v]=1;
                }
            }
        }
    }
    return !equal(dis[T],-inf);
}
int dfs(int u,int flow){//死循环原因：标记是否达到 
    if(!flow || u==T)return flow;
    //sb错误原因：一种写法是整个dfs结束时，mc+=dis[T]*flow 但是有个问题在于，可能进入T点但是不是合法路径（最长路） 
    int fl=0,f;vis[u]=1;
    for(int &i=cur[u];i;i=nxt[i]){
        int v=to[i];
        if(vis[v])continue;
        if( equal(dis[u]+c[i],dis[v])&&( f=dfs(v,min(flow,w[i])) )  ){
        //!!!!!!!!逻辑算符 bool f1() && bool f2()    会在f1()=0时，放弃计算f2()    
            w[i]-=f;
            w[i^1]+=f;
            fl+=f;
            flow-=f;
            maxcost+=c[i]*f;
            if(!flow)break;
        }
    }
    return fl;
}
inline void MCMF(){//最大费用最大流  zkw???
    while(SPFA()){
        dfs(S,n);
    }
}
inline bool judge(double ans){
    clear();
    for(int i=1;i<=n;i++){
        add_edge(S,boy(i),1,0.0);
        add_edge(girl(i),T,1,0.0);
        for(int j=1;j<=n;j++)
        add_edge(boy(i),girl(j),1,1.0*a[i][j]-ans*b[i][j]);
    }
    MCMF();
    return maxcost>=0.0 ;
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)scanf("%d",&a[i][j]);
    for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)scanf("%d",&b[i][j]);
    double l=0.0,r=10000.0;
    double mid=(l+r)/2.0;
    for(int i=1;i<=40;i++){
        if(judge(mid))l=mid;
        else r=mid;
        mid=(l+r)/2.0;
    }
    printf("%.6lf",l);
    return 0;
}

update:才知道自己写错了。附上正确模板 【luogu P3381】【模板】最小费用最大流

#include<bits/stdc++.h>
#define LL long long
#define rep(i,l,r) for(int i=(l);i<=(r);i++)
using namespace std;
const int inf=1e9;
template<typename T>
inline void read(T &a){
    a=0;bool b=0;char x=getchar();
    while(x<'0'||'9'<x){
        if(x=='-')b=1;
        x=getchar();
    }
    while('0'<=x&&x<='9'){
        a=(a<<1)+(a<<3)+x-'0';
        x=getchar();
    }
    if(b)a=-a;
}
char C_[50];
int TEMP;
template<typename T>
inline void write(T a){
    if(a<0){
         putchar('-');
         a=-a;
    }
    do{
         C_[++TEMP]=a%10+'0';
         a/=10;
    }while(a);
    while(TEMP)putchar(C_[TEMP--]);
}
const int maxn=5005;
const int maxm=50005;
int cur[maxn],fst[maxn],nxt[maxm<<1],to[maxm<<1],w[maxm<<1],c[maxm<<1],edge_count;
inline void add(int x,int y,int flow,int cost){
    edge_count++;
    to[edge_count]=y;
    w[edge_count]=flow;
    c[edge_count]=cost;
    nxt[edge_count]=fst[x];
    fst[x]=edge_count;
}
int S,T;
LL dis[maxn];
queue<int >q;
bool vis[maxn];
LL maxflow,mincost;
inline bool SPFA(){
    rep(i,1,maxn-1)dis[i]=inf,vis[i]=0,cur[i]=fst[i];
    dis[S]=0;vis[S]=1;
    q.push(S);
    while(q.size()){
        int u=q.front();q.pop();
        vis[u]=0;
        for(int i=fst[u];i;i=nxt[i]){
            int v=to[i];
            if(w[i] && dis[v] > dis[u] + c[i]){
                dis[v]=dis[u]+c[i];
                if(!vis[v]){
                    vis[v]=1;
                    q.push(v);
                }
            }
        }
    }
    return dis[T]<inf;
}
int dfs(int u,int flow){
    if(!flow || u==T)return flow;
    int fl=0,f;vis[u]=1;
    for(int &i=cur[u];i;i=nxt[i]){
        int v=to[i];
        if(!vis[v] && dis[v]==dis[u]+c[i] && ( f=dfs(v,min(flow,w[i] ) ) ) ){
            w[i]-=f;
            w[i^1]+=f;
            fl+=f;
            flow-=f;
            mincost+=f*c[i];
            if(!flow)break;
        }
    }
    vis[u]=0;//一定要加的。就像打标记一样 
    return fl;
}
inline void MCMF(){
    while(SPFA())maxflow+=dfs(S,inf);
}
int n,m;
int main(){
    edge_count=1;
    scanf("%d%d%d%d",&n,&m,&S,&T);
    rep(i,1,m){
        int a,b,c,d;
        scanf("%d%d%d%d",&a,&b,&c,&d);
        add(a,b,c,d);add(b,a,0,-d);
    }
    MCMF();
    printf("%lld %lld",maxflow,mincost);
     return 0;
}

T2:？？？神奇建图模型

【题目描述】

给定一颗N个点的有根树，其中1是树根，除了1以外的其他点u有唯一的父亲Fatheru。同时，给定M条路径，第i条路径是(si,ti)，保证si是ti的祖先。你需要给每条路径染上红色或者蓝色。对于第i条路径，如果把它染成红色，需要花费代价pathRi；否则染成蓝色，需要花费代价pathBi。对于每个不是1的点u，考虑其连接它的父亲Fatheru的边，需要满足如下两个条件：

（1）覆盖了这条边，同时被染成红色的路径不超过Ru条；

（2）覆盖了这条边，同时被染成蓝色的路径不超过Bu条。

同时，对于这条边，如果有x条覆盖了它且被染成红色的路径，需要花费代价x×edgeRu；如果有y条覆盖了它且被染成蓝色的路径，需要花费代价y×edgeBu。

请你求出一个合法的染色方案，同时最小化它的代价。如果无解，请输出−1。

【输入格式】第一行两个非负整数N和M，表示树的点数和路径条数。接下来N−1行，第i行五个个非负整数Fatheri+1,Ri+1,Bi+1,edgeRi+1和edgeBi+1描述每个不是根的点的父亲

对连接父亲这条边的限制，以及代价的系数。接下来M行，第i行四个非负整数si,ti,pathRi和pathBi描述第i条路径。

【输出格式】如果有解则输出一行一个非负整数，表示最小的代价；否则输出−1表示无解。

显然这种费用最小，流量有限制的应该考虑网络流（费用流），但是没有想到比较好的建图方式，会出现“串边”的问题，就是从一条路径的ti进入从另一条路径的sj流出，这显然是不合法的，

我们需要做一些调整，首先发现，可以先让所有的路径都染成一个颜色，然后再作调整。（qzh：分RB两颗树，会串边（R经过次数和B经过次数都不同），一棵树不会）

调整如下：每条路径上的点，有两种选择：1.全变成另一种颜色，2.保持原来颜色

两种情况都必须：1.ti->si两个点都要有流量流入（上界=下界=1）

2.出现路径交叉不合法（交叉路径同色：无影响，交叉路径不同色：如下图）

【已经先染蓝色，向里面添加红色路径】

发现串边的情况并不存在（简单依次证明，或者说明流量守恒）

所以保留1.树边，[?,?],费用为er-eb，单位流量表示选择染红色

2.ti->si，[0,1],费用为pathB-pathR，单位流量表示选择染蓝色

3.S->ti，si->T，[1,1],费用为0，表示必须选

有上下界最小费最大流【注意建完新图之后，直接跑费用流就行，不用先求可行流，本质上是一样的】

code：

#include<bits/stdc++.h>
#define rep(i,l,r) for(int i=(l);i<=(r);i++)
#define LL long long 
using namespace std;
const int maxn=200;
const LL inf=1e9;
int cur[maxn+10],fst[maxn+10],nxt[100000],w[100000],to[100000],c[100000],edge_count;
inline void add(int x,int y,int flow,int cost){
    edge_count++;
    to[edge_count]=y;
    w[edge_count]=flow;
    c[edge_count]=cost;
    nxt[edge_count]=fst[x];
    fst[x]=edge_count;
}
int d[maxn+10];//d[i]=in-out
int S,T,ss,tt;
inline void add(int x,int y,int down,int up,int cost){
    add(x,y,up-down,cost);add(y,x,0,-cost);
    d[y]+=down;d[x]-=down;
}
int n,m;
LL dis[100000];
queue<int >q;
bool vis[100000];
LL maxflow,mincost;
inline bool SPFA(){
    while(q.size())q.pop();
    
    rep(i,1,tt)dis[i]=inf,vis[i]=0,cur[i]=fst[i];
    dis[ss]=0;vis[ss]=1;
    q.push(ss);
    while(q.size()){
        int u=q.front();q.pop();
        vis[u]=0;
        for(int i=fst[u];i;i=nxt[i]){
            int v=to[i];
            if(w[i] && dis[v] > dis[u] + c[i]){
                dis[v]=dis[u]+c[i];
                if(!vis[v]){
                    vis[v]=1;
                    q.push(v);
                }
            }
        }
    }
    return dis[tt]<inf;
}
int dfs(int u,int flow){
    if(!flow || u==tt)return flow;
    int fl=0,f;vis[u]=1;//must 
    for(int &i=cur[u];i;i=nxt[i]){
        int v=to[i];
        if( ! vis[v] && dis[v]==dis[u]+c[i] && ( f=dfs(v,min(flow,w[i] ) ) ) ){
            //^ must 
            w[i]-=f;
            w[i^1]+=f;
            fl+=f;
            flow-=f;
            mincost+=f*c[i];
            if(!flow)break;
        }
    }
    vis[u]=0;//must 
    return fl;
}
inline void MCMF(){
    while(SPFA())maxflow+=dfs(ss,inf);
}
int fa[maxn],r[maxn],b[maxn],er[maxn],eb[maxn],cnt[maxn],s[maxn],t[maxn],pr[maxn],pb[maxn];
inline void clear(){
    memset(fst,0,sizeof fst);
    edge_count=1;
}
int main(){
    scanf("%d%d",&n,&m);
    S=n+1;T=S+1;ss=T+1;tt=ss+1;
    rep(i,2,n)scanf("%d%d%d%d%d",&fa[i],&r[i],&b[i],&er[i],&eb[i]);
    clear();
    rep(i,1,m){
        scanf("%d%d%d%d",&s[i],&t[i],&pr[i],&pb[i]);
        add(S,t[i],1,1,0);
        add(s[i],T,1,1,0);
        add(t[i],s[i],0,1,pb[i]-pr[i]);
        mincost+=pr[i];
        while(t[i]!=s[i]){
            cnt[t[i]]++;
            mincost+=eb[t[i]];
            t[i]=fa[t[i]];
        }
    }
    rep(i,2,n){
        if(r[i]+b[i]<cnt[i]){
            printf("-1");
            return 0;
        }
        add(i,fa[i],cnt[i]-b[i],r[i],er[i]-eb[i]);
        mincost+=(cnt[i]-b[i])*(er[i]-eb[i]);
    }
    add(T,S,0,inf,0);
    rep(i,1,T){
        if(d[i]>0)add(ss,i,0,d[i],0);
        else add(i,tt,0,-d[i],0);
    }
    MCMF();
    printf("%lld",mincost);
    return 0;
}

（注意加反向边）

LCT：非常重要的数据结构（都挺重要，难写难调）

容易T掉，注意常数，本蒟蒻就没注意。

#include<bits/stdc++.h>
#define LL long long
using namespace std;
template<typename T>
inline void read(T &a){
    a=0;bool b=0;char x=getchar();
    while(x<'0'||'9'<x){
        if(x=='-')b=1;
        x=getchar();
    }
    while('0'<=x&&x<='9'){
        a=(a<<1)+(a<<3)+x-'0';
        x=getchar();
    }
    if(b)a=-a;
}
char C_[50];
int TEMP;
template<typename T>
inline void write(T a){
    if(a<0){
         putchar('-');
         a=-a;
    }
    do{
         C_[++TEMP]=a%10+'0';
         a/=10;
    }while(a);
    while(TEMP)putchar(C_[TEMP--]);
}
const int maxn=2e5;
struct Node{
    int fa,ch[2],val,xsum;
    bool rev;
    Node(){
        fa=ch[0]=ch[1]=val=xsum=rev=0;
    }
}t[maxn];
int n,m;
inline void maintain(int x){
    t[x].xsum=t[x].val^t[t[x].ch[1]].xsum^t[t[x].ch[0]].xsum;
}
inline void pushrev(int x){
    swap(t[x].ch[1],t[x].ch[0]);
    t[x].rev^=1;
}
inline void pushdown(int x){
    if(t[x].rev){
        if(t[x].ch[0])pushrev(t[x].ch[0]);
        if(t[x].ch[1])pushrev(t[x].ch[1]);
        t[x].rev=0;
    }
}
inline int get(int x){
    if(x!=t[t[x].fa].ch[1]&&x!=t[t[x].fa].ch[0])return -1;
    else return x==t[t[x].fa].ch[1];
}
inline void rotate(int x){
    int f=t[x].fa;
    bool b=get(x);
    if(get(f)!=-1)t[t[f].fa].ch[get(f)]=x;//不用担心虚边会错连成实边 
    t[x].fa=t[f].fa;
    t[f].fa=x;
    t[f].ch[b]=t[x].ch[!b];
    if(t[f].ch[b])t[t[f].ch[b]].fa=f;
    t[x].ch[!b]=f;
    maintain(f);//多更新好多次 
}
inline void print(int x){
    if(t[x].ch[0])print(t[x].ch[0]);
    printf(" %d %d:%d",t[x].fa,x,t[x].rev);
    if(t[x].ch[1])print(t[x].ch[1]);
}
inline void splay(int x){
//    if(get(x)==-1)return;//注意！！！不能直接返回，否则标记无法放掉，出现鬼畜错误     
    stack<int >sta;
//标记一定???从上往下放：否则会出现下面标记放掉，上面标记任在，放不完全的问题
//防止找根时出错？？？ 
    int f=x;
    sta.push(x);
    while(get(f)!=-1){
        sta.push(t[f].fa);
        f=t[f].fa;
    }
    while(sta.size()){
        pushdown(sta.top());
        sta.pop();
    }
    while(get(x)!=-1){
        f=t[x].fa;
        if(get(f)!=-1 && get(f)==get(x))rotate(f);
        else rotate(x);
    }
    maintain(x);
}
inline void access(int x){
    for(int y=0;x;y=x,x=t[x].fa){//注意y=0，保证第一次断开实边 
        splay(x);
        t[x].ch[1]=y;
        maintain(x);//儿子有变，更新 
    }
}
inline void makeroot(int x){
    access(x);
    splay(x);
    pushrev(x);
}
inline int findroot(int x){
    access(x);
    //if(x==3)for(int i=1;i<=n;i++)print(i),putchar('\n'); 
    splay(x);
    //if(x==3)for(int i=1;i<=n;i++)print(i),putchar('\n'); 
    while(t[x].ch[0]){
        pushdown(x);//???
        x=t[x].ch[0];
    }
    splay(x);
    //if(x==3)for(int i=1;i<=n;i++)print(i),putchar('\n'); 
    return x;
}
inline bool link(int x,int y){
    makeroot(x);
    //for(int i=1;i<=n;i++)print(i),putchar('\n'); 
    if(x==findroot(y))return 0;
    t[x].fa=y;
    return 1;
}
inline bool cut(int x,int y){
    makeroot(x);
    if(findroot(y)!=x || t[y].fa!=x || t[y].ch[0])return 0;
    t[y].fa=t[x].ch[1]=0;
    maintain(x);//没有儿子，更新 
    return 1;
}
inline void split(int x,int y){
    makeroot(x);
    access(y);
    splay(y);
    //print(y);putchar('\n');
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%d",&t[i].val);
        t[i].xsum=t[i].val;
    }
    for(int i=1,opt,x,y;i<=m;i++){
        scanf("%d%d%d",&opt,&x,&y);
        if(!opt){
            split(x,y);
            printf("%d\n",t[y].xsum);
        }
        else if(opt==1){
            link(x,y);
        }
        else if(opt==2){
            cut(x,y);
        }
        else {
            splay(x);
            t[x].val=y;
            maintain(x);
        }
    //    for(int i=1;i<=n;i++)print(i),putchar('\n'); 
    }
     return 0;
}

 好啦好啦，我又回来啦。

那么复习数据结构吧，刚刚看了看单调栈这个东西，发现并没有想象中那么简单，这东西本质上是维护一个单调的序列，但是并不只是能求出该位置前后第一个> or < 的位置，还是可以利用单调性做些事情的

BZOJ2086

自己也是退役很久了，都不太会做题了，T1就不会了。

O(n)求出比一个数大的最后位置（比一个数小的最前位置），我们发现，如果一个序列是单调的，那么他只有第一个位置有意义，所以我们利用这个性质，用一个位置代替后面所有不如他优的位置，也就是单调栈，然后再进行比较，可以得到答案。

#include<bits/stdc++.h>
#define LL long long 
#define rep(i,l,r) for(int i=l;i<=r;i++)
#define irp(i,r,l) for(int i=r;i>=l;i--)
using namespace std;
template<typename T>
inline void read(T &x){
    char ch;x=0;ch=getchar();bool b=0;
    while(ch<'0' || '9'<ch){
        if(ch=='-')b=1;
        ch=getchar();
    }
    while('0'<=ch && ch<='9'){
        x=(x<<1)+(x<<3)+ch-'0';
        ch=getchar();
    }
    if(b)x=-x;
}
const int maxn=1e6+5;
LL sum[maxn];
int n,m,a[maxn],k;
int sta[maxn],p;
int main(){
    read(n);read(m);
    rep(i,1,n)read(a[i]);
    while(m--){
        p=0;
        int ans=0;
        read(k);
        rep(j,1,n){
            sum[j]=sum[j-1]+a[j]-k;
            if(sum[j]<sum[sta[p]])sta[++p]=j;
        }
        irp(j,n,1){
            while(sum[sta[p-1]]<=sum[j] && p)p--;
            ans=max(ans,j-sta[p]);
        }
        printf("%d ",ans);
    }
    return 0;
}

单调队列的理解：同单调栈一样，并不只局限于维护定长序列的最大or最小值。而是在维护单调性的同时满足一些其他的性质，在不满足的时候，让左端电来回移动。然后右端点在添加的时候维护这个性质，从而得到我们想要的东西。

BZOJ2276

这个题，让我们在一堆不等式里选一段连续的，并且可以得到不降解。

那么我们发现，一个新增加的上届，仅仅对之前的解有影响，也就是说，之前的下界都得<=当前上界，所以这个东西就成为我们维护左端点的依据，然后，我们所要求的区间，下届的只要<=当前上界就可以了。那么我们维护单调减队列。

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e6+5;
int n,l[maxn],r[maxn],ans;
int q[maxn],front,rear,lft=1;
bool ban[maxn];
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d%d",&l[i],&r[i]);
    
    q[front=1]=1;
    for(int i=1;i<=n;i++){//右端点 逼迫 左端点(允许温度的最小值)的最大值 
        
        if(front<=rear){
            while(front<=rear && l[ q[rear] ]<=l[i]){
                rear--;
            }
        }
        q[++rear]=i; 
        
        while(front<=rear && l[ q[front] ]>r[i]){
            lft++;
            if(lft>q[front])front++;
        }
        ans=max(ans,i-lft+1);
    }
    printf("%d",ans);
    return 0;
}