洛谷 P2055 [ZJOI2009] 假期的宿舍（最大流）

题目链接

https://www.luogu.com.cn/problem/P2055

思路

根据样例。我们从源点$S$向所有不回家的在校生和非在校生连一条容量为$1$的边。我们从所有的在校生向汇点$T$连一条容量为$1$的边。再根据所有的认识关系，从不回家的在校生和非在校生中的点向在校生中的点连一条容量为$1$的边。如上图所示。

我们可以求出从源点到汇点的最大流，如果最大流的值与源点$S$向所有不回家的在校生和非在校生连边的数量相等，则存在一种方案，否则不存在方案。

代码

#include <bits/stdc++.h>

using namespace std;

#define int long long
#define double long double

typedef long long i64;
typedef unsigned long long u64;
typedef pair<int, int> pii;

const int N = 1e2 + 5, M = 6e4 + 5;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f3f3f3f3f;

int n, m, S, T;
int a[N], b[N];
int d[N];   // 点在分层图中的编号
int cur[N]; // 当前弧优化，存储从当前节点开始还需要遍历的点的编号
struct Edge
{
    int to, f, next; // 终点，容量，同起点的上一条边的编号
} edge[M];           // 边集
int head[N], idx;    // head[i],表示以i为起点的第一条边在边集数组的位置（编号）
void init()          // 初始化
{
    for (int i = 0; i < N; i++)
        head[i] = -1;
    idx = 0;
}
void add_edge(int u, int v, int f) // 加边，u起点，v终点，w容量
{
    edge[idx].to = v;         // 终点
    edge[idx].f = f;          // 权值
    edge[idx].next = head[u]; // 以u为起点上一条边的编号，也就是与这个边起点相同的上一条边的编号
    head[u] = idx++;          // 更新以u为起点上一条边的编号
}
bool bfs()
{
    queue<int> q;
    memset(d, -1, sizeof d);
    q.push(S);
    d[S] = 0;
    cur[S] = head[S];
    while (q.size())
    {
        int u = q.front();
        q.pop();
        for (int i = head[u]; i != -1; i = edge[i].next)
        {
            int j = edge[i].to;
            if (d[j] == -1 && edge[i].f)
            {
                d[j] = d[u] + 1;
                cur[j] = head[j];
                if (j == T)
                    return true;
                q.push(j);
            }
        }
    }
    return false;
}
// 从起点S到当前点u允许流过的最大流量为limit
int find(int u, int limit)
{
    if (u == T)
        return limit;
    int flow = 0;
    for (int i = cur[u]; i != -1 && flow < limit; i = edge[i].next)
    {
        cur[u] = i; // 当前弧优化
        int j = edge[i].to;
        if (d[j] == d[u] + 1 && edge[i].f)
        {
            int op = find(j, min(edge[i].f, limit - flow));
            // 废点优化
            // op==0 说明不能找到从j到T的增广路
            // 因此下一次遍历到j时直接跳过即可, 将d[j]标记为-1即可
            if (!op)
                d[j] = -1;
            edge[i].f -= op;
            edge[i ^ 1].f += op;
            flow += op;
        }
    }
    return flow;
}
int dinic()
{
    int ans = 0, flow;
    while (bfs())
    {
        while (flow = find(S, inf))
            ans += flow;
    }
    return ans;
}
void solve(int test_case)
{
    cin >> n;
    init();
    S = 0, T = n * 2 + 1;
    int cnt = 0;
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
    }
    for (int i = 1; i <= n; i++)
    {
        cin >> b[i];
    }
    for (int i = 1; i <= n; i++)
    {
        if ((a[i] == 1 && b[i] == 0) || a[i] == 0)
        {
            add_edge(i, n + i, 1);
            add_edge(n + i, i, 0);
            add_edge(S, i, 1);
            add_edge(i, S, 0);
            cnt++;
        }
        if (a[i] == 1)
        {
            add_edge(n + i, T, 1);
            add_edge(T, n + i, 0);
        }
    }
    for (int i = 1, x; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            cin >> x;
            if (x == 1)
            {
                if ((a[i] == 1 && b[i] == 0) || a[i] == 0)
                {
                    add_edge(i, n + j, 1);
                    add_edge(n + j, i, 0);
                }
            }
        }
    }
    int ans = dinic();
    if (ans == cnt)
    {
        cout << "^_^" << endl;
    }
    else cout << "T_T" << endl;
}

signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int test = 1;
    cin >> test;
    for (int i = 1; i <= test; i++)
    {
        solve(i);
    }
    return 0;
}