Oooooooo AAAAE 【网络流最小点权覆盖】

Description

“Let the bass kick!O-oooooooooo AAAAE-A-A-I-A-U- JO-oooooooooooo AAE-O-A-A-U-U-A- E-eee-ee-eee AAAAE-A-E-I-E-A- JO-ooo-oo-oo-oo EEEEO-A-AAA-AAAA!”

LiMn2O4沉迷音乐游戏，每天都在摸鱼搓音游，而且是手机电脑两开花……为了帮助LiMn2O4尽快清醒过来，LiMn2O4答应skyer_hxx，只要skyer_hxx能写一个自动脚本来玩这个游戏，打败他的最高纪录，那么就不再摸鱼了。

这个游戏可以简化成：谱面由N个键和M条连线组成，每两个键之间有一个连线，玩家需要在键之间滑动，且连线的方向是固定的，玩家每次选择一个键，把所有从这个键出发的连线都消除掉，花费为ai，也可以将每个结束在这个点的连线消除，花费Bi。不用担心，LiMn2O4的手指足够多。最后让连线全部消失，得分就是总花费。花费越少，分数越高。

skyer_hxx何许人也，怎么会怕这点小问题？但是他现在很忙，需要你的帮助。请你对于给出的谱面，求出最小的花费。

Input

第一行有两个正整数N,M,含义同题目描述

接下来两行，第一行有N个正整数 ,代表从键i正向划到别的键需要的花费

第二行有N个正整数 ,代表从其他的键划到第i个键需要的花费

接下来M行，每一行都有两个正整数u，v，代表键u，v之间有一条u到v的连线。两个键之间可能有多个连线，同一个键之间也可能有连线。

Output

输出最小的花费，占一行。

Sample Input

3 2

1 2 1

2 1 2

1 2

1 3

Sample Output

2

我的想法：

1.首先想用贪心算法，存每条边然后比较out[a], in[b]。不过错的很离谱，答案要大了很多。原因是因为没看清楚题目。也就是上面我标红的地方。对于每个点只能计算一次最小的点权，用贪心的话点有重复也会重复计算进去。

2.最小点权覆盖集：从x或者y集合中选取一些点，使这些点覆盖所有的边，并且选出来的点的权值尽可能小。最大点权独立集：在二分图中找到权值和最大的点集，使得它们之间两两没有边。

3.借鉴了题解的思路。才知道是网络流最小点权覆盖问题。设立源点s和t，s连边到点i，容量为i点的权值；点j连边到t，容量为j点权值；原二分图中的边容量为INF，求最大流即为最小点权覆盖。

4.扩展：最大点权独立集可转化为最小点权覆盖问题，最大点权独立集 = 总权值 - 最小点权覆盖集

题解思路：

经典的网络流最小点权覆盖问题，首先拆点，分成左右两部分，源点向所有左节点连一条边，流量为删除出边的花费。所有右节点向汇点连一条边，流量为删除入边的费用。对于每条输入给定的边<u,v>，其在左边的点为u,v，右边的点为u’,v’，那么我们连一条<u,v’>的边，流量为∞（正无穷才不会对可行流上最小的容量产生限制）。跑一边最大流，得到的答案就是最小的费用。
首先，如果没有花费的话，这道题就是简单的最小点覆盖集。加上了点权之后，我们就要将最小割的思想融合进去。要注意费用，一定要符合S->T的顺序

代码：

 #include<stdio.h>
 #include<string.h>
 #include<queue>
 #include<algorithm>
 #define mem(a, b) memset(a, b, sizeof(a))
 const int inf = 0x3f3f3f3f;
 using namespace std;

 int n, m, cnt, head[];
 int arr[], brr[];
 int dep[];
 queue<int>Q;

 struct Edge
 {
     int to, next;
     int w;
 }edge[];

 void add(int a, int b, int w)
 {
     edge[cnt].to = b;
     edge[cnt].w = w;
     edge[cnt].next = head[a];
     head[a] = cnt ++;
 }

 int bfs(int st, int ed) //dinic算法的优化之处，先进行分层
 {
     if(st == ed)
         return ;
     while(!Q.empty())
         Q.pop();
     mem(dep, -);  //每次都初始化为未被分层
     dep[st] = ; //源点设置层次为1
     Q.push(st);
     while(!Q.empty())
     {
         int index = Q.front();
         Q.pop();
         for(int i = head[index]; i != -; i = edge[i].next)
         {
             int to = edge[i].to;
             if(dep[to] == - && edge[i].w > )
             {
                 dep[to] = dep[index] + ;
                 Q.push(to);
             }
         }
     }
     return dep[ed] != -;//返回是否成功分层
 }

 int dfs(int now, int ed, int cnt)
 {
     if(now == ed)
         return cnt;
     for(int i = head[now]; i != -; i = edge[i].next)
     {
         int to = edge[i].to;
         if(dep[to] == dep[now] +  && edge[i].w > )
         {
             int flow = dfs(to, ed, min(edge[i].w, cnt));
             if(flow > )
             {
                 edge[i].w -= flow;
                 edge[i ^ ].w += flow;
                 return flow;
             }
         }
     }
     return -;
 }

 void dinic(int st, int ed)
 {
     long long ans = ;
     while(bfs(st, ed))
     {
         while()
         {
             int inc = dfs(st, ed, inf);
             if(inc == -)
                 break;
             ans += inc;
         }
     }
     printf("%lld\n", ans);
 }

 int main()
 {
     mem(head, -);
     scanf("%d%d", &n, &m);//n个点,m条边
     for(int i = ; i <= n; i ++) //起点向汇点 2 * n + 1建边
     {
         scanf("%d", &arr[i]);
         add(i + n,  * n + , arr[i]);
         add( * n + , i + n, );
     }
     for(int i = ; i <= n; i ++)//源点 0 向终点建边
     {
         scanf("%d", &brr[i]);
         add(, i, brr[i]);
         add(i, , );
     }
     for(int i = ; i <= m; i ++)//从源点方向向汇点方向建边
     {
         int a, b;
         scanf("%d%d", &a, &b);
         add(a, b + n, inf);
         add(b + n, a, );
     }
     //从源点向汇点跑一遍最大流
     dinic(,  * n + );
     return ;
 }