洛谷 P2057 [SHOI2007]善意的投票二者选一的问题

最新推荐文章于 2020-11-26 18:44:15 发布

原创最新推荐文章于 2020-11-26 18:44:15 发布 · 220 阅读

0 ·

CC 4.0 BY-SA版权

学习笔记同时被 2 个专栏收录

34 篇文章

订阅专栏

网络流

8 篇文章

订阅专栏

题目描述
幼儿园里有n个小朋友打算通过投票来决定睡不睡午觉。对他们来说，这个问题并不是很重要，于是他们决定发扬谦让精神。虽然每个人都有自己的主见，但是为了照顾一下自己朋友的想法，他们也可以投和自己本来意愿相反的票。我们定义一次投票的冲突数为好朋友之间发生冲突的总数加上和所有和自己本来意愿发生冲突的人数。

我们的问题就是，每位小朋友应该怎样投票，才能使冲突数最小？

输入格式
文件的第一行只有两个整数n，m，保证有2≤n≤300，1≤m≤n(n-1)/2。其中n代表总人数，m代表好朋友的对数。文件第二行有n个整数，第i个整数代表第i个小朋友的意愿，当它为1时表示同意睡觉，当它为0时表示反对睡觉。接下来文件还有m行，每行有两个整数i，j。表示i，j是一对好朋友，我们保证任何两对i，j不会重复。

输出格式
只需要输出一个整数，即可能的最小冲突数。

输入 #1

输出 #1
1
分析：
结合方格取数问题还有骑士共存还有小M的作物这三道题目来看，差不多可以得到这样的一个结论：对于两者选一的问题来说，他们都需要分出两个种类，然后这两个种类分别就是对应这个源点S和汇点T；写个步骤吧：
1.确定需要分成那两个集合。
2.分区，确定哪些是需要连到汇点和源点的，以边权代表点权；
3.明白最小割割边代表的是什么，就拿这道题目来说，睡觉的人连到S，不睡觉的人连到T，这就是两个集合，边权是1，对于是朋友的人怎么处理呢，朋友之间需要建一个双向边，因为他们之间是有可能互斥的状态，就像方格取数和骑士共存这两道题，S与T之间的关系都是用INF建立的双向边（其实单向边也可以，但要主要方向），这样就可以套最小割最大流的板子。
4.最小割割的是边权，最小的代价使其分开，割掉一个边，就相当于减少一次冲突了，将所有的冲突解决之后，在网络流中就是s到t中不存在路径，s与t完全分开的代价就是最小割的代价了；

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<string>
#include<cmath>
#include<cstring>
#include<set>
#include<queue>
#include<stack>
#include<map>
typedef long long ll;
using namespace std;
const int INF=0x3f3f3f3f;
struct node{
    int from,to,cap,flow;
};
vector<int>G[50000];
vector<node>edge;
void add(int from ,int to,ll cap){
    edge.push_back((node){from,to,cap,0});
    edge.push_back((node){to,from,0,0});
    int m=edge.size();
    G[from].push_back(m-2);
    G[to].push_back(m-1);
}
int s,t;
bool vis[50000];
int d[50000],cur[50000];

bool bfs(){
    memset(vis,0,sizeof vis);
    queue<int>q;
    q.push(s);
    d[s]=0;
    vis[s]=1;
    while(!q.empty()){
        int x=q.front();
        q.pop();
        for(int i=0;i<G[x].size();i++){
            node& e=edge[G[x][i]];
            if(!vis[e.to] && e.cap>e.flow){
                vis[e.to]=1;
                d[e.to]=d[x]+1;
                q.push(e.to);
            }
        }
    }
    return vis[t];
}

int dfs(int x,int a){
    if(x==t|| a==0) return a;
    int flow=0,f;
    for(int & i=cur[x]; i< G[x].size(); i++){
        node & e = edge[G[x][i]];
        if(d[x]+1==d[e.to] && (f=(dfs(e.to,min(a,e.cap-e.flow))))>0){
            e.flow+= f;
            edge[G[x][i]^1].flow-=f;
            flow+=f;
            a-=f;
            if(a==0) break;
        }
    }
    return flow;
}

int dinic(){
    int flow=0;
    memset(d,0,sizeof d);
    while(bfs()){
        memset(cur,0,sizeof cur);
        flow+=dfs(s,INF);
    }
    return flow;
}
int n,m;
int a[500];
int main()
{
    #ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
    #endif // ONLINE_JUDGE
    scanf("%d%d",&n,&m);
    s=0,t=n+1;
    int sum=0;
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        if(a[i])
           add(s,i,1),sum++;
        else
           add(i,t,1),sum++;
    }
    for(int i=0;i<m;i++){int u,v;
        scanf("%d%d",&u,&v);
        add(u,v,INF);
        add(v,u,INF);
    }
    printf("%d\n",dinic());
    return 0;
}