最大权闭合子图题目泛做

题目1 POJ2987

题目大意：

一个公司要裁员，每个成员都有自己的效益值，可正可负，而且每个人都有自己的直接下属，如果某个人被裁员，那么他的直接下属，他的下属的下属。。。。都会离开这家公司。

现在请你确定裁员的方案，求最小裁员人数和公司的最大收益。

算法讨论：

选了一个点，其后继都必须要选，这是闭合子图的特点。所以这个题就是裸题啦。

最小裁员人数就是与S相连的点数，公司的最大收益就是正权和-最小割。

Code：

#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>

using namespace std;
typedef long long ll;
const int N = 50000 + 5;
const ll oo = 10000000000000000LL;

struct Edge {
  int from, to;
  ll cap, flow;
  Edge(int u = 0, int v = 0, ll cp = 0, ll fw = 0):
    from(u), to(v), cap(cp), flow(fw) {}
};

struct Dinic {
  int n, m, s, t;
  int cur[N], que[N * 10];
  ll dis[N];
  bool vis[N];
  vector <Edge> edges;
  vector <int> G[N];

  void add(int from, int to, ll cp) {
    edges.push_back(Edge(from, to, cp, 0));
    edges.push_back(Edge(to, from, 0, 0));
    m = edges.size();
    G[from].push_back(m - 2);
    G[to].push_back(m - 1);
  }

  bool bfs() {
    int head = 1, tail = 1;
    memset(vis, false, sizeof vis);
    dis[s] = 0; vis[s] = true; que[head] = s;
    while(head <= tail) {
      int x = que[head];
      for(int i = 0; i < (signed) G[x].size(); ++ i) {
        Edge &e = edges[G[x][i]];
        if(!vis[e.to] && e.cap > e.flow) {
          vis[e.to] = true;
          dis[e.to] = dis[x] + 1;
          que[++ tail] = e.to;
        }
      }
      ++ head;
    }
    return vis[t];
  }

  ll dfs(int x, ll a) {
    if(x == t || a == 0) return a;
    ll flw = 0, f;
    for(int &i = cur[x]; i < (signed) G[x].size(); ++ i) {
      Edge &e = edges[G[x][i]];
      if(dis[e.to] == dis[x] + 1 && (f = dfs(e.to, min(a, e.cap - e.flow))) > 0) {
        e.flow += f; edges[G[x][i] ^ 1].flow -= f; a -= f; flw += f;
        if(a == 0) break;
      }
    }
    return flw;
  }

  ll mxflow(int s, int t) {
    this->s = s; this->t = t;
    ll flw = 0;
    while(bfs()) {
      memset(cur, 0, sizeof cur);
      flw += dfs(s, oo);
    }
    return flw;
  }

  int bfs(int s) {
    queue <int> q;
    memset(vis, false, sizeof vis);
    int cnt = 1;
    q.push(s); vis[s] = true;
    while(!q.empty()) {
      int x = q.front(); q.pop();
      for(int i = 0; i < (signed)G[x].size(); ++ i) {
        Edge e = edges[G[x][i]];
        if(!vis[e.to] && e.cap > e.flow) {
          vis[e.to] = true;
          ++ cnt;
          q.push(e.to);
        }
      }
    }
    return cnt - 1;
  }
}net;

int n, m, S, T, w[N];

int main() {
  int ou = 0, as, bs;
  ll tot = 0, c = 0;
  scanf("%d%d", &n, &m);
  S = 0; T = n + 1;
  for(int i = 1; i <= n; ++ i) {
    scanf("%d", &w[i]);
    if(w[i] > 0) {
      net.add(S, i, w[i]);
      tot += w[i];
    }
    else if(w[i] < 0) {
      net.add(i, T, -w[i]);
    }
  }
  for(int i = 1; i <= m; ++ i) {
    scanf("%d%d", &as, &bs);
    net.add(as, bs, oo);
  }
  c = net.mxflow(S, T);
  tot = tot - c;
  ou = net.bfs(S);
  printf("%d %lld
", ou, tot);
  return 0;
}

题目2 HDU3879

题目大意：

要选择位置建立通信站，在第i个位置建立要花费的代价 为wi，如果i .. j两个点都建立了通信站，那么这两个点之间就可以进行通信，而且可以收获c的收益。

求最大收益。

算法讨论：

我们把所有事情都看做一个事件，建立一个站是一个负权点，权值为wi，两个点都建立通信站是一个正权点，权值为c，而且这个点发生的前提是这两个点都已经建立了站点。

所以满足闭合子图的定义，就这样直接建立网络流的模型即可。

代码：

#include <cstdlib>
#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>

using namespace std;

const int N = 55000 + 5;
const int oo = 0x3f3f3f3f;

struct Edge {
  int from, to, cap, flow;
  Edge(int u = 0, int v = 0, int cp = 0, int fw = 0) :
    from(u), to(v), cap(cp), flow(fw) {}
};

struct Dinic {
  int n, m, s, t;
  int dis[N], cur[N], que[N * 10];
  bool vis[N];
  vector <Edge> edges;
  vector <int> G[N];

  void clear() {
    for(int i = 0; i <= n; ++ i) G[i].clear();
    edges.clear();
    n = 0; s = t = 0;
  }

  void add(int from, int to, int cap) {
    edges.push_back(Edge(from, to, cap, 0));
    edges.push_back(Edge(to, from, 0, 0));
    m = edges.size();
    G[from].push_back(m - 2);
    G[to].push_back(m - 1);
  }

  bool bfs() {
    int head = 1, tail = 1;
    memset(vis, false, sizeof vis);
    dis[s] = 0; vis[s] = true; que[head] = s;
    while(head <= tail) {
      int x = que[head];
      for(int i = 0; i < (signed) G[x].size(); ++ i) {
        Edge &e = edges[G[x][i]];
        if(!vis[e.to] && e.cap > e.flow) {
          vis[e.to] = true;
          dis[e.to] = dis[x] + 1;
          que[++ tail] = e.to;
        }
      }
      ++ head;
    }
    return vis[t];
  }

  int dfs(int x, int a) {
    if(x == t || a == 0) return a;
    int flw = 0, f;
    for(int &i = cur[x]; i < (signed) G[x].size(); ++ i) {
      Edge &e = edges[G[x][i]];
      if(dis[e.to] == dis[x] + 1 && (f = dfs(e.to, min(a, e.cap - e.flow))) > 0) {
        e.flow += f; edges[G[x][i] ^ 1].flow -= f; a -= f; flw += f;
        if(a == 0) break;
      }
    }
    return flw;
  }

  int mx(int s, int t) {
    this->s = s; this->t = t;
    int flw = 0;
    while(bfs()) {
      memset(cur, 0, sizeof cur);
      flw += dfs(s, oo);
    }
    return flw;
  }
}net;

int n, m, w[N];
int S, T;

int main() {
  int tot = 0, a, b, c;
  while(~scanf("%d%d", &n, &m)) {
    net.clear(); tot = 0;
    net.n = n + m + 1;
    S = 0; T = n + m + 1;
    for(int i = 1; i <= n; ++ i) {
      scanf("%d", &w[i]);
      net.add(i + m, T, w[i]);
    }
    for(int i = 1; i <= m; ++ i) {
      scanf("%d%d%d", &a, &b, &c);
      net.add(S, i, c);
      tot += c;
      net.add(i, a + m, oo);
      net.add(i, b + m, oo);
    }
    printf("%d
", tot - net.mx(S, T));
  }
  return 0;
}