【NOI赛前训练】——专项测试1·网络流

T1：

题目大意：

　　传送门

　　给一个长度为$n（n<=200）$的数列$h$，再给$m$个可以无限使用的操作，第$i$个操作为给长度为花费$c_i$的价值给长度为$l_i$的数列子序列+1或-1，求将数列变为不下降数列的最小花费。

题解：

第一部分（上下界最小费用可行流）：　　

　　设$h_0=-inf,h_{n+1}=inf$，令$a$为$h$的差分数组，即$a_i=h_{i}-h_{i-1}$。考虑当对于区间$[l,r]$操作时（比如+1），相当于$a_{r+1}$减少1,$a_{l}$增加1。若将$a$数组看做点集，这个变化相当于从$r+1$到$l$的一条流量为$1$的有向边，反之（-1）亦然。

　　显然问题相当于把$a$数组元素均变为 不为0。那么我们由S向$a_{i}>0$的位置连$flow=[0,a_{i}],cost=0$的边，表示${i}$可以减少流量上下界，对于$a_{i}<0$的位置，我们至少要使其增加$-a_i$所以我们向$T$连$flow=[-a_i,inf]，cost=0$的边。对于每个操作我们由于可无限使用我们就给所有合法位置连$flow=[0,inf],cost=c_{i}$的边，然后我们可以跑一个上下界解决问题。

　　等等，这样的确解决了问题，不过我们观察一下这个图，会发现上下界源点只连向了$T$，而上下界汇点只被那些$a_{i}<0$的点连接到。

　　我们把这个图转化一下，会发现对于上面的建图方式，我们只把$a_{i}<0$的边建成$flow=-a_i，cost=0$的边即可，根本不需要跑上下界。这就是另外一种思考方式。

第二部分（最小费用最大流）：

　　我们考虑那些$a_{i}<0$的点变为$0$一定比使其变为任一整数更优秀，同时这也是我们的判断有没有解的依据。

　　所以我们就直接由$a_{i}<0$的点连向$T$的边为$flow=-a_i,cost=0$即可，如果所有连向$T$的边都流满，说明有解，同时由于上述性质，一定是最优解。

　　

　　不过这两个时间复杂度并没有太大区别。

代码：

#include "bits/stdc++.h"

using namespace std;

#define inf 0x3f3f3f3f

inline int read() {
    int s=0,k=1;char ch=getchar ();
    while (ch<'0'|ch>'9') ch=='-'?k=-1:0,ch=getchar();
    while (ch>47&ch<='9') s=s*10+(ch^48),ch=getchar();
    return s*k;
}

const int N=1e3+10;

struct edges {
    int v,cap,cost;edges *pair,*last;
}edge[N*N],*head[N];int cnt;

inline void push(int u,int v,int cap,int cost) {
    edge[++cnt]=(edges){v,cap,cost,edge+cnt+1,head[u]},head[u]=edge+cnt;
    edge[++cnt]=(edges){u,0,-cost,edge+cnt-1,head[v]},head[v]=edge+cnt;
}

int S,T,ss,tt,n,fl,m;
int piS,vis[N];
long long cost;

inline int aug(int x,int w) {
    if (x==T) return cost+=1ll*piS*w,fl+=w,w;
    vis[x]=true;
    int ret=0;
    for (edges *i=head[x];i;i=i->last)
        if (i->cap&&!i->cost&&!vis[i->v])   {
            int flow=aug(i->v,min(i->cap,w));
            i->cap-=flow,i->pair->cap+=flow,ret+=flow,w-=flow;
            if (!w) break;
        }
    return ret;
}

inline bool modlabel() {
    static int d[N];
    memset(d,0x3f,sizeof d);d[T]=0;
    static deque<int> q;q.push_back(T);
    int dt;
    while (!q.empty()) {
        int x=q.front();q.pop_front();
        for (edges *i=head[x];i;i=i->last)  
            if (i->pair->cap&&(dt=d[x]-i->cost)<d[i->v])
                (d[i->v]=dt)<=d[q.size()?q.front():0]
                    ?q.push_front(i->v):q.push_back(i->v);
    }
    for (int i=S;i<=T;++i)
        for (edges *j=head[i];j;j=j->last)
            j->cost+=d[j->v]-d[i];
    piS+=d[S];
    return d[S]<inf;
}

inline void solve() {
    piS = cost = 0;
    while(modlabel())
        do memset(vis,0,sizeof vis); 
    while(aug(S, inf));
}

int h[N],a[N],c[N],l[N],typ[N];
int f[N],g[N];

int main(){
    n=read(),m=read();
    for (int i=1;i<=n;++i)
        h[i]=read();
    for (int i=n;i>1;--i)
        h[i]=h[i]-h[i-1];
    h[1]=inf,h[n+1]=inf;
    ss=n+2,tt=ss+1,T=tt+1;
    char opt[2];
    for (int i=1;i<=m;++i) {
        scanf("%s",opt),l[i]=read(),c[i]=read();
        typ[i]=opt[0]=='+';
    }
    ++n;
    for (int i=1;i<=n;++i)
        if (h[i] > 0)
            push(ss,i,h[i],0);
        else if(h[i]<0)  push(i,tt,inf,0),a[i]=-h[i],a[tt]+=h[i],push(i,T,a[i],0);
    push(tt,ss,inf,0);
    push(S,tt,-a[tt],0);
    memset(f,0x3f,sizeof(f));
    f[0]=0;
    memcpy(g,f,sizeof g);
    for (int j=1;j<=m;++j)  
        for (int k=l[j];k<=n;k+=l[j])
            if(typ[j])  
                for (int i=n-1;i>=l[j];--i)
                    f[i]=min(f[i],f[i-l[j]]+c[j]);
            else 
                for (int i=n-1;i>=l[j];--i)
                    g[i]=min(g[i],g[i-l[j]]+c[j]);
    // puts()
    for (int j=1;j<=m;++j)  
        if (typ[j]){
            if (f[l[j]]==c[j])  
                for (int i=l[j]+1;i<=n;++i)
                    push(i,i-l[j],inf,c[j]);
        }else 
            if (g[l[j]]==c[j])
                for (int i=1;i+l[j]<=n;++i)
                    push(i,i+l[j],inf,c[j]); 
    solve();
    if (fl==-a[tt])
        printf("%lld\n",cost);
    else puts("-1");
}

#include "bits/stdc++.h"

using namespace std;

#define inf 0x3f3f3f3f

inline int read() {
    int s=0,k=1;char ch=getchar ();
    while (ch<'0'|ch>'9') ch=='-'?k=-1:0,ch=getchar();
    while (ch>47&ch<='9') s=s*10+(ch^48),ch=getchar();
    return s*k;
}

const int N=1e3+10;

struct edges {
    int v,cap,cost;edges *pair,*last;
}edge[N*N],*head[N];int cnt;

inline void push(int u,int v,int cap,int cost) {
    edge[++cnt]=(edges){v,cap,cost,edge+cnt+1,head[u]},head[u]=edge+cnt;
    edge[++cnt]=(edges){u,0,-cost,edge+cnt-1,head[v]},head[v]=edge+cnt;
}

int S,T,ss,tt,n,fl,m;
int piS,vis[N];
long long cost;

inline int aug(int x,int w) {
    if (x==T) return cost+=1ll*piS*w,fl+=w,w;
    vis[x]=true;
    int ret=0;
    for (edges *i=head[x];i;i=i->last)
        if (i->cap&&!i->cost&&!vis[i->v])   {
            int flow=aug(i->v,min(i->cap,w));
            i->cap-=flow,i->pair->cap+=flow,ret+=flow,w-=flow;
            if (!w) break;
        }
    return ret;
}

inline bool modlabel() {
    static int d[N];
    memset(d,0x3f,sizeof d);d[T]=0;
    static deque<int> q;q.push_back(T);
    int dt;
    while (!q.empty()) {
        int x=q.front();q.pop_front();
        for (edges *i=head[x];i;i=i->last)  
            if (i->pair->cap&&(dt=d[x]-i->cost)<d[i->v])
                (d[i->v]=dt)<=d[q.size()?q.front():0]
                    ?q.push_front(i->v):q.push_back(i->v);
    }
    for (int i=S;i<=T;++i)
        for (edges *j=head[i];j;j=j->last)
            j->cost+=d[j->v]-d[i];
    piS+=d[S];
    return d[S]<inf;
}

inline void solve() {
    piS = cost = 0;
    while(modlabel())
        do memset(vis,0,sizeof vis); 
    while(aug(S, inf));
}

int h[N],a[N],c[N],l[N],typ[N];
int f[N],g[N];

int main(){
    n=read(),m=read();
    for (int i=1;i<=n;++i)
        h[i]=read();
    for (int i=n;i>1;--i)
        h[i]=h[i]-h[i-1];
    h[1]=inf,h[n+1]=inf;
    // ss=n+2,tt=ss+1,T=tt+1;
    char opt[2];
    for (int i=1;i<=m;++i) {
        scanf("%s",opt),l[i]=read(),c[i]=read();
        typ[i]=opt[0]=='+';
    }
    ++n;T=n+1;
    for (int i=1;i<=n;++i)
        if (h[i] > 0)
            push(S,i,h[i],0);
        else if(h[i]<0)  push(i,T,-h[i],0),a[tt]+=h[i];//,push(i,T,a[i],0);
    // push(tt,ss,inf,0);
    // push(S,tt,-a[tt],0);
    memset(f,0x3f,sizeof(f));
    f[0]=0;
    memcpy(g,f,sizeof g);
    for (int j=1;j<=m;++j)  
        for (int k=l[j];k<=n;k+=l[j])
            if(typ[j])  
                for (int i=n-1;i>=l[j];--i)
                    f[i]=min(f[i],f[i-l[j]]+c[j]);
            else 
                for (int i=n-1;i>=l[j];--i)
                    g[i]=min(g[i],g[i-l[j]]+c[j]);
    for (int j=1;j<=m;++j)  
        if (typ[j]){
            if (f[l[j]]==c[j])  
                for (int i=l[j]+1;i<=n;++i)
                    push(i,i-l[j],inf,c[j]);
        }else 
            if (g[l[j]]==c[j])
                for (int i=1;i+l[j]<=n;++i)
                    push(i,i+l[j],inf,c[j]); 
    solve();
    // printf("%d %d\n",fl);
    if (fl==-a[tt])
        printf("%lld\n",cost);
    else puts("-1");
}

 

T2：

题目大意：

　　emmm，由于并没在网上找到这题，题意我就不发了，仅供自己记忆233。

题解：

　　这是一道及其简单的模拟网络流最小割的静态仙人掌。（完全不需要题意……各位就知道了）

　　没什么好说的……

　　tajan缩点，树剖+线段树维护，以及8k代码。没了。

代码：

#include "bits/stdc++.h"

inline int read(){
    int s=0,k=1;char ch=getchar();
    while (ch<'0'|ch>'9') ch=='-'?k=-1:0,ch=getchar();
    while (ch>47&ch<='9') s=s*10+(ch^48),ch=getchar();
    return s*k;
}

using namespace std;

#define inf 0x7fffffff

const int N=5e5+10,M=1e6+10;

struct node {
    int a,b,w,id;
}line[N];

struct edges{
    int v,w;edges *last;node *id;
}edge[N<<1],*head[N];int cnt=1;

inline void push(int u,int v,int w){
    edge[++cnt]=(edges) {v,w,head[u]},head[u]=edge+cnt;
}

int bccno[N],bcc_cnt,low[N],dfn[N],idx,stk[N],top,size[N],aa[N];
bool vis[N],used[N];

inline void tarjan(int x,int fa) {
    low[x]=dfn[x]=++idx;
    stk[++top]=x;
    for (edges *i=head[x];i;i=i->last)  if(i->v!=fa) {
        if(!dfn[i->v])
            tarjan(i->v,x),
            low[x]=min(low[x],low[i->v]);
        else    low[x]=min(low[x],dfn[i->v]);
    }
    if(dfn[fa]<low[x]) {
        bcc_cnt++;int t;
        do t=stk[top--],bccno[t]=bcc_cnt,++size[bcc_cnt];while (t!=x);
    }
}

struct Tree {
    int val;
    Tree *lc,*rc;
    inline void update() {
        val=min(lc->val,rc->val);
    }
}tree[N<<3];int cnt_tree;

struct Segment{
    Tree *root;

    inline void build(Tree *&u,int l,int r) {
        if(!u) u=tree+cnt_tree,cnt_tree++;
        if(l==r)  return void(u->val=aa[l]);
        int mid=l+r>>1;
        build(u->lc,l,mid);
        build(u->rc,mid+1,r);
        u->update();
    }

    inline void change(Tree *u,int l,int r,int x,int val){
        if(l==r) return void(u->val=val);
        int mid=l+r>>1;
        if (x>mid) change(u->rc,mid+1,r,x,val);
        else change(u->lc,l,mid,x,val);
        u->update();
    }

    inline int query(Tree *u,int l,int r,int x,int y) {
        if (x>y) return inf;
        if(x<=l&&r<=y) return u->val;
        int mid=l+r>>1,ret=0x7fffffff;
        if (y>mid) ret=query(u->rc,mid+1,r,x,y);
        if(x<=mid) ret=min(ret,query(u->lc,l,mid,x,y));
        return ret;
    }
}seg[N],rt,sft;

int n,m,pos[N];
vector<int> bcc[N],val[N];

inline void dfs(int x) {
    vis[x]=true;    
    bcc[bccno[x]].push_back(x);
    pos[x]=bcc[bccno[x]].size();
    for (edges *i=head[x];i;i=i->last)  {
        if (!vis[i->v]&&bccno[x]==bccno[i->v]){        
        i->id->id=pos[x],val[bccno[x]].push_back(i->w),used[i-edge]=used[(i-edge)^1]=true;
        dfs(i->v);
    }
    }
    if(pos[x]==size[bccno[x]])
        for (edges *i=head[x];i;i=i->last)  if (!used[i-edge]&&bcc[bccno[x]][0]==i->v)
            i->id->id=pos[x],val[bccno[x]].push_back(i->w);
}

int heavy[N],sz[N],fat[N],gra[N],deep[N],tid[N],rid[N],up[N],down[N],upb[N];

inline void dfs(int x,int fa){
    sz[x]=1;
    for (edges *i=head[x];i;i=i->last)   if(i->v!=fa){
        deep[i->v]=deep[x]+1,dfs(i->v,x);
        sz[x]+=sz[i->v];
        if (sz[heavy[x]]<sz[i->v])
            heavy[x]=i->v;
    }
    fat[x]=fa;
}

inline void dfs(int x,int fa,int gr) {
    gra[x]=gr;
    tid[x]=++tid[0];
    rid[tid[0]]=x;
   
    if (heavy[x]) {
        dfs(heavy[x],x,gr);
        for (edges *i=head[x];i;i=i->last)  if (i->v!=fa&&i->v!=heavy[x])
            dfs(i->v,x,i->v);
        for (edges *i=head[x];i;i=i->last)  if (i->v!=fa)
            aa[tid[i->v]]=i->w;
    } 
}

inline int query(int x,int l,int r){
    if (l==r) return inf;
    if (l>r) swap(l,r);
    return     seg[x].query(seg[x].root,1,size[x],l,r-1)+
           min(seg[x].query(seg[x].root,1,size[x],r,n),
               seg[x].query(seg[x].root,1,size[x],1,l-1)) ;
}

inline void sdfs(int x) {
    for (edges *i=head[x];i;i=i->last) if(i->v!=fat[x]){ 
        up[i->v]=deep[bccno[i->id->a]]>deep[bccno[i->id->b]]?i->id->a:i->id->b;
        upb[i->v]=i->id->a^i->id->b^up[i->v];        
        sdfs(i->v);            
        if (i->v==heavy[x]) 
            down[x]=deep[bccno[i->id->a]]<deep[bccno[i->id->b]]?i->id->a:i->id->b;
        if (i->v==heavy[x]&&fat[x])     {
            int l=pos[up[x]],r=pos[down[x]];
            aa[tid[x]]=query(x,l,r);
        }
    }
}

inline void change(int id,int f) {
    int a=line[id].a,b=line[id].b;
    if (bccno[a]^bccno[b])    {
        a=bccno[a],b=bccno[b];
        if (deep[a]<deep[b]) swap(a,b);        
        rt.change(rt.root,1,bcc_cnt,tid[a],f);
    }else {
        b=bccno[a];
        seg[b].change(seg[b].root,1,size[b],line[id].id,f);
        if (up[b]&&down[b]) {
            int l=pos[up[b]],r=pos[down[b]],val=query(b,l,r);
            sft.change(sft.root,1,bcc_cnt,tid[b],val);
        }
    }
}

inline int query (int x,int y){
    int ret=inf;
    if (bccno[x]==bccno[y]) {
        int l=pos[x],r=pos[y];
        return query(bccno[x],l,r);
    }
    int a=x,b=y;
    x=bccno[x],y=bccno[y];
    while (gra[x]!=gra[y]) {
        if (deep[gra[x]]<deep[gra[y]]) swap(x,y),swap(a,b);
        ret=min(ret,rt.query(rt.root,1,bcc_cnt,tid[gra[x]],tid[x]));
        int l,r;
        l=pos[a],r=pos[up[x]];
        ret=min(ret,query(x,l,r));
        a=upb[gra[x]];
        if (gra[fat[x]]==gra[x])    {    
            x=fat[x];
            ret=min(ret,sft.query(sft.root,1,bcc_cnt,tid[gra[x]],tid[x]));
        }
        x=fat[gra[x]];
    }
    if (deep[x]>deep[y]) swap(x,y),swap(a,b);
    if (x^y) {
        ret=min(ret,rt.query(rt.root,1,bcc_cnt,tid[x]+1,tid[y]));
        int l=pos[b],r=pos[up[y]];
        ret=min(ret,query(y,l,r));
        ret=min(ret,sft.query(sft.root,1,bcc_cnt,tid[x]+1,tid[y]-1));
        l=pos[a],r=pos[down[x]];
        ret=min(ret,query(x,l,r));
    }else 
        ret=min(ret,query(x,pos[a],pos[b]));
    return ret;
}

int main(){
    n=read(),m=read();
    for (int i=1;i<=m;++i) {
        int a=read(),b=read(),w=read();
        line[i]=(node){a,b,w};
        push(a,b,w),push(b,a,w);
        edge[cnt].id=edge[cnt-1].id=line+i;
    }
    tarjan(1,0); 
    for (int i=1;i<=n;++i)
        if(!vis[i]) dfs(i);        
    
    for (int i=1;i<=bcc_cnt;++i)    {
        if (size[i]==1) val[i].push_back(inf);
        for (int j=1;j<=size[i];++j)
            aa[j]=val[i][j-1];
        seg[i].build(seg[i].root,1,size[i]);
    }
    memset(head,0,sizeof(head));
    cnt=0;
    for (int i=1;i<=m;++i)  {
        int a,b,w=line[i].w;
        if ((a=bccno[line[i].a])!=(b=bccno[line[i].b]))
            push(a,b,w),push(b,a,w),edge[cnt].id=edge[cnt-1].id=line+i;
    }
    dfs(1,0);
    dfs(1,0,1);
    aa[1]=0;   
    rt.build(rt.root,1,bcc_cnt);
    memset(aa,127,sizeof aa);

    int Q=read(),typ,a,b;
    sdfs(1);
    sft.build(sft.root,1,bcc_cnt);
    while (Q--) {
        typ=read(),a=read(),b=read();
        if (typ)  change(a,b);
        else   printf("%d\n",query(a,b));
    }
}

 

 

T3

题目大意：

　　传送门

　　$n*n$的棋盘，有一些位置可以放棋子，有一些已经放了棋子，有一些什么都没有，也不能放，要求放置以后满足:第i行和第i列的棋子数相同，同时每行的棋子数占总数比例小于$\frac{A}{B}$。求最多可以放多少，无解则输出$impossible$。

题解：

　  Orz一发大佬——传送门。

　　先把整张图放满，题目就转化为最少删多少点就合法。

　　我们用$numx$来记录每行可以放的和已经放棋子总数，$numy$记录每列。从$S$向第i行连流量为$numx_i$的0费用边，从第j列向$T$连流量为$numy_j$的边。先不考虑怎么构建中间的图，在不考虑$\frac{A}{B}$的情况，我们需要判断流量合法的，我们可以让到$T$的边都满流意味着选了和没选的可以构成全集。

　　我们对于可以放棋子的地方$(x,y)$，由第$x$行到第$y$列连$flow=1,cost=1$的边，表示将这个点删去的所需价值。

　　考虑后一个限制。

　　我们可以枚举每一行最多放置的棋子个数$f$，然后我们从第$i$行向第$i$列连一条$flow=f,cost=0$的边。表示第i行选了最多保留$f$个棋子，第$i$列保留棋子等同于这条边的流量，因为其他连向第$i$列的边都是要费用的，对第$i$行来讲其他的出边也是要费用的，而那些要费用的边就是删去的集合。

　　然后判断一下当前解是否合法即可。

代码：

#include "bits/stdc++.h"

using namespace std;

#define inf 0x3f3f3f3f

inline int read() {
    int s=0,k=1;char ch=getchar ();
    while (ch<'0'|ch>'9') ch=='-'?k=-1:0,ch=getchar();
    while (ch>47&ch<='9') s=s*10+(ch^48),ch=getchar();
    return s*k;
}

const int N=100;

struct edges {
    int v,cap,cost;edges *pair,*last;
}edge[N*N],*head[N];int cnt;

inline void push(int u,int v,int cap,int cost) {
    edge[++cnt]=(edges){v,cap,cost,edge+cnt+1,head[u]},head[u]=edge+cnt;
    edge[++cnt]=(edges){u,0,-cost,edge+cnt-1,head[v]},head[v]=edge+cnt;
}

int S,T,n,fl,ans;
int piS,vis[N];
int cost;

inline int aug(int x,int w) {
    if (x==T) return cost+=1ll*piS*w,fl+=w,w;
    vis[x]=true;
    int ret=0;
    for (edges *i=head[x];i;i=i->last)
        if (i->cap&&!i->cost&&!vis[i->v])   {
            int flow=aug(i->v,min(i->cap,w));
            i->cap-=flow,i->pair->cap+=flow,ret+=flow,w-=flow;
            if (!w) break;
        }
    return ret;
}

inline bool modlabel() {
    static int d[N];
    memset(d,0x3f,sizeof d);d[T]=0;
    static deque<int> q;q.push_back(T);
    int dt;
    while (!q.empty()) {
        int x=q.front();q.pop_front();
        for (edges *i=head[x];i;i=i->last)  
            if (i->pair->cap&&(dt=d[x]-i->cost)<d[i->v])
                (d[i->v]=dt)<=d[q.size()?q.front():0]
                    ?q.push_front(i->v):q.push_back(i->v);
    }
    for (int i=S;i<=T;++i)
        for (edges *j=head[i];j;j=j->last)
            j->cost+=d[j->v]-d[i];
    piS+=d[S];
    return d[S]<inf;
}

inline void solve() {
    piS = cost = 0;
    while(modlabel())
        do memset(vis,0,sizeof vis); 
    while(aug(S, inf));
}

char mp[N][N];
int numx[N],numy[N],A,B;

int main() {
    n=read(),A=read(),B=read();  
    T=n<<1|1;
    int used=0,sum=0;
    ans=-1;
    for (int i=1;i<=n;++i)  {
        scanf("%s",mp[i]+1);
        for (int j=1;j<=n;++j)
            if(mp[i][j]=='C'||mp[i][j]=='.')    {
                ++sum,++numx[i],++numy[j];
                used+=mp[i][j]=='C';
            }
    } 
    for (int flow=0;flow<=n;++flow) {
        memset(head,0,sizeof head);
        cnt=0;fl=0;
        for (int i=1;i<=n;++i) {
            push(S,i,numx[i],0);
            push(i+n,T,numy[i],0);
            push(i,i+n,flow,0);
            for (int j=1;j<=n;++j) 
                if(mp[i][j]=='.')
                    push(i,j+n,1,1);
        }
        solve();
        if (fl==sum&&flow*B<=(sum-cost)*A)
            ans=max(ans,sum-cost);
    }
    if (ans==-1)   puts("impossible");
    else printf("%d\n",ans-used);
}