【题解】Inspection UVa 1440 LA 4597 NEERC 2009

题目传送门：https://vjudge.net/problem/UVA-1440

看上去很像DAG的最小路径覆盖QwQ？

反正我是写了一个上下界网络流，建模方法清晰易懂。

建立源$s$，向每个原图中的点连边，下界为$0$，上界为$infty$，表示在每个点可以放置无限多的人。

建立汇$t$，每个原图中的点向汇连边，下界为$0$，上界为$infty$，表示人可以在任意一个点停止滑雪。

对于原图中的每条弧$<u,v>$，连边$<u,v>$，下界为$1$，上界为$infty$，表示这条路至少要被检查一遍。

然后跑一个有源汇上下界最小流就好啦OvO。

不会求上下界网络流的看这里：http://www.cnblogs.com/mlystdcall/p/6734852.html

输出方案？瞎搞QwQ。任选一个“需要放置人的点”开始dfs，在每个点的出边中任选一个“还需要被访问的”继续dfs，详见代码和注释。

这样输出方案为什么是对的？时间太久远辣我已经忘辣QwQ。

代码如下：

#include <algorithm>
#include <cstring>
#include <cstdio>
#include <queue>

using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 110;

namespace ISAP {
    const int MAXV = MAXN;
    const int MAXE = ( MAXV*MAXV/2 + MAXV*2 )*3;
    
    struct Edge {
        int u, v, c, f;
        Edge(){}
        Edge( int u, int v, int c, int f ):
            u(u),v(v),c(c),f(f){}
    }edge[MAXE<<1];
    int n, m, s, t, ss, tt;
    int head[MAXV], nxt[MAXE<<1], eid[MAXE<<1], eidx;
    void init( int n2, int ss2, int tt2 ) { // 初始化，设置附加源和附加汇
        n = n2; ss = ss2; tt = tt2;
        m = eidx = 0;
        memset( head, -1, sizeof(head) );
    }
    int adde( int u, int v, int c ) { // 添加一条只有上界的边
        int rtn = m;
        eid[eidx] = m; nxt[eidx] = head[u]; head[u] = eidx++;
        edge[m++] = Edge(u,v,c,0);
        eid[eidx] = m; nxt[eidx] = head[v]; head[v] = eidx++;
        edge[m++] = Edge(v,u,0,0);
        return rtn;
    }
    int adde2( int u, int v, int b, int c ) { // 添加一条有上下界的边，返回边的下标
        int rtn = adde(u,v,c-b);
        adde(ss,v,b);
        adde(u,tt,b);
        return rtn;
    }
    // 以下ISAP板子
    int prev[MAXV], dist[MAXV], num[MAXV], cur[MAXV], res[MAXV];
    queue<int> bfsq;
    void bfs() {
        for( int i = 1; i <= n; ++i ) dist[i] = n;
        dist[t] = 0; bfsq.push(t);
        while( !bfsq.empty() ) {
            int u = bfsq.front(); bfsq.pop();
            for( int i = head[u]; ~i; i = nxt[i] ) {
                Edge &e = edge[eid[i]];
                if( dist[e.v] == n ) {
                    dist[e.v] = dist[u] + 1;
                    bfsq.push(e.v);
                }
            }
        }
    }
    void augment() {
        int u = t, flow = res[t];
        while( u != s ) {
            int i = prev[u];
            edge[i].f += flow;
            edge[i^1].f -= flow;
            u = edge[i].u;
        }
    }
    bool advance( int &u ) {
        for( int i = cur[u]; ~i; i = nxt[i] ) {
            Edge &e = edge[eid[i]];
            if( e.c > e.f && dist[e.v] + 1 == dist[u] ) {
                prev[e.v] = cur[u] = i;
                res[e.v] = min( res[u], e.c - e.f );
                u = e.v;
                return true;
            }
        }
        return false;
    }
    bool retreat( int &u ) {
        if( --num[dist[u]] == 0 ) return false;
        int newd = n;
        for( int i = head[u]; ~i; i = nxt[i] ) {
            Edge &e = edge[eid[i]];
            if( e.c > e.f ) newd = min( newd, dist[e.v] + 1 );
        }
        ++num[ dist[u] = newd ];
        cur[u] = head[u];
        if( u != s ) u = edge[prev[u]].u;
        return true;
    }
    int solve( int s2, int t2 ) { // 以s2为源，t2为汇跑最大流
        s = s2; t = t2;
        bfs();
        for( int i = 1; i <= n; ++i )
            cur[i] = head[i], ++num[dist[i]];
        int u = s, flow = 0;
        res[s] = INF;
        while( dist[s] < n ) {
            if( u == t ) {
                augment();
                flow += res[t];
                u = s;
            }
            if( !advance(u) )
                if( !retreat(u) )
                    break;
        }
        return flow;
    }
}

int n, s, t, ss, tt; // 点的个数，源，汇，附加源，附加汇

namespace Solve {
    using ISAP::head;
    using ISAP::nxt;
    using ISAP::eid;
    using ISAP::Edge;
    using ISAP::edge;
    bool first;
    void dfs( int u ) { // dfs输出方案
        // printf( "Debug: u = %d
", u );
        if( !first ) putchar(' ');
        first = false;
        printf( "%d", u );
        for( int i = head[u]; ~i; i = nxt[i] ) {
            Edge &e = edge[eid[i]];
            if( e.v <= n && e.f > 0 ) { // 任选一条边走下去
                // printf( "going eid = %d, from %d to %d, flow_left = %d
", eid[i], e.u, e.v, e.f );
                --e.f;
                dfs(e.v);
                return;
            }
        }
    }
    void addbound() { // 把每条边流量加上下界，恢复成原图的样子，方便输出方案
        using ISAP::m;
        for( int i = 0; i < m; ++i ) {
            Edge &e = edge[eid[i]];
            if( e.u <= n && e.v <= n && e.c > 0 )
                ++e.f;
        }
    }
}

namespace Debug { // 调试用QwQ
    void print_flow() {
        using ISAP::edge;
        using ISAP::Edge;
        using ISAP::eid;
        using ISAP::m;
        for( int i = 0; i < m; ++i ) {
            Edge &e = edge[eid[i]];
            if( e.u <= n && e.v <= n && e.c > 0 )
                printf( "eid = %d, from %d to %d, flow = %d
", eid[i], e.u, e.v, e.f );
        }
    }
    void print_flow2() {
        using ISAP::edge;
        using ISAP::Edge;
        using ISAP::eid;
        using ISAP::m;
        for( int i = 0; i < m; ++i ) {
            Edge &e = edge[eid[i]];
            if( e.f > 0 )
                printf( "eid = %d, from %d to %d, flow = %d
", eid[i], e.u, e.v, e.f );
        }
    }
}

int main() {
    while( scanf( "%d", &n ) == 1 ) {
        s = n+1, t = n+2, ss = n+3, tt = n+4;
        ISAP::init(tt,ss,tt);
        for( int i = 1; i <= n; ++i ) {
            int mi; scanf( "%d", &mi );
            while( mi-- ) {
                int v; scanf( "%d", &v );
                ISAP::adde2(i,v,1,INF);
            }
            ISAP::adde2(s,i,0,INF);
            ISAP::adde2(i,t,0,INF);
        }
        int flow1 = ISAP::solve(ss,tt);
        // printf( "flow1 = %d
", flow1 );
        // Debug::print_flow();
        // Debug::print_flow2();
        int tsedge = ISAP::adde2(t,s,0,INF); // 存储弧<t,s>的信息，调试用QwQ
        int ans = ISAP::solve(ss,tt);
        // printf( "t_s flow = %d
", ISAP::edge[tsedge].f );
        // Debug::print_flow();
        // Debug::print_flow2();
        printf( "%d
", ans );
        Solve::addbound(); // 把每条图中的边流量加上下界，恢复成原图的样子，方便输出方案
        while( ans ) {
            using namespace Solve;
            for( int i = head[s]; ~i; i = nxt[i] ) {
                Edge &e = edge[eid[i]];
                if( e.v <= n && e.f > 0 ) { // 任选一个点dfs，输出方案
                    first = true;
                    --e.f;
                    --ans;
                    dfs(e.v);
                        putchar('
');
                }
            }
        }
    }
    return 0;
}