Bzoj4823 [Cqoi2017]老C的方块

没有题面，懒得手打

网络流 最小割

码农题(误)

一开始是冲着n<=5000的部分分写了网络流，结果神奇地发现似乎就是正解。

说好的dinic时间复杂度上界$O(V^2 E)$呢……网络流不愧是玄学算法。

放一张题目里的图

四种图案：

观察这四种图案和它们旋转/翻转以后的样子，可以发现一个共同点：每种图案都是由“中心一条蓝色边和它相邻的两个方块”，以及另外两个邻接的方块组成的

范围画出来就是这个样子：

可以发现“另外两个邻接的方块”肯定一个在蓝线左边一个在蓝线右边。

先说一种错误的想法：

将每个方块看做一个结点；

左边三个格子如果有方块，从源点向它们连INF边，从它们向中心偏左方块连INF边；

右边三个格子如果有方块，从它们向汇点连INF边，从中心偏右的方块向它们连INF边；

中心偏左的方块向中心偏右的方块连INF边；

按照以上思路，每个方块拆点，入点出点之间连容量为方块权值的边，做最小点割。

然后看一个显然的矛盾：

当重合部分有方块的时候，它们就会同时连通源汇点，使得该方块必须被割掉，显然错误。

很可惜样例没有这种情况，博主又傻傻没发现，于是交上去以后愉快地爆零啦

正确的做法：

上述问题的解决方法是：重新分类

　　

像这样把坐标分成四类，红色的只能入，蓝色的中转，灰色的只能出。

套用到原图上发现没有矛盾。

懒得再画图了，放一张做题时候的草稿。有些乱qwq

其中灰色方框没有意义，橙色连源点，红色连汇点。

这样就把方格分为四类。每添加一个方块时，查看它四周都有没有方块，如果有，按方格类型讨论连边即可。

——————

给定一个坐标，如何知道它对应哪种格子？按行的奇偶性和列%4的值分类讨论即可

——————

这时候的连边方式有些细节要注意，比如说“中间格”对应的结点不能拆，否则会出现奇怪的方向问题；为了代替拆点限权，两中间格之间的连边应是权值等于min(w[a],w[b])的双向边（同样是为了规避不同流向的权值差异）。

↑画画图就一目了然了。

建图建了近百行……过程还有很大优化空间，但是既然过了就不管了（逃）

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#include<queue>
#include<map>
#define LL long long
using namespace std;
const int mx[5]={0,-1,0,1,0};
const int my[5]={0,0,-1,0,1};
const int INF=0x3f3f3f3f;
const int mxn=300010;
int read(){
    int x=0,f=1;char ch=getchar();
    while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0' && ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
struct edge{
    int v,nxt,f;
}e[mxn<<2];
int hd[mxn],mct=1;
void add_edge(int u,int v,int w){
    e[++mct].v=v;e[mct].nxt=hd[u];e[mct].f=w;hd[u]=mct;return;
}
int S,T;
void insert(int u,int v,int w){
//    printf("u:%d v:%d w:%d
",u,v,w);
    add_edge(u,v,w);
    add_edge(v,u,0);
}
int d[mxn];
bool BFS(){
    queue<int>q;
    memset(d,0,sizeof d);
    q.push(S);
    d[S]=1;
    while(!q.empty()){
        int u=q.front();q.pop();
        for(int i=hd[u];i;i=e[i].nxt){
            int v=e[i].v;
            if(!d[v] && e[i].f){
                d[v]=d[u]+1;
                q.push(v);
            }
        }
    }
    return d[T];
}
int DFS(int u,int lim){
    if(u==T)return lim;
    int f=0,tmp;
    for(int i=hd[u];i;i=e[i].nxt){
        int v=e[i].v;
        if(d[v]==d[u]+1 && e[i].f && (tmp=DFS(v,min(lim,e[i].f)))){
            f+=tmp;lim-=tmp;
            e[i].f-=tmp;
            e[i^1].f+=tmp;
            if(!lim)return f;
        }
    }
    d[u]=0;
    return f;
}
LL Dinic(){
    LL res=0;
    while(BFS())res+=DFS(S,INF);
    return res;
}
//
int PD(int x,int y){//判断是否在关键边旁边 
    if(y%4==0){
        if((x&1)==0)return 2;//right
        else return 4;//outpos
    }
    if(y%4==1){
        if(x&1)return 1;//left
        else return 4;//outpos
    }
    if(y%4==2){
        if(x&1)return 2;//right
        else return 3;//inpos
    }
    if(y%4==3){
         if((x&1)==0)return 1;//left
         else return 3;//inpos
    }
    return 0;
}
map<pair<int,int>,int>mp;
struct block{
    int x,y;
    int w;
}b[mxn];
int C,R,n;
int Tct[mxn];
void Build(int id){
//    printf("insert:#%d
",id);
    int s=PD(b[id].x,b[id].y);
    for(int k=1;k<=4;k++){
        int nx=b[id].x+mx[k];
        int ny=b[id].y+my[k];
        if(nx>0 && nx<=R && ny>0 && ny<=C){
            int v=mp[make_pair(nx,ny)];
            if(!v)continue;
            int t=PD(nx,ny);
/*            printf("u:%d v:%d s:%d t:%d
",id,v,s,t);
            printf("x1:%d y1:%d x2:%d y2:%d
",
                b[id].x,b[id].y,nx,ny);
            printf("s:%d t:%d

",s,t);*/
            if(s==1 && t==2){
                add_edge(id,v,min(b[id].w,b[v].w));
                add_edge(v,id,min(b[id].w,b[v].w));
            }
            if(s==2 && t==1){
                add_edge(id,v,min(b[id].w,b[v].w));
                add_edge(v,id,min(b[id].w,b[v].w));
            }
            if(s==1 && t==3){
                insert(S,v,INF);
                insert(v+n,id,INF);
            }
            if(s==1 && t==4){
                insert(id,v,INF);
                insert(v+n,T,INF);
            }
            if(s==2 && t==3){
                insert(S,v,INF);
                insert(v+n,id,INF);
            }
            if(s==2 && t==4){
                insert(id,v,INF);
                insert(v+n,T,INF);
            }
            if(s==3 && t==1){
                insert(S,id,INF);
                insert(id+n,v,INF);
            }            
            if(s==3 && t==2){
                insert(S,id,INF);
                insert(id+n,v,INF);
            }
            if(s==4 && t==1){
                insert(id+n,T,INF);
                insert(v,id,INF);
            }
            if(s==4 && t==2){
                insert(id+n,T,INF);
                insert(v,id,INF);
            }
        }
    }
    mp[make_pair(b[id].x,b[id].y)]=id;
//    printf("
");
    return;
}
void solve(){
    for(int i=1;i<=n;i++){
        int t=PD(b[i].x,b[i].y);
        if(t==1 || t==2)continue;
        add_edge(i,i+n,b[i].w);
        add_edge(i+n,i,0);
    }
    LL res=Dinic();
    printf("%lld
",res);
    return;
}
int main(){
//    freopen("block.in","r",stdin);
//    freopen("block.out","w",stdout);
    int i,j;
    C=read();R=read();n=read();
    for(i=1;i<=n;i++){
        b[i].y=read();b[i].x=read();//行列顺序相反 
        b[i].w=read();
    }
    S=0;T=n*2+1;
    for(i=1;i<=n;i++)Build(i);
    solve();
    return 0;
}