zkw费用流模版

/**************************************************************
    Problem: 3876
    User: wangck1998
    Language: C++
    Result: Accepted
    Time:176 ms
    Memory:1456 kb
****************************************************************/
 
#include <bits/stdc++.h>
using namespace std;
  
#ifdef debug
#define ep(...) fprintf(stderr, __VA_ARGS__)
#else
#define ep(...) assert(true)
#endif
  
const int MAXN = 303;
const int INF = 0x3f3f3f3f;
  
const int MAXV = MAXN + 3;
const int MAXE = (5003 + MAXN * 2) * 2;
  
struct Edge {
  Edge* next;
  int dest;
  int cap;
  int val;
};
  
Edge memory[MAXE];
Edge* curMemory = memory;
Edge* info[MAXV];
  
 
void insert(int u, int v, int c, int l) {
  curMemory->next = info[u];
  curMemory->dest = v;
  curMemory->cap = c;
  curMemory->val = l;
  info[u] = curMemory++;
 
  curMemory->next = info[v];
  curMemory->dest = u;
  curMemory->cap = 0;
  curMemory->val = -l;
  info[v] = curMemory++;
}
 
  
Edge* oppsiteEdge(const Edge* const x) {
  return memory + ((x - memory) ^ 1);
}
  
int n;
int S, T;
  
  
int d[MAXV];
bool vis[MAXV];
int slack[MAXV];
Edge* pre[MAXV];
 
int dfs(int u, int flow) {
  if (u == T) return flow;
  vis[u] = true;
  int rest = flow;
  for (Edge* &pt = pre[u]; pt; pt = pt->next) {
    int v = pt->dest;
    if (pt->cap) {
      if (d[u] + pt->val == d[v] && ! vis[v]) {
        int temp = dfs(v, min(rest, pt->cap));
        if (temp) {
          rest -= temp;
          pt->cap -= temp;
          oppsiteEdge(pt)->cap += temp;
          if (rest == 0) return flow;
        }
      }
      else slack[v] = min(slack[v], d[u] + pt->val - d[v]);
    }
  }
  return flow - rest;
}
 
int maxFlow() {
  fill(d, d + T + 1, INF);
  d[S] = 0;
  queue<int> que;
  que.push(S);
  do {
    int u = que.front();
    que.pop();
    for (Edge* pt = info[u]; pt; pt = pt->next) 
      if (pt->cap) {
        int v = pt->dest;
        int temp = d[u] + pt->val;
        if (temp < d[v]) {
          d[v] = temp;
          que.push(v);
        }
      }
  }while (! que.empty());
 
  int ret = 0;
  while (1) {
    while (1) {
      fill(vis, vis + T + 1, false);
      fill(slack, slack + T + 1, INF);
      copy(info, info + T + 1, pre);
      int temp = dfs(S, INF);
      if (temp) ret += (d[T] - d[S]) * temp;
      else break;
    }
 
    int temp = INF;
    for (int i = 0; i <= T; i++) 
      if (! vis[i]) temp = min(temp, slack[i]);
    if (temp == INF) break;
    for (int i = 0; i <= T; i++) 
      if (vis[i]) d[i] -= temp;
  }
  return ret;
}
 
int main() {
    scanf("%d", &n);
    S = 0, T = n + 1;
  
    int ans = 0;
    static int degree[MAXN];
    for (int i = 1; i <= n; i ++) {
        int m;
        scanf("%d", &m);
        degree[i] -= m;
        for (int j = 0; j < m; j ++) {
            int v, c;
            scanf("%d%d", &v, &c);
            degree[v] ++;
            insert(i, v, INF, c);
            ans += c;
        }
    }
  
    for (int i = 1; i <= n; i ++) {
        if (degree[i] > 0) {
            insert(S, i, degree[i], 0);
        }
        else if (degree[i] < 0) {
            insert(i, T, - degree[i], 0);
        }
        insert(i, 1, INF, 0);
    }
  
    printf("%d
", ans + maxFlow());
  
    return 0;
}