hdu 3820 最小割

#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
typedef long long ll ;
#define captype int

const int MAXN = 40010;   //點的總數
const int MAXM = 400010;    //邊的總數
const int INF = 1<<30;
struct EDG{
    int to,next;
    captype cap;
} edg[MAXM];
int eid,head[MAXN];
int gap[MAXN];  //每種距離(或可認爲是高度)點的個數
int dis[MAXN];  //每個點到終點eNode 的最短距離
int cur[MAXN];  //cur[u] 表示從u點出發可流經 cur[u] 號邊

void init(){
    eid=0;
    memset(head,-1,sizeof(head));
}
//有向邊 三個參數，無向邊4個參數
void addEdg(int u,int v,captype c,captype rc=0){
    edg[eid].to=v; edg[eid].next=head[u];
    edg[eid].cap=c; head[u]=eid++;

    edg[eid].to=u; edg[eid].next=head[v];
    edg[eid].cap=rc; head[v]=eid++;
}
//預處理eNode點到所有點的最短距離
void BFS(int sNode, int eNode){
    queue<int>q;
    memset(gap,0,sizeof(gap));
    memset(dis,-1,sizeof(dis));
    gap[0]=1;
    dis[eNode]=0;
    q.push(eNode);
    while(!q.empty()){
        int u=q.front(); q.pop();
        for(int i=head[u]; i!=-1; i=edg[i].next){
            int v=edg[i].to;
            if(dis[v]==-1){
                dis[v]=dis[u]+1;
                gap[dis[v]]++;
                q.push(v);
            }
        }
    }
}
int S[MAXN];    //路徑棧，存的是邊的id號
captype maxFlow_sap(int sNode,int eNode, int n){  //注意：n爲點的總個數，包括源點與匯點
    BFS(sNode, eNode);              //預處理eNode到所有點的最短距離
    if(dis[sNode]==-1) return 0;    //源點到不可到達匯點
    memcpy(cur,head,sizeof(head));

    int top=0;  //棧頂
    captype ans=0;  //最大流
    int u=sNode;
    while(dis[sNode]<n){   //判斷從sNode點有沒有流向下一個相鄰的點
        if(u==eNode){   //找到一條可增流的路
            captype Min=INF ;
            int inser;
            for(int i=0; i<top; i++)    //從這條可增流的路找到最多可增的流量Min
            if(Min>=edg[S[i]].cap){
                Min=edg[S[i]].cap;
                inser=i;
            }
            for(int i=0; i<top; i++){
                edg[S[i]].cap-=Min;
                edg[S[i]^1].cap+=Min;  //可迴流的邊的流量
            }
            ans+=Min;
            top=inser;  //從這條可增流的路中的流量瓶頸 邊的上一條邊那裏是可以再增流的，所以只從斷流量瓶頸 邊裁斷
            u=edg[S[top]^1].to;  //流量瓶頸 邊的起始點
            continue;
        }
        bool flag = false;  //判斷能否從u點出發可往相鄰點流
        int v;
        for(int i=cur[u]; i!=-1; i=edg[i].next){
            v=edg[i].to;
            if(edg[i].cap>0 && dis[u]==dis[v]+1){
                flag=true;
                cur[u]=i;
                break;
            }
        }
        if(flag){
            S[top++] = cur[u];  //加入一條邊
            u=v;
            continue;
        }
        //如果上面沒有找到一個可流的相鄰點，則改變出發點u的距離（也可認爲是高度）爲相鄰可流點的最小距離+1
        int Mind= n;
        for(int i=head[u]; i!=-1; i=edg[i].next)
        if(edg[i].cap>0 && Mind>dis[edg[i].to]){
            Mind=dis[edg[i].to];
            cur[u]=i;
        }
        gap[dis[u]]--;
        if(gap[dis[u]]==0) return ans;  //當dis[u]這種距離的點沒有了，也就不可能從源點出發找到一條增廣流路徑
                                        //因爲匯點到當前點的距離只有一種，那麼從源點到匯點必然經過當前點，然而當前點又沒能找到可流向的點，那麼必然斷流
        dis[u]=Mind+1;      //如果找到一個可流的相鄰點，則距離爲相鄰點距離+1，如果找不到，則爲n+1
        gap[dis[u]]++;
        if(u!=sNode) u=edg[S[--top]^1].to;  //退一條邊

    }
    return ans;
}

        //ans-=maxFlow_sap(s , t ,t+1);
int dx[4] = { -1 , 0 , 1 , 0 } ;
int dy[4] = { 0 , -1 , 0 , 1 } ;
int N , M ;int g[55][55] , s[55][55];
const int inf = 0x3f3f3f3f ;
int main()
{
    int T ; scanf("%d" , &T) ;
    int gold , silv ;
    int kk = 1 ;
    while( T -- ){
        int sum = 0 ;
        scanf("%d %d %d %d" , &N , &M , &gold , &silv) ;
        for(int i = 1 ; i <= N ; i ++ ){
            for(int j = 1 ; j <= M ; j ++ ){
                scanf("%d" , &g[i][j]) ;
                sum += g[i][j] ;

            }
        }
        for(int i = 1 ; i <= N ; i ++ ){
            for(int j = 1 ; j <= M ; j ++ ){
                scanf("%d" , &s[i][j]) ;
                sum += s[i][j] ;
            }
        }
        init() ;
        int st = 0 ;
        int ed = 2*N*M + 1 ;
        int n = ed + 1 ;
        for(int i = 1 ; i <= N ; i ++ ){
            for(int j = 1 ; j <= M ; j ++ ){
                if(( i + j )& 1 ){
                    addEdg(st , (i - 1)*M + j , g[i][j]) ;
                    addEdg((i - 1)*M + j + N*M , ed , s[i][j]) ;
                    addEdg((i - 1)*M+j , (i - 1)*M+j+N*M , INF) ;
                    for(int op = 0 ; op <= 3 ; op ++ ){
                        int x = i + dx[op] , y = j + dy[op] ;
                        if(x >= 1 && x <= N && y >= 1 && y <= M){
                            addEdg((i-1)*M+j , (x-1)*M+y+N*M , gold) ;
                            addEdg((x-1)*M+y , (i-1)*M+j+N*M , silv) ;
                        }
                    }
                }else{
                    addEdg(st , (i - 1)*M + j , s[i][j]) ;
                    addEdg((i - 1)*M + j + N*M , ed , g[i][j]) ;
                    addEdg((i - 1)*M+j , (i - 1)*M+j+N*M , INF) ;
                    /*for(int op = 0 ; op <= 3 ; op ++ ){
                        int x = i + dx[op] , y = j + dy[op] ;
                        if(x >= 1 && x <= N && y >= 1 && y <= M){
                            addEdg((i-1)*M+j , (x-1)*M+y+N*M , silv) ;
                            addEdg((x-1)*M+y , (i-1)*M+j+N*M , gold) ;
                        }
                    }*/
                }
            }
        }
        printf("Case %d: %d\n" ,kk ++ , sum - maxFlow_sap(st , ed , n))  ;
    }
    return 0;
}