D 勤奋的杨老师（二）（最小割）

显然是最小割的经典应用“二者选一”

这里有一个用其他算法不好解决的地方，选择了v，则必须选择所有的u，而对于这个直接建好v指向u的边，容量设为正无穷即可。（即该边不可被割）

源点指向某个知识点，边容量为收益大小，这个点再指向汇点，边容量为损失大小。

对于每个点，要么选（切断与汇点的联系），要么不选（切断与源点的联系），用链接源点的收益和减去最小割就是答案。

最小割的巨大优势是，它可以同时考虑所有点的选择，而得出最优解。

最小割==最大流

最小割：将原图割成只与源点相连和只与汇点相连的两个集合，需要割掉的最小边权和

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
#include<queue>
#include<map>
using namespace std;
typedef  long long ll;
const int MAX_N = 1600;  
const int MAX_M = 50000;  
const int INF = 1000000000;  
struct edge {
    int v, c, next;   
} e[MAX_M];
int p[MAX_N], eid;
void init() {
    memset(p, -1, sizeof(p));
    eid = 0;
}
void insert(int u, int v, int c) {  
    e[eid].v = v;
    e[eid].c = c;
    e[eid].next = p[u];
    p[u] = eid++;
}
void addedge(int u, int v, int c) {  
    insert(u, v, c);
    insert(v, u, 0);  
}
int S, T;  
int d[MAX_N];  
bool CountLayer() {  
    memset(d, -1, sizeof(d));
    queue<int> q;
    q.push(S);
    d[S] = 0;
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int i = p[u]; i != -1; i = e[i].next) {
            int v = e[i].v;
            if (e[i].c > 0 && d[v] == -1) {
                q.push(v);
                d[v] = d[u] + 1;
            }
        }
    }
    return (d[T] != -1);  
}

ll dfs(int u, int flow) {  
    if (u == T) {
        return flow;
    }
    ll res = 0;
    for (int i = p[u]; i != -1; i = e[i].next) {
        int v = e[i].v;
        if (e[i].c > 0 && d[u] + 1 == d[v]) {
            ll tmp = dfs(v, min(flow, e[i].c));  
            flow -= tmp;
            e[i].c -= tmp;
            res += tmp;
            e[i ^ 1].c += tmp;  
            if (flow == 0) {  
                break;
            }
        }
    }
    if (res == 0) {  
        d[u] = -1;
    }
    return res;
}

ll maxflow() {  
    ll res = 0;
    while (CountLayer()) {
        res += dfs(S, INF);  
    }
    return res;
}

int main()
{    int n;
    cin>>n;
    ll x,y,sum=0;
    S=0,T=n+1;
    init();
    for(int i=1;i<=n;i++)
    {    
        cin>>x>>y;
        int res=x-y;
        if(res>0) addedge(0, i, res),sum+=res;
        
        else addedge(i, n+1, -res);
        
    }
    while(~scanf("%d%d",&x,&y))
    {
        addedge(y, x, INF);
    }
    cout<<sum-maxflow()<<endl;
    
    return 0;
}