POJ 3680 Intervals（最小费用流）

题目链接：点击打开链接

题意：n个区间， 每个区间有一个值， 让你选择若干区间， 使得没有一个点被覆盖超过k次的前提下的最大值。

思路：我们可以把区间端点离散化然后跑费用流， 不超过k次， 我们可以把这个对应流量属性。  那么不难想到， 将区间端点作为结点， 连一条流量为1，费用为-a[i].c的边， 因为可以跳过一些点， 所以我们把每个相邻端点之间用流量INF，费用为0的边连接， 然后源点流量为k， 汇点流量为k， 当其满流的时候， 就求出了最大费用， 而且可以保证每个结点覆盖不会超过k次。

最后多说一下， 这个流量特性， 为什么最大流等于最小割， 其实很简单， 因为限制一条路的最大流量的就是那个最小流量的地方。

细节参见代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<bitset>
#include<cstdlib>
#include<cmath>
#include<set>
#include<list>
#include<deque>
#include<map>
#include<queue>
#define Max(a,b) ((a)>(b)?(a):(b))
#define Min(a,b) ((a)<(b)?(a):(b))
using namespace std;
typedef long long ll;
typedef long double ld;
const ld eps = 1e-9, PI = 3.1415926535897932384626433832795;
const int mod = 1000000000 + 7;
const int INF = 0x3f3f3f3f;
// & 0x7FFFFFFF
const int seed = 131;
const ll INF64 = ll(1e18);
const int maxn = 500;
struct Edge {
  int from, to, cap, flow, cost;
};

struct MCMF {
  int n, m, s, t;
  vector<Edge> edges;
  vector<int> G[maxn];
  int inq[maxn];         // 是否在队列中
  int d[maxn];           // Bellman-Ford
  int p[maxn];           // 上一条弧
  int a[maxn];           // 可改进量

  void init(int n) {
    this->n = n;
    for(int i = 0; i < n; i++) G[i].clear();
    edges.clear();
  }

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

  bool BellmanFord(int s, int t, int& flow, int& cost) {
    for(int i = 0; i < n; i++) d[i] = INF;
    memset(inq, 0, sizeof(inq));
    d[s] = 0; inq[s] = 1; p[s] = 0; a[s] = INF;

    queue<int> Q;
    Q.push(s);
    while(!Q.empty()) {
      int u = Q.front(); Q.pop();
      inq[u] = 0;
      for(int i = 0; i < G[u].size(); i++) {
        Edge& e = edges[G[u][i]];
        if(e.cap > e.flow && d[e.to] > d[u] + e.cost) {
          d[e.to] = d[u] + e.cost;
          p[e.to] = G[u][i];
          a[e.to] = min(a[u], e.cap - e.flow);
          if(!inq[e.to]) { Q.push(e.to); inq[e.to] = 1; }
        }
      }
    }
    if(d[t] == INF) return false;
    flow += a[t];
    cost += d[t] * a[t];
    int u = t;
    while(u != s) {
      edges[p[u]].flow += a[t];
      edges[p[u]^1].flow -= a[t];
      u = edges[p[u]].from;
    }
    return true;
  }

  // 需要保证初始网络中没有负权圈
  int Mincost(int s, int t) {
    int cost = 0, flow = 0;
    while(BellmanFord(s, t, flow, cost));
    return cost;
  }

};
struct node {
    int a, b, c;
}a[maxn];
MCMF g;
int T, n, k, b[maxn];
int main() {
    scanf("%d",&T);
    while(T--) {
        scanf("%d%d",&n,&k);
        int cnt = 0;
        for(int i=0;i<n;i++) {
            scanf("%d%d%d",&a[i].a,&a[i].b,&a[i].c);
            b[cnt++] = a[i].a;
            b[cnt++] = a[i].b;
        }
        sort(b, b+cnt);
        int len = unique(b, b+cnt) - b;
        g.init(len + 3);
        for(int i=0;i<len-1;i++) {
            g.AddEdge(i, i+1, INF, 0);
        }
        int s = len, t = len + 1;
        g.AddEdge(s, 0, k, 0);
        g.AddEdge(len-1, t, k, 0);
        for(int i=0;i<n;i++) {
            int l = lower_bound(b, b+len, a[i].a) - b;
            int r = lower_bound(b, b+len, a[i].b) - b;
            g.AddEdge(l, r, 1, -a[i].c);
        }
        printf("%d\n",-g.Mincost(s, t));
    }
    return 0;
}