Codeforces Round #366 (Div. 1) D. Captain America 上下界网络流

题意

给定一个坐标平面上的N个点，要为这些点染色，每种点可以染为两种颜色，红色花费为r，蓝色花费为b。
现在给出m个约束条件，每个条件形如：“ ti li di ”表示：
1.如果ti=1，那么要求x=li上所有点红蓝数量之差小于等于di
2.如果ti=2，那么要求y=li上所有点红蓝数量之差小于等于di
然后要你最小化花费

分析

这是一个平面图，我们想到x和y连，
于是对于每个x和每个y，知道他们连出去的边有s个，那么上下界就是：

$$[\lceil \frac{s-d_i}{2}\rceil,\lfloor \frac{s+d_i}{2}\rfloor]$$
中间就是[0,1]的边

关于上下界网络流，我们回忆一下：
每个点有一个in[i],out[i]分别表示流入的边的下界和流出的边的下界
建一个超级源点和超级汇点

$$in[i] - out[i] > 0 \Rightarrow (ss,i) flow:in[i]-out[i]$$
$$out[i] - in[i]> 0 \Rightarrow (i,tt) flow:out[i]-in[i]$$
然后连一条从t到s的边，流量为[0,inf]。

首先跑有源汇可行流，答案就是t到s的边流过的流量
当前可行当且仅当ss流出的边全部满流

然后把这条边和ss，tt拆掉，再跑最大流，把两次答案加起来就好了

方案数就看中间的边有没有流

我这道题T了，我加当前弧的话前面的点T，不加的话后面的点T。。。
留坑待填

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

const int N = 200010;
const int mod = 1000000007;
const int inf = 1e9;

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

struct node{int x,y,next,c;}edge[N<<3]; int len,first[N]; int cur[N];
void ins(int x,int y,int c)
{
  len++; edge[len].x=x; edge[len].y=y; edge[len].c=c; edge[len].next=first[x]; first[x]=len;
  len++; edge[len].x=y; edge[len].y=x; edge[len].c=0; edge[len].next=first[y]; first[y]=len;
}

int dep[N]; queue<int>q; int s,d,ss,dd;

bool bfs()
{
  while(!q.empty()) q.pop(); q.push(ss);
  memset(dep,0,sizeof(dep)); dep[ss]=1;
  while(!q.empty())
  {
    int x=q.front();
    for(int k=first[x];k!=-1;k=edge[k].next)
    {
      int y=edge[k].y;
      if(edge[k].c && !dep[y])
      {
        dep[y] = dep[x] + 1;
        q.push(y);
      }
    }
    q.pop();
  }
  return dep[dd] > 0;
}


inline int dfs(int x,int flow)
{
  if(x==dd) return flow;
  int delta=0;
  for(int k=first[x];k!=-1;k=edge[k].next)
  {
    int y=edge[k].y;
    if(edge[k].c && flow > delta && dep[y] == dep[x]+1)
    {
      int minf = dfs(y,min(flow-delta,edge[k].c));
      edge[k].c-=minf; edge[k^1].c+=minf;
      delta+=minf;
    }
  }
  if(delta==0) dep[x]=0;
  return delta;
}

struct point{int x,y;}po[N];

map<int,int> mx,my; int dx=0,dy=0;
int cnt[N],in[N],out[N],lim[N];
int id[N];

int main()
{

  len = 1; memset(first,-1,sizeof(first));

  int n = read(); int m = read();
  int r = read(); int b = read();

  for(int i=1;i<=n;i++)
  {
    po[i].x = read(); po[i].y = read();
    if(!mx.count(po[i].x)) mx[po[i].x] = ++dx;
    if(!my.count(po[i].y)) my[po[i].y] = ++dy;
  }

  s = dx + dy +1; d = s+1; ss = d+1; dd = ss+1;

  for(int i=1;i<=n;i++) id[i] = len+1,ins(mx[po[i].x],my[po[i].y] + dx,1),cnt[mx[po[i].x]]++,cnt[my[po[i].y]+dx]++;
  for(int i=1;i<=dx+dy;i++) lim[i]=inf;

  int ans = 0; int op = 1; if(r>b) swap(r,b),op=-1;
  for(int i=1;i<=m;i++)
  {
    int t = read(); int l = read(); int di = read();

    if(t==1 && mx.count(l))
    {
      int down = (int)(ceil((double)(cnt[mx[l]] - di) / 2.0));
      int up = (int)(floor((double)(cnt[mx[l]] + di) / 2.0));

      down = max(down , 0);
      if(up - down < 0){printf("-1\n"); return 0;}

      lim[mx[l]] = min(lim[mx[l]],up-down);

      in[mx[l]] = max(in[mx[l]],down);
      //printf("%d\n",up-down);
      // printf("%d %d\n",up,down);
    }

    else if(t==2 && my.count(l))
    {
      int down = (int)(ceil((double)(cnt[my[l]+dx] - di) / 2.0));
      int up = (int)(floor((double)(cnt[my[l]+dx] + di) / 2.0));

      down = max(down , 0);
      if(up - down < 0){printf("-1\n"); return 0;}

      lim[my[l]+dx] = min(lim[my[l]+dx],up-down);

      out[my[l]+dx] = max(out[my[l]+dx],down);
      //printf("%d\n",up-down);
      // printf("%d %d\n",up,down);
    }
  }

  int tot = 0;
  for(int i=1;i<=dx;i++) ins(s,i,lim[i]),out[s]+=in[i];
  for(int i=1;i<=dy;i++) ins(i+dx,d,lim[i+dx]),in[d]+=out[i+dx];

  for(int i=1;i<=dd;i++)
  {
    if(in[i] < out[i]) ins(i,dd,out[i]-in[i]);
    else ins(ss,i,in[i]-out[i]);
  }

  ins(d,s,inf);

  // for(int i=2;i<=len;i+=2) printf("%d %d %d\n",edge[i].x,edge[i].y,edge[i].c);

  while(bfs())
  {

    dfs(ss,inf);
  }

  ans = edge[len].c;

  for(int k=first[ss];k!=-1;k=edge[k].next) tot += edge[k].c;
  if(tot){printf("-1\n"); return 0;}

  edge[len^1].c=edge[len].c=0; first[ss] = first[dd] = -1; ss=s; dd=d;
  while(bfs())
  {
    ans+=dfs(ss,inf);
  }
  // printf("%d\n",ans);
  printf("%lld\n",(ll)ans * r + (ll)(n-ans) * b);

  //for(int i=2;i<=len;i+=2) printf("%d %d %d\n",edge[i].x,edge[i].y,edge[i].c);

  for(int i=1;i<=n;i++)
  {
    int k = id[i];
    int col = op * ((edge[k].c==1) ? (-1) : 1);
    if(col==-1) printf("b");
    else printf("r");
  }
  return printf("\n"),0;
}