洛谷P4843 清理雪道

题意：给你DAG，求最小路径边覆盖。路径可重。

解：首先可以想到边转点，发现有n²条边，果断超时。

有源汇有上下界最小流。

建图：每条边都建立一条边，流量限制为[1, 1]。

源点向每个点连边，因为都可以作为起点。流量不限。

每个点向汇点连边，同上。

求最小可行流。

首先去掉下界限制，跑出一个可行流。

然后求t -> s的最大流，退掉多余流。

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

 const int N = , M = , INF = 0x3f3f3f3f;

 struct Edge {
     int nex, v, c;
 }edge[N << ]; int top = ;

 int e[N], d[N], ot[N];
 std::queue<int> Q;

 inline void add(int x, int y, int z) {
     top++;
     edge[top].v = y;
     edge[top].c = z;
     edge[top].nex = e[x];
     e[x] = top;

     top++;
     edge[top].v = x;
     edge[top].c = ;
     edge[top].nex = e[y];
     e[y] = top;
     return;
 }

 inline bool BFS(int s, int t) {
     memset(d, , sizeof(d));
     d[s] = ;
     Q.push(s);
     while(!Q.empty()) {
         int x = Q.front();
         Q.pop();
         for(int i = e[x]; i; i = edge[i].nex) {
             int y = edge[i].v;
             if(!edge[i].c || d[y]) {
                 continue;
             }
             d[y] = d[x] + ;
             Q.push(y);
         }
     }
     return d[t];
 }

 int DFS(int x, int t, int maxF) {
     if(x == t) {
         return maxF;
     }
     int ans = ;
     for(int i = e[x]; i; i = edge[i].nex) {
         int y = edge[i].v;
         if(!edge[i].c || d[x] +  != d[y]) {
             continue;
         }
         int temp = DFS(y, t, std::min(edge[i].c, maxF - ans));
         if(!temp) {
             d[y] = INF;
         }
         ans += temp;
         edge[i].c -= temp;
         edge[i ^ ].c += temp;
         if(ans == maxF) {
             break;
         }
     }
     return ans;
 }

 inline int solve(int s, int t) {
     int ans = ;
     while(BFS(s, t)) {
         ans += DFS(s, t, INF);
     }
     return ans;
 }

 int main() {

     int n;
     scanf("%d", &n);
     int s = n + , t = n + ;
     for(int i = , x, y; i <= n; i++) {
         scanf("%d", &x);
         for(int j = ; j <= x; j++) {
             scanf("%d", &y);
             add(i, y, INF);
             ot[i]++;
             ot[y]--;
         }
         add(s, i, INF);
         add(i, t, INF);
     }
     int ss = n + , tt = n + , sum = ;
     for(int i = ; i <= n; i++) {
         if(ot[i] > ) {
             add(i, tt, ot[i]);
             sum += ot[i];
         }
         else if(ot[i] < ) {
             add(ss, i, -ot[i]);
         }
     }
     add(t, s, INF);
     solve(ss, tt);
     int ans;
     for(int i = e[s]; i; i = edge[i].nex) {
         if(edge[i].v == t) {
             ans = edge[i].c;
             break;
         }
     }
     for(int i = e[ss]; i; i = edge[i].nex) {
         edge[i].c = edge[i ^ ].c = ;
     }
     for(int i = e[tt]; i; i = edge[i].nex) {
         edge[i].c = edge[i ^ ].c = ;
     }
     edge[top].c = edge[top - ].c = ;

     ans -= solve(t, s);
     printf("%d", ans);
     return ;
 }

AC代码

题外话：

一开始感觉跟餐巾计划问题很像，结果没想出费用流做法......

餐巾计划问题也没想出上下界做法...

太菜了。