BZOJ1934: [Shoi2007]Vote 善意的投票

1934: [Shoi2007]Vote 善意的投票

Time Limit: 1 Sec  Memory Limit: 64 MB
Submit: 2489  Solved: 1544
[Submit][Status][Discuss]

Description

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

Input

第一行只有两个整数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不会重复。

Output

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

Sample Input

3 3
1 0 0
1 2
1 3
3 2

Sample Output

1

HINT

在第一个例子中，所有小朋友都投赞成票就能得到最优解

Source

【题解】

本题这样建图：

S连向同意的点，我们把这些边记做s边，由S连出的点叫s点

不同意的点连T，我们把这些边记做t边，连向T的点叫t点

观点相同的朋友之间加双向边，我们把这些边记做sam边

观点不同的朋友之间加双向边，我们把这些边记做dif边

网上大多数题解描述的建图原因：

不妨设割完之后S点所在集合是同意

割掉s边，意味着s点从“同意”变成了“不同意”，增加一点矛盾

割掉t边，意味着t点从“不同意”变成了“同意”，增加一点矛盾

割掉dif边，意味着朋友保留dif边所连点的s边和t边，表示这两个点一个同意一个不同意，增加一点矛盾

仔细想想，这样解释完全是错误的

因为s点或t点立场改变的时候，不只影响dif边，还影响着sam边！原来立场相同的变得立场不同，立场不同的变得立场相同

这就是双向边的原因！

加了双向边，意味着割掉一条s边后，它对应的s点就不需要割对应的两条dif边，但必须把s点连出的f边（一条，从f边两端点的

非s点指向s点的那一条）割去（全部或一部分，取决于f边所连点的割边方式），否则可能出现s->f边连的另一个点->s点->dif边所连的另一个点->T的一条路径，不是割

这样割边就意味着改变了一个点的立场，少割了跟它不同立场的朋友，多割了跟它同立场的朋友

这才是原题的意思

这才是加双向边的原因

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <queue>
#include <vector>
#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))
#define abs(a) ((a) < 0 ? (-1 * (a)) : (a))
inline void swap(int &a, int &b)
{
    long long tmp = a;a = b;b = tmp;
}
inline void read(int &x)
{
    x = 0;char ch = getchar(), c = ch;
    while(ch < '0' || ch > '9') c = ch, ch = getchar();
    while(ch <= '9' && ch >= '0') x = x * 10 + ch - '0', ch = getchar();
    if(c == '-')x = -x;
}

const int INF = 0x3f3f3f3f;
const int MAXN = 500;
const int MAXM = 1000000;

struct Edge
{
    int u,v,w,nxt;
    Edge(int _u, int _v, int _w, int _nxt){u = _u;v = _v;w = _w;nxt = _nxt;}
    Edge(){}
}edge[MAXM << 1];
int head[MAXN], cnt = 1, q[MAXN], h[MAXN], ans = 0, S, T;

inline void insert(int a, int b, int c)
{
    edge[++cnt] = Edge(a,b,c,head[a]);
    head[a] = cnt;
    edge[++cnt] = Edge(b,a,0,head[b]);
    head[b] = cnt;
}

bool bfs()
{
    int he = 0, ta = 1;
    memset(h, -1, sizeof(h));
    q[he] = S, h[S] = 0;
    while(he < ta)
    {
        int now = q[he ++];
        for(int pos = head[now];pos;pos = edge[pos].nxt)
        {
            int v = edge[pos].v;
            if(h[v] == -1 && edge[pos].w)
            {
                h[v] = h[now] + 1;
                q[ta ++] = v;
            }
        }
    }
    return h[T] != -1;
}

int dfs(int x, int f)
{
    if(x == T) return f;
    int w, used = 0;
    for(int pos = head[x];pos;pos = edge[pos].nxt)
    {
        int v = edge[pos].v;
        if(h[v] == h[x] + 1)
        {
            w = dfs(v, min(f - used, edge[pos].w));
            edge[pos].w -= w;
            edge[pos ^ 1].w += w;
            used += w;
            if(used == f) return f;
        }
    }
    if(!used) h[x] = -1;
    return used;
}

void dinic()
{
    while(bfs()) ans += dfs(S, INF);
}

int n,m;

int main()
{
    S = 301, T = 302;
    read(n), read(m);
    for(register int i = 1;i <= n;++ i)
    {
        int tmp;read(tmp);
        if(tmp) insert(S, i, 1);
        else insert(i, T, 1);
    }
    for(register int i = 1;i <= m;++ i)
    {
        int tmp1,tmp2;
        read(tmp1), read(tmp2);
        insert(tmp1, tmp2, 1);
        insert(tmp2, tmp1, 1);
    }
    dinic();
    printf("%d", ans);
    return 0;
}