【题解】CQOI2012交换棋子

感受到网络流的强大了……这道题目的关键在于:

  前后颜色不变的,流入流出的次数相等;原本是黑色的最后变成了白色,流出比流入次数多1;原本是白色最后变成黑色,流入比流出次数多一。所以我们将每一点拆成3个点,分别代表流入点,原点与流出点。最开始为黑色的点与源点连流量为1,费用为0的边,最后为黑色的点与汇点连流量为1,费用为0的边。

#include<bits/stdc++.h>
using namespace std;
#define maxn 300
#define maxm 8000
#define INF 99999
int n, m, size, tem, a[maxn][maxn], b[maxn][maxn], c[maxn][maxn], head[maxm];
int cnp, fans, ans, cost, dis[maxm], pre[maxm], flow[maxm];
int dx[10] = {0, 0, 0, 1, 1, 1, -1, -1, -1};
int dy[10] = {0, 1, -1, 0, 1, -1, 1, 0, -1};
int s = 0, t;
bool vis[maxm];
deque <int> q;

struct edge
{
    int to, last, f, c;
}E[maxn * 400];

void add(int u, int v, int f, int c)
{
    E[cnp].to = v, E[cnp].last = head[u], E[cnp].f = f, E[cnp].c = c; head[u] = cnp ++;
    E[cnp].to = u, E[cnp].last = head[v], E[cnp].f = 0, E[cnp].c = -c; head[v] = cnp ++;
}

int Get_id(int x, int y)
{
    return (x - 1) * m + y;
}

void init()
{
    memset(head, -1, sizeof(head));
}

int SPFA()
{
    q.push_back(s);
    flow[s] = INF;
    for(int i = 1; i <= n * m * 3 + 3; i ++) dis[i] = INF;
    while(!q.empty())
    {
        int u = q.front();
        q.pop_front();
        vis[u] = false;
        for(int i = head[u]; i != -1; i = E[i].last)
        {
            int v = E[i].to;
            if(E[i].f && dis[v] > dis[u] + E[i].c)
            {
                dis[v] = dis[u] + E[i].c, pre[v] = i;
                flow[v] = min(flow[u], E[i].f);
                if(!vis[v])
                {
                    vis[v] = true;
                    if(!q.empty() && dis[v] < dis[q.front()]) q.push_front(v);
                    else q.push_front(v);
                }
            }
        }
    }
    if(dis[t] >= INF) return false;
    else return true;
}

void Max_flow()
{
    while(SPFA())
    {
        int v = pre[t];
        while(2333)
        {
            E[v].f -= flow[t];
            E[v ^ 1].f += flow[t];
            if(E[v ^ 1].to == s) break;
            v = pre[E[v ^ 1].to];
        }
        ans += flow[t];
        cost += flow[t] * dis[t];
    }
}

void Get_input()
{
    for(int i = 1; i <= n; i ++)
    {
        string s; cin >> s;
        for(int j = 0; j < m; j ++)
            a[i][j + 1] = s[j] - ‘0‘;
    }
    for(int i = 1; i <= n; i ++)
    {
        string s; cin >> s;
        for(int j = 0; j < m; j ++)
            b[i][j + 1] = s[j] - ‘0‘;
    }
    for(int i = 1; i <= n; i ++)
    {
        string s; cin >> s;
        for(int j = 0; j < m; j ++)
            c[i][j + 1] = s[j] - ‘0‘;
    }
}

void Connect()
{
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= m; j ++)
        {
            int u = Get_id(i, j);
            if(a[i][j]) tem ++, add(s, u, 1, 0);
            if(b[i][j]) fans ++, add(u, t, 1, 0);
            if(a[i][j] == b[i][j])
            {
                add(u + size, u, c[i][j] / 2, 1);
                add(u, u + 2 * size, c[i][j] / 2, 1);
            }
            else if(b[i][j])
            {
                add(u + size, u, (c[i][j] + 1) / 2, 1);
                add(u, u + 2 * size, c[i][j] / 2, 1);
            }
            else if(a[i][j])
            {
                add(u + size, u, c[i][j] / 2, 1);
                add(u, u + 2 * size, (c[i][j] + 1) / 2, 1);
            }
            for(int k = 1; k <= 8; k ++)
            {
                int x = i + dx[k], y = j + dy[k];
                if(x < 1 || x > n || y < 1 || y > m) continue;
                add(u + 2 * size, Get_id(x, y) + size, INF, 0);
            }
        }
}

int main()
{
    scanf("%d%d", &n, &m);
    init();
    t = n * m * 3 + 3, size = n * m;
    Get_input();
    Connect();
    if(tem != fans)
    {
        printf("-1\n");
        return 0;
    }
    Max_flow();
    if(ans == fans) printf("%d", cost >> 1);
    else printf("-1\n");
    return 0;
} 

原文地址:https://www.cnblogs.com/twilight-sx/p/8481028.html

时间: 2024-10-07 00:18:50

【题解】CQOI2012交换棋子的相关文章

BZOJ2668: [cqoi2012]交换棋子

题解: 可以戳这里:http://www.cnblogs.com/zig-zag/archive/2013/04/21/3033485.html 其实自己yy一下就知道这样建图的正确性了. 感觉太神奇,居然还能拆成3个点 orzzzzzzzzzzzzzzzzzzzzzzzzz 跪跪跪跪跪跪跪跪 代码: 1 #include<cstdio> 2 3 #include<cstdlib> 4 5 #include<cmath> 6 7 #include<cstring&

[CQOI2012]交换棋子(最小费用最大流)

[CQOI2012]交换棋子(luogu) Description 题目描述 有一个n行m列的黑白棋盘,你每次可以交换两个相邻格子(相邻是指有公共边或公共顶点)中的棋子, 最终达到目标状态.要求第i行第j列的格子只能参与mi,j次交换. 输入格式 第一行包含两个整数n,m(1<=n, m<=20).以下n行为初始状态,每行为一个包含m个字符的01串, 其中0表示黑色棋子,1表示白色棋子.以下n行为目标状态,格式同初始状态. 以下n行每行为一个包含m个0~9数字的字符串,表示每个格子参与交换的次

[CQOI2012]交换棋子

---题面--- 题解: 其实还算是道好题 一开始很快想出了一个接近正解的建图方法,但其实是错误的,不过还是骗了70分_(:зゝ∠)_ 首先我们可以观察到棋子有限,但费用多种,其实也就相当于限制了流量,找最小费用 对于初始状态的每一个1,我们连s ---> x   flow = 1  cost = 0 对于目标状态的每一个1,我们连x ---> t  flow = 1 cost = 0 对于每一个方块,我们向周围八个格子连边 flow = inf , cost = 1(表示交换了一次) 然后就

BZOJ 2668 [cqoi2012]交换棋子 | 最小费用最大流

传送门 BZOJ 2668 题解 同时分别限制流入和流出次数,所以把一个点拆成三个:入点in(x).中间点mi(x).出点ou(x). 如果一个格子x在初始状态是黑点,则连(S, mi(x), 1, 0) 如果x在目标状态是黑点,则连(mi(x), T, 1, 0) 设x的交换次数限制是w 如果x在两种状态中颜色相同,则连(in(x), mi(x), w / 2, 0), (mi(x), ou(x), w / 2, 0) 如果x只在初始状态为黑色,则连(in(x), mi(x), w / 2,

[bzoj2668] [洛谷P3159] [cqoi2012] 交换棋子

Description 有一个n行m列的黑白棋盘,你每次可以交换两个相邻格子(相邻是指有公共边或公共顶点)中的棋子,最终达到目标状态.要求第i行第j列的格子只能参与mi,j次交换. Input 第一行包含两个整数n,m(1<=n, m<=20).以下n行为初始状态,每行为一个包含m个字符的01串,其中0表示黑色棋子,1表示白色棋子.以下n行为目标状态,格式同初始状态.以下n行每行为一个包含m个0~9数字的字符串,表示每个格子参与交换的次数上限. Output 输出仅一行,为最小交换总次数.如果

洛谷P3159 [CQOI2012]交换棋子

巧妙的拆点方式,首先把1看成黑点,0看成空的,几次交换就可以看成一条路径 1)从容量上看,这条路径为1-2-2-2-2-2----2-1 2)从费用上看,这条路径每条边费用都是1 于是用一种巧妙的拆点方式,把一个点拆成三个,连两条边,成为一条链, 然后如果是黑点的话就由s向中间那个点连边,如果是路过的话就由一条链的尾部向另一条链的首部连边 这样就满足了上面的条件1)2) 容量的话如果是黑点出来就是(c+1)/2,进来是c/2,其他的以此类推 1 #include<cstdio> 2 #incl

p3159 [CQOI2012]交换棋子

传送门 分析 https://www.luogu.org/blog/dedicatus545/solution-p3159 代码 #include<iostream> #include<cstdio> #include<cstring> #include<string> #include<algorithm> #include<cctype> #include<cmath> #include<cstdlib>

【BZOJ-2668】交换棋子 最小费用最大流

2668: [cqoi2012]交换棋子 Time Limit: 3 Sec  Memory Limit: 128 MBSubmit: 1055  Solved: 388[Submit][Status][Discuss] Description 有一个n行m列的黑白棋盘,你每次可以交换两个相邻格子(相邻是指有公共边或公共顶点)中的棋子,最终达到目标状态.要求第i行第j列的格子只能参与mi,j次交换. Input 第一行包含两个整数n,m(1<=n, m<=20).以下n行为初始状态,每行为一个

BZOJ 2668 交换棋子(费用流)

题目链接:http://61.187.179.132/JudgeOnline/problem.php?id=2668 题意:有一个n行m列的黑白棋盘,你每次可以交换两个相邻格子中的棋子,最终达到目标状态.要求第i行第j列的格子只能参与m[i,j]次交换. 思路: 我们将1看做要移动的数字,将0看做空白.那么若1在始末状态个数不同则无解:如某个格子始末状态均有1则这个格子的1对结果无影响,可以将其都置为0.将每个格子拆为为个点p0,p1,p2: (1)若格子初始为1,则连边:<s,p0,1,0>