【最小割二种决策选一】【SPOJ1693】Coconut

【题目来源】http://www.spoj.com/problems/COCONUTS/

 

【问题描述】N个城堡守卫正在就非洲的燕子能否搬运椰子而进行投票。每个人都有自己的看法，但是为了避免跟自己的朋友持相反意见，他们时常会投相反的票。现在给出每个人的初始看法以及朋友关系，求在某种投票方案下，违背自己意愿的票数与持不同意见的朋友对数的总和最小。（2 <= N <= 300, 1 <= M <= N(N-1)/2）

 

【问题分析】本题属于二种决策选一的经典最小割模型。设立源点S和汇点T，把每个城堡守卫看成点，连接S到每个守卫再到汇点T。如果这个守卫自己的看法为赞同，那么就边守卫->T的容量为1，边S->守卫的容量为0；反之亦然。对于每对朋友关系，连接i->j和j->i，容量为1。

  　　　　　建模分析 ： 割对应实际问题的时候，相当于选择边加入割集，并且要使得不存在一条从S->T的路径。倘若选择了S->守卫，表示选择了赞同，边上的容量即为选择赞同的代价，如果这个人原先是想投赞同票，那么边上容量为0，也就相当于没有代价；反之，如果这个人原先是想投反对票，那么边上的容量为1，相当于记录下了他违背自己意愿。并且，对于一对朋友之间，如果2个人的选择不同，那么仍然会存在一条从S->T的路径。此时需要再选取一条边，就是这对朋友i和j之间边的容量，也就是这对朋友选择不同的代价。

 

【代码如下】

 

 

#include <iostream>
#include <cstdio>
#include <climits>
#include <cstring>
#include <vector>
#include <deque>
#include <algorithm>

#define FILE_IO

using namespace std;

const int Maxn = 302, INF = INT_MAX;

struct edge
{
    int v, c;
    edge* next, * op;
    edge(int _v, int _c, edge* _next) : v(_v), c(_c), next(_next) {}
}* E[Maxn], * Et[Maxn];

int S, T, Maxflow, N, M;
vector <int> Lv;
deque <int> Q;

void Init();
inline void edgeAdd(int, int, int);
void Dinic();
bool Dinic_Label();
int Dinic_Augment(int, int);
void Print();
void Clear();

int main()
{
    #ifdef FILE_IO
    freopen("1693.in", "r", stdin);
    #endif // FILE_IO
    scanf("%d%d", &N, &M);
    while (!(N == 0 && M == 0))
    {
        Init();
        Dinic();
        Print();
        Clear();
        scanf("%d%d", &N, &M);
    }
    #ifdef FILE_IO
    fclose(stdin);
    #endif // FILE_IO
    return 0;
}

void Init()
{
    S = 0; T = N + 1;
    for (int i = 1; i <= N; i ++)
    {
        int a; scanf("%d", &a);
        if (a) edgeAdd(S, i, 1);
        else edgeAdd(i, T, 1);
    }
    for (int i = 1; i <= M; i ++)
    {
        int x, y; scanf("%d%d", &x, &y);
        edgeAdd(x, y, 1); edgeAdd(y, x, 1);
    }
}

inline void edgeAdd(int x, int y, int c)
{
    E[x] = new edge(y, c, E[x]);
    E[y] = new edge(x, 0, E[y]);
    E[x] -> op = E[y]; E[y] -> op = E[x];
}

void Dinic()
{
    while (Dinic_Label())
    {
        memcpy(Et, E, sizeof(Et));
        Maxflow += Dinic_Augment(S, INF);
    }
}

bool Dinic_Label()
{
    Lv.assign(T + 1, -1); Lv[S] = 0;
    Q.clear(); Q.push_back(S);
    while (!Q.empty())
    {
        int i = Q.front(); Q.pop_front();
        for (edge* j = E[i]; j; j = j -> next)
        {
            if (j -> c && Lv[j -> v] == -1)
            {
                Lv[j -> v] = Lv[i] + 1;
                if (j -> v == T) return true;
                Q.push_back(j -> v);
            }
        }
    }
    return false;
}

int Dinic_Augment(int i, int bm)
{
    if (i == T || bm == 0) return bm;
    int iflow = 0;
    for (edge* &j = Et[i]; j; j = j -> next)
    {
        if (j -> c && Lv[i] + 1 == Lv[j -> v])
        {
            int add = Dinic_Augment(j -> v, min(bm, j ->c));
            j -> c -= add;
            j -> op -> c += add;
            iflow += add;
            bm -= add;
            if (bm == 0) break;
        }
    }
    return iflow;
}

void Print()
{
    printf("%d\n", Maxflow);
}

void Clear()
{
    for (int i = 0; i <= T; i ++) E[i] = NULL;
    Maxflow = 0;
}