矩阵游戏_bzoj1059_网络流

Description

---

　　小Q是一个非常聪明的孩子，除了国际象棋，他还很喜欢玩一个电脑益智游戏——矩阵游戏。矩阵游戏在一个N
*N黑白方阵进行（如同国际象棋一般，只是颜色是随意的）。每次可以对该矩阵进行两种操作：行交换操作：选择
矩阵的任意两行，交换这两行（即交换对应格子的颜色）列交换操作：选择矩阵的任意行列，交换这两列（即交换
对应格子的颜色）游戏的目标，即通过若干次操作，使得方阵的主对角线(左上角到右下角的连线)上的格子均为黑
色。对于某些关卡，小Q百思不得其解，以致他开始怀疑这些关卡是不是根本就是无解的！！于是小Q决定写一个程
序来判断这些关卡是否有解。

Input

---

　　第一行包含一个整数T，表示数据的组数。接下来包含T组数据，每组数据第一行为一个整数N，表示方阵的大
小；接下来N行为一个N*N的01矩阵（0表示白色，1表示黑色）。

Output

---

　　输出文件应包含T行。对于每一组数据，如果该关卡有解，输出一行Yes；否则输出一行No。
　

Analysis

---

首先说明，同行同列的黑格子不可能通过某种转换变得在对角线上
那么接下来就简单了，题目变成求是否有n个不同行同列的不同黑格子存在
连边求最大匹配

还有就是，代码里面我用e[i]和e[i^1]表示两条对边，如果边从1开始算起的话，那么1^1=0，也就是它的对边变成了不存在的第0条边。
因此我们把初始edgecnt = 1就可以a了

Code

---

#include <cstring>
#include <cstdio>
#include <queue>
#define rep(i, a, b) for (int i = a; i <= b; i ++)
#define fill(x, t) memset(x, t, sizeof(x))
#define N 505
#define E N * N * 2 + 1
#define INF 0x3f3f3f3f
using namespace std;
struct edge{int y, w, next;}e[E];
int cur[N], dis[N], ls[N], edgecnt;
inline int read(){
    int x = 0, v = 1; char ch = getchar();
    while (ch < '0' || ch > '9'){
        if (ch == '-'){
            v = -1;
        }
        ch = getchar();
    }
    while (ch <='9' && ch >= '0'){
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * v;
}
int min(int x, int y){
    return x<y?x:y;
}
int add(int x, int y, int w){
    e[++edgecnt] = (edge){y, w, ls[x]}; ls[x] = edgecnt;
    e[++edgecnt] = (edge){x, 0, ls[y]}; ls[y] = edgecnt;
    return 0;
}
int bfs(int st, int ed){
    queue<int>q;
    fill(dis, 0);
    q.push(st);
    dis[st] = 1;
    while (!q.empty()){
        int now = q.front(); q.pop();
        for (int i = ls[now]; i; i = e[i].next){
            if (e[i].w > 0 && !dis[e[i].y]){
                dis[e[i].y] = dis[now] + 1;
                q.push(e[i].y);
                if (ed == e[i].y){
                    return 1;
                }
            }
        }
    }
    return 0;
}
int find(int now, int ed, int mn){
    if (now == ed || !mn){
        return mn;
    }
    int ret = 0;
    for (int &i = cur[now]; i; i = e[i].next){
        if (e[i].w > 0 && dis[now] + 1 == dis[e[i].y]){
            int d = find(e[i].y, ed, min(mn - ret, e[i].w));
            e[i].w -= d;
            e[i ^ 1].w += d;
            ret += d;
            if (ret == mn){
                break;
            }
        }
    }
    return ret;
}
int dinic(int n, int st, int ed){
    int mxFlow = 0;
    while (bfs(st, ed)){
        rep(i, st, ed){
            cur[i] = ls[i];
        }
        mxFlow += find(st, ed, INF);
    }
    return mxFlow;
}
int main(void){
    int T = read();
    while (T --){
        edgecnt = 1;
        fill(ls, 0);
        int n = read();
        rep(i, 1, n){
            rep(j, 1, n){
                int tmp = read();
                if (tmp == 1){
                    add(i, j + n, 1);
                }
            }
        }
        int st = 0, ed = n + n + 1;
        rep(i, 1, n){
            add(st, i, 1);
            add(i + n, ed, 1);
        }
        int ans = dinic(n, st, ed);
        if (ans == n){
            printf("Yes\n");
        }else{
            printf("No\n");
        }
    }
    return 0;
}