POJ 3680：Intervals（最小费用最大流）***

http://poj.org/problem?id=3680

题意：给出n个区间[Li,Ri]，每个区间有一个权值wi，要使得每个点都不被超过k个区间覆盖（最多能被k个区间覆盖），如果选取了第i个区间，那么能得到wi的权值，问最终能得到的最大权值是多少。

思路：首先把区间离散化，然后考虑构图。

第一种构图方式：

将S到第一个区间结点连一条容量为k，费用为0的边，代表最多能使用k个区间。

对于每个区间[l,r]，从l到r连一条容量为1，费用为-w[i]的边（因为跑的是最大的费用），这里如果这条边的流量为1，那么代表使用了这个区间，那么就加上费用。

将最后一个区间结点连一条容量为k，费用为0的边，同S。

对于每个离散化后的区间，将i和i+1连一条容量为INF，费用为0的边，如果不跑这条边，那么说明这段区间被覆盖了。

最后将答案取反就是最终答案。

画了个图帮助理解：如果跑1->3的区间的话，那么1->3的流量是1，那么主路径在[1,3]的时候流量为k-1，然后跑2->4，主路径在[2,3]的流量就变成k-2，跑到3的时候就变回k-1，跑到4又变回k，如果k=0的时候，那么就不能被覆盖了，因此恰好可以满足限制。

第二种构图方式：

是挑战上的，对于有负权边的构图。

S和T和i到i+1的连边和上图一样。

对于[u,v]，S到v连一条容量为1，费用为0的边，u到T连一条容量为1，费用为0的边，v到u连一条容量为1，费用为wi的边。

这个方法还不太理解。

 #include <cstdio>
 #include <algorithm>
 #include <iostream>
 #include <cstring>
 #include <string>
 #include <cmath>
 #include <queue>
 #include <vector>
 #include <map>
 #include <set>
 #include <stack>
 using namespace std;
 #define INF 0x3f3f3f3f
 #define N 510
 typedef long long LL;
 struct Edge {
     int u, v, nxt, cap, cost;
 } edge[N*N];
 int head[N], tot, pre[N], dis[N], vis[N], a[N], b[N], w[N], S, T;
 vector<int> vec;

 void Add(int u, int v, int cap, int cost) {
     edge[tot] = (Edge) { u, v, head[u], cap, cost }; head[u] = tot++;
     edge[tot] = (Edge) { v, u, head[v], , -cost }; head[v] = tot++;
 }

 bool SPFA(int S) {
     queue<int> que;
     que.push(S);
     memset(dis, INF, sizeof(dis));
     memset(vis, , sizeof(vis));
     dis[S] = ; vis[S] = ;
     while(!que.empty()) {
         int u = que.front(); que.pop();
         vis[u] = ;
         for(int i = head[u]; ~i; i = edge[i].nxt) {
             int v = edge[i].v, cost = edge[i].cost, cap = edge[i].cap;
             if(dis[v] > dis[u] + cost && cap > ) {
                 dis[v] = dis[u] + cost;
                 pre[v] = i;
                 if(!vis[v]) vis[v] = , que.push(v);
             }
         }
     }
     return dis[T] < INF;
 }

 int MFMC(int S, int T) {
     int ans = , u, flow;
     while(SPFA(S)) {
         flow = INF, u = T;
         while(u != S) {
             if(flow > edge[pre[u]].cap) flow = edge[pre[u]].cap;
             u = edge[pre[u]].u;
         } u = T;
         while(u != S) {
             edge[pre[u]].cap -= flow; edge[pre[u]^].cap += flow;
             ans += flow * edge[pre[u]].cost;
             u = edge[pre[u]].u;
         }
     }
     return ans;
 }

 int main() {
     int n, k, t; scanf("%d", &t);
     while(t--) {
         scanf("%d%d", &n, &k);
         memset(head, -, sizeof(head)); tot = ;
         vec.clear();
         for(int i = ; i <= n; i++)
             scanf("%d%d%d", &a[i], &b[i], &w[i]), vec.push_back(a[i]), vec.push_back(b[i]);
         sort(vec.begin(), vec.end());
         vec.erase(unique(vec.begin(), vec.end()), vec.end()); // 新的离散化姿势
         int cnt = vec.size();
         S = , T = cnt + ;
         int ans = ;

 //      First
         Add(S, , k, ); Add(cnt, T, k, );
         for(int i = ; i < cnt; i++) Add(i, i + , INF, );
         for(int i = ; i <= n; i++) {
             int u = lower_bound(vec.begin(), vec.end(), a[i]) - vec.begin() + ;
             int v = lower_bound(vec.begin(), vec.end(), b[i]) - vec.begin() + ;
             Add(u, v, , -w[i]);
         }
         ans -= MFMC(S, T);

 //        Second
 //        Add(S, 1, k, 0); Add(cnt, T, k, 0);
 //        for(int i = 1; i < cnt; i++) Add(i, i + 1, INF, 0);
 //        for(int i = 1; i <= n; i++) {
 //            int u = lower_bound(vec.begin(), vec.end(), a[i]) - vec.begin() + 1;
 //            int v = lower_bound(vec.begin(), vec.end(), b[i]) - vec.begin() + 1;
 //            Add(S, v, 1, 0); Add(u, T, 1, 0);
 //            Add(v, u, 1, w[i]);
 //            ans += w[i];
 //        }
 //        ans -= MFMC(S, T);
         printf("%d\n", ans);
     }
     return ;
 }

 /*
 3 1
 1 2 2
 2 3 4
 3 4 8
 3 1
 1 3 2
 2 3 4
 3 4 8
 3 2
 1 100000 100000
 1 150 301
 100 200 300
 */