【BZOJ 1191】[HNOI2006]超级英雄Hero(二分图匹配/枚举)

最大流算法解决有奖问答策略

最新推荐文章于 2024-09-25 13:58:13 发布

原创最新推荐文章于 2024-09-25 13:58:13 发布 · 205 阅读

0 ·

CC 4.0 BY-SA版权

图论同时被 3 个专栏收录

6 篇文章

订阅专栏

OJ--BZOJ

5 篇文章

订阅专栏

图论--网络流

3 篇文章

订阅专栏

本文介绍了一种使用最大流算法解决有奖问答节目中的策略问题，旨在找到通过最多题目的策略。通过构建一个包含问题和锦囊的二分图，并利用Dinic最大流算法，文章详细阐述了如何在有限的锦囊条件下，最大化正确回答的问题数量。

题面

题意：

一个有奖问答节目，有 $n$ 个问题， $m$ 个锦囊。每道题你可以在某两个锦囊之间选择一个使该题通过。假设你一道题不会。在回答过程中如果错误则游戏结束。求最多通过几道题。

IDEA：

我们枚举回答的最后一个问题 $i$ ,每次从问题 $1 - i$ 匹配对应的锦囊。如果满足完美匹配则继续。否则输出答案。

code:

#include<bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long ll;

//Dinic最大流, 节点编号从0开始 
struct MaxFlow{
    const static ll MAX_V = 2010;
    ll V;
    //终点、容量、反向边 
    struct edge{
        ll to, cap, rev;
    };
    vector<edge> G[MAX_V];
    ll level[MAX_V];//顶点到源点的距离标号 
    ll iter[MAX_V];// 当前弧，在其之前的边已经没有用了

    void add_edge(ll from, ll to, ll cap){
        G[from].push_back((edge){to, cap, (ll)G[to].size()});
        G[to].push_back((edge){from, 0, (ll)G[from].size()-1});
    } 

    // 通过BFS计算从源点出发的距离标号 
    void bfs(ll s){
        fill(level, level + V, -1);
        queue<ll> que;
        level[s] = 0;
        que.push(s);
        while (!que.empty()){
            ll v = que.front();
            que.pop();
            for (ll i=0; i< G[v].size(); i++){
                edge& e = G[v][i];
                if (e.cap > 0 && level[e.to] < 0){
                    level[e.to] = level[v] + 1;
                    que.push(e.to);
                }
            }
        }
    }

    //通过DFS寻找增广路 
    ll dfs(ll v, ll t, ll f){
        if (v == t)
            return f;
        for (ll &i = iter[v]; i < G[v].size(); i++){
            edge& e = G[v][i];
            if (e.cap > 0 && level[v] < level[e.to]){
                ll d = dfs(e.to, t, min(f, e.cap));
                if (d > 0){
                    e.cap -= d;
                    G[e.to][e.rev].cap += d;
                    return d;
                }
            }
        }
        return 0;
    }

    //求解从s到t的最大流 
    ll max_flow(ll s, ll t){
        ll flow = 0;
        for (;;){
            bfs(s);
            if(level[t] < 0)
                return flow;
            fill(iter, iter + V, 0);
            ll f;
            while ((f = dfs(s, t, INF)) > 0){
                flow += f;
            }
        }
    }

    void init(ll n = 0){
        for (ll i = 0; i < V; i++){
            G[i].clear();
        }
        V = n;
    }
}mf;
int u[2000];int v[2000];
int main(){
    int n,m;
    cin>>n>>m;
    mf.init();
    mf.V=n+m+2;
    for(int i=1;i<=m;i++) cin>>u[i]>>v[i];
    int ans=0;
    for(int i=1;i<=m;i++){
        mf.init();
        mf.V=n+m+2;
        for(int j=1;j<=m;j++){
             mf.add_edge(0,j,1);
             mf.add_edge(j,0,0);
         }
         for(int j=m+1;j<=m+n;j++){
             mf.add_edge(j,m+n+1,1);
             mf.add_edge(m+n+1,j,0);
         }
        for(int j=1;j<=i;j++){
         mf.add_edge(j,u[j]+m+1,1);
         mf.add_edge(u[j]+m+1,j,0);
         mf.add_edge(j,v[j]+m+1,1);
         mf.add_edge(v[j]+m+1,j,0);
        }
        int res=mf.max_flow(0,n+m+1);
        if(res==i) ans=i;
        else break;
    }
    cout<<ans<<endl;
    return 0;
}