BZOJ2400: Spoj 839 Optimal Marks

最新推荐文章于 2019-03-15 10:05:07 发布

原创最新推荐文章于 2019-03-15 10:05:07 发布 · 243 阅读

0 ·

CC 4.0 BY-SA版权

< 网络流 > 同时被 2 个专栏收录

18 篇文章

订阅专栏

最小割

5 篇文章

订阅专栏

本文详细解答了BZOJ2400:Spoj839OptimalMarks问题，通过巧妙利用最小割算法解决点权与边权问题。采用位运算按位处理，并结合费用流思想，利用最小割算法找到最优解。

BZOJ2400: Spoj 839 Optimal Marks

最小割的奇妙世界

题解：

引用自http://blog.youkuaiyun.com/u012288458/article/details/50720724，少许改动。

位运算相关，按位做
枚举每一位（以下的0和1都是指的这一位）
一个点与S连通表示这个点选0，与T连通表示这个点选1
如果这个点确定为0，那么源点S向这个点连一条容量为inf的边
如果这个点确定为1，那么这个点向汇点T连一条容量为inf的边
每条边对应连一条容量为1的边
跑一下最小割，第一问做好了。

考虑点权的话非常巧妙，本来第二个条件应该是费用流的？
但是可以通过一些技巧用最小割来实现
把原来的边容量放大BASE倍
如果一个点不和S直接连边，那么源点S向这个点连一条容量为1的边
这样割掉这条边要花1的费用
为什么是对的呢？因为小边是不会影响大边的，一定是在大边最小的情况下，才会考虑小边，就等价于在边权和最小的情况下，考虑点权和
ans/BASE是最小边权和，ans%BASE是最小点权和

记得用long long……

Code：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#define D(x) cout<<#x<<" = "<<x<<"  "
#define E cout<<endl
using namespace std;
const int N = 505;
const int INF = 0x3f3f3f3f;
const int BASE = 2333;

int n,m,S,T,w[N],x[2005],y[2005];
long long ans1,ans2;

struct Edge{
    int to,next,cap,flow;
} e[100005];
int head[N], ec=1;
void add(int a,int b,int cap){
    ec++; e[ec].cap=cap; e[ec].flow=0;
    e[ec].to=b; e[ec].next=head[a]; head[a]=ec; 
}
void add2(int a,int b,int cap){
//  D(a); D(b); D(cap); E;
    add(a,b,cap); add(b,a,0);
}

int d[N]; bool vis[N];
bool bfs(){
    memset(vis,false,sizeof(vis));
    memset(d,-1,sizeof(d));
    queue<int> q; q.push(S); vis[S]=true; d[S]=0;
    while(!q.empty()){
        int u=q.front(); q.pop();
        for(int i=head[u];i;i=e[i].next){
            int v=e[i].to;
            if(!vis[v] && e[i].cap>e[i].flow){
                vis[v]=true; d[v]=d[u]+1; q.push(v);
                if(v==T) return true;
            }
        }
    }
    return false;
}

int dfs(int u,int a){
    if(u==T || a==0) return a;
    int flow=0, f;
    for(int i=head[u];i;i=e[i].next){
        int v=e[i].to;
        if(d[v]==d[u]+1 && (f=dfs(v,min(a,e[i].cap-e[i].flow)))){
            e[i].flow+=f; e[i^1].flow-=f; flow+=f; a-=f;
            if(a==0) break;
        }
    }
    if(a) d[u]=-1;
    return flow;
}

int dinic(){
    int flow=0;
    while(bfs()){
        flow+=dfs(S,INF);
    }
    return flow;
}

void build(int bit){
    ec=1; memset(head,0,sizeof(head));
    S=n+1; T=S+1;
    for(int i=1;i<=n;i++){
        if(w[i]>=0){
            if(w[i]&(1<<bit)){ add2(i,T,INF); add2(S,i,1); }
            else{ add2(S,i,INF); }
        }
        else{ add2(S,i,1); }
    }
    for(int i=1;i<=m;i++){ add(x[i],y[i],BASE); add(y[i],x[i],BASE); }
}

int main(){
    freopen("a.in","r",stdin);
    scanf("%d%d",&n,&m); int mxw=0;
    for(int i=1;i<=n;i++) scanf("%d",&w[i]), mxw=max(mxw,w[i]);
    for(int i=1;i<=m;i++) scanf("%d%d",&x[i],&y[i]);
    int LOG=0; while(mxw>=(1<<LOG)) LOG++;
    for(int bit=LOG;bit>=0;bit--){
//      D(bit); E;
        build(bit);
        int flow=dinic();
//      D(flow); E;
        ans1+=(long long)(1<<bit)*(long long)(flow/BASE);
        ans2+=(long long)(1<<bit)*(long long)(flow%BASE);
    }
    printf("%lld\n%lld\n",ans1,ans2);
}