uva 1440 & uvalive 4597

Posted 2021-11-28 kickit

题目链接

题意：

DAG的最小路径覆盖，一条边可以被重复覆盖多次，但是一次只能沿着DAG的方向覆盖一条链，问最少覆盖次数。

思路：

看了半天没有思路，所以去搜索了题解，然后发现是有源汇上下界的最小流，这个东西依赖于有源汇上下界的可行流，然后又依赖于无源汇上下界可行流，所以就都去学了一下，写一个简单的总结与建模方法。

无源汇上下界可行流：

首先强行指定每条边的流为下界，然后会很大概率出现流量不平衡的现象，那么现在需要让流量平衡，就需要补流与分流。
强行指定之后，设流入每个点的流量为\\(in_i\\)，流出每个点的流量为\\(out_i\\)，那么就有3种情况：

• \\(in_i = out_i\\)，此时无需做任何事情；
• \\(in_i > out_i\\)，流入的流量比流出的流量多，那么需要从附加源点\\(SS\\)引入\\(in_i - out_i\\)的流，即加边\\(adde(SS,i,in[i]-out[i])\\)；
• \\(in_i < out_i\\)，流出的流量比流入的流量多，那么需要从点分流\\(out_i - in_i\\)到附加汇点\\(TT\\)，即加边\\(adde(i,TT,out[i]-in[i])\\).

此时，只是处理完了需要流量平衡的地方，现在还需要对边的流量的上界进行限制，由于已经强行指定了边的下界，所以每一条边的上界都是原来的上界减去下界，按照这个限制对图加边即可。
最后，求\\(SS\\)到\\(TT\\)的最大流，如果满流，则说明这个图有可行流，并且每一条边的流为附加流加上指定的下界。

有源汇上下界可行流：

转化为无源汇上下界可行流，只需要加边\\(adde(T,S,inf)\\)，如此就可以保证源点和汇点也流量平衡（无源汇可行流的基础就是流量平衡）。
加边之后，按照无源汇可行流求解即可，并且\\(T\\)到\\(S\\)的反向边的流量就是原图的一个可行流。

有源汇上下界最大流：

转化为有源汇上下界可行流，在这个残量网络上求从\\(S\\)到\\(T\\)的最大流，加上之前求的可行流即是本图的最大流。

有源汇上下界最小流：

转化为可行流问题，但是稍微有不同。
首先不连边\\(adde(T,S,inf)\\)，然后求\\(SS\\)到\\(TT\\)的最大流；
之后连边\\(adde(T,S,inf)\\)，再次求\\(SS\\)到\\(TT\\)的最大流，这个最大流就是我们所求的最小流，原理不太懂，参考。

题目思路：

从源点到每个点连边，下界为0，上界为inf，表示这个点可以放下任意数量的人；
从每个点到汇点连边，下界为0，上界为inf，表示任意数量的人在这个点停止；
题目中给出的边，下界为1，上界为inf，表示每条边至少被覆盖一次。
然后求有源汇上下界最小流即可。
然后是找路径，dfs找到return即可。
但是得从S开始找，不要从某一个点开始找。假设从S到1的流量为3，但是1流出的总流量为5，从1开始dfs，就会出现某个后面的点无法找到路径的情况。

代码：

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 2e2 + 5;

vector<int> g[N];
vector<vector<int> > anc;
vector<int> tp;
int mp[N][N];
int in[N],out[N];
int dis[N],cur[N];
int S,T,SS,TT;
int st,en;

struct edge
{
    int u,v,cap,org;
    edge(int u,int v,int cap,int org):u(u),v(v),cap(cap),org(org){}
};

vector<edge> es;
vector<int> G[N];

void adde(int u,int v,int cap)
{
    es.push_back(edge(u,v,cap,cap));
    es.push_back(edge(v,u,0,0));
    int sz = es.size();
    G[u].push_back(sz-2);
    G[v].push_back(sz-1);
}

bool bfs()
{
    memset(dis,inf,sizeof dis);
    dis[st] = 0;
    queue<int> q;
    q.push(st);
    while (!q.empty())
    {
        int u = q.front();
        q.pop();
        for (int i = 0;i < G[u].size();i++)
        {
            edge &e = es[G[u][i]];
            int v = e.v;
            if (dis[v] >= inf && e.cap > 0)
            {
                dis[v] = dis[u] + 1;
                q.push(v);
            }
        }
    }
    return dis[en] < inf;
}

int dfs(int u,int flow)
{
    if (u == en) return flow;
    for (int i = cur[u];i < G[u].size();i++)
    {
        cur[u] = i;
        edge &e = es[G[u][i]];
        int v = e.v;
        if (dis[v] == dis[u] + 1 && e.cap > 0)
        {
            int tmp = dfs(v,min(flow,e.cap));
            if (tmp)
            {
                e.cap -= tmp;
                es[G[u][i]^1].cap += tmp;
                return tmp;
            }
        }
    }
    return 0;
}

int dinic()
{
    int ans = 0;
    while (bfs())
    {
        memset(cur,0,sizeof cur);
        int tmp;
        while (tmp = dfs(st,inf)) ans += tmp;
    }
    return ans;
}

void fin(int u)
{
    tp.push_back(u);
    for (int i = 0;i < g[u].size();i++)
    {
        int v = g[u][i];
        if (mp[u][v])
        {
            mp[u][v]--;
            fin(v);
            return;
        }
    }
}

int main()
{
    int n;
    while (~scanf("%d",&n))
    {
        for (int i = 0;i < N;i++)
        {
            g[i].clear();
            G[i].clear();
        }
        es.clear();
        memset(in,0,sizeof in);
        memset(out,0,sizeof out);
        memset(mp,0,sizeof mp);
        anc.clear();
        for (int i = 1;i <= n;i++)
        {
            int m;
            scanf("%d",&m);
            for (int j = 0;j < m;j++)
            {
                int x;
                scanf("%d",&x);
                g[i].push_back(x);
                mp[i][x]++;
            }
        }
        for (int i = 1;i <= n;i++)
        {
            for (int j = 0;j < g[i].size();j++)
            {
                int x = g[i][j];
                out[i]++;
                in[x]++;
            }
        }
        S = 0;T = n + 1;
        SS = n + 2;TT = n + 3;
        for (int i = 1;i <= n;i++)
        {
            for (int j = 0;j < g[i].size();j++)
            {
                int x = g[i][j];
                adde(i,x,inf);
            }
        }
        int sum = 0;
        for (int i = 1;i <= n;i++)
        {
            adde(S,i,inf);
            adde(i,T,inf);
        }
        //adde(T,S,inf);
        int cnt = 0;
        for (int i = 1;i <= n;i++)
        {
            if (in[i] > out[i])
            {
                cnt++;
                adde(SS,i,in[i] - out[i]);
                sum += in[i] - out[i];
            }
            else if (in[i] < out[i])
            {
                cnt++;
                adde(i,TT,out[i] - in[i]);
            }
        }
        //puts("GG");
        st = SS;en = TT;
        
        dinic();
        
        adde(T,S,inf);
        //printf("%d %d\\n",sum,ans);
        //if (ans == sum) puts("Yes");
        //else puts("No");
        
        int ans = dinic();
        printf("%d\\n",ans);
        //printf("%d\\n",dec);
        for (int i = 1;i <= n;i++)
        {
            for (int j = 0;j < G[i].size();j++)
            {
                edge e = es[G[i][j]];
                if (e.v == S || e.v == T || e.org == 0 || e.v == SS || e.v == TT) continue;
                mp[i][e.v] += e.org - e.cap;
            }
        }
        for (int i = 0;i < G[S].size();i++)
        {
            edge e = es[G[S][i]];
            int v = e.v;
            if (v >= 1 && v <= n)
            {
                int c = e.org - e.cap;
                while (c)
                {
                    tp.clear();
                    fin(v);
                    anc.push_back(tp);
                    c--;
                }
            }
        }
        for (int i = 0;i < anc.size();i++)
        {
            tp = anc[i];
            int sz = tp.size();
            for (int j = 0;j < sz;j++)
            {
                printf("%d%c",tp[j],j == sz - 1 ? '\\n' : ' ');
            }
        }
    }
    return 0;
}
/*
8
1 3 
1 7 
2 4 5 
1 8 
1 8
0
2 6 5
0
*/