【2018焦作网络赛】 Modular Production Line（费用流)

题意

给出 NN 种零件，现在你可以用连续的一些零件组装成为一个产品，组装完你可以获得 ww 的价值，要求每种零件最多使用 KK 次并且每一个产品只能生产一个。问你最多可以获得的价值是多少。

思路

由于给出的 NN 很大， MM很小，那么显然，很多点都是没有用的，那么我们就可以将他们舍弃掉，只使用出现的点，那么可以考虑到离散化。

对于给出的每一个区间 [u,v][u,v] 内的零件，我们可以从 uu 到 v+1v+1 建一条流量为11，费用为 −w−w 的边，表示制作了这一个产品的情况。
对于全部的点，我们可以建一条从 ii 到 i+1i+1 的边，表示第 ii 个零件不使用的情况。
对于超级源点和超级汇点，我们建一条从超级源点到第一个点，流量为 KK，费用为 00 的边，在建一条从最后一个点到超级汇点，流量为 KK，费用为 00 的边，这是为了防止任意一种零件使用次数超过 KK，所以从一开始就限制了流量。
最后跑最小费用最大流，算出的答案的绝对值就是要求的。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1000;
const int MAXM = 100000;
const int INF = 0x3f3f3f3f;
struct Edge{
    int to, next, cap, flow, cost;
} edge[MAXM];
int head[MAXN], tol;
int pre[MAXN], dis[MAXN];
bool vis[MAXN];
int N;
void init(int n)
{
    N = n;
    tol = 0;
    memset(head, -1, sizeof(head));
}

void addedge(int u, int v, int cap, int cost)
{
    edge[tol].to = v;
    edge[tol].cap = cap;
    edge[tol].cost = cost;
    edge[tol].flow = 0;
    edge[tol].next = head[u];
    head[u] = tol++;
    edge[tol].to = u;
    edge[tol].cap = 0;
    edge[tol].cost = -cost;
    edge[tol].flow = 0;
    edge[tol].next = head[v];
    head[v] = tol++;
}

bool spfa(int s, int t){
    queue<int> q;
    for (int i = 0; i < N; i++){
        dis[i] = INF;
        vis[i] = false;
        pre[i] = -1;
    }
    dis[s] = 0;
    vis[s] = true;
    q.push(s);
    while (!q.empty()){
        int u = q.front();
        q.pop();
        vis[u] = false;
        for (int i = head[u]; i != -1; i = edge[i].next){
            int v = edge[i].to;

            if (edge[i].cap > edge[i].flow && dis[v] > dis[u] + edge[i].cost){
                dis[v] = dis[u] + edge[i].cost;
                pre[v] = i;
                if (!vis[v]){
                    vis[v] = true;
                    q.push(v);
                }
            }
        }
    }
    if (pre[t] == -1) return false;
    else  return true;
}

int minCostMaxflow(int s, int t, int &cost){
    int flow = 0;
    cost = 0;
    while (spfa(s, t)){
        int Min = INF;
        for (int i = pre[t]; i != -1; i = pre[edge[i ^ 1].to]){
            if (Min > edge[i].cap - edge[i].flow)
                Min = edge[i].cap - edge[i].flow;
        }
        for (int i = pre[t]; i != -1; i = pre[edge[i ^ 1].to]){
            edge[i].flow += Min;
            edge[i ^ 1].flow -= Min;
            cost += edge[i].cost * Min;
        }
        flow += Min;
    }
    return flow;
}

map<int,int> dp;
struct edg{
    int u,v,w;
}ed[MAXN];

int main()
{
    #ifndef ONLINE_JUDGE
        freopen("in.txt","r",stdin);
        freopen("out.txt","w",stdout);
    #endif
    int T,N,M,K,u,v,w;
    scanf("%d",&T);
    map<int,int> ::iterator it;
    while(T--){
        dp.clear();
        scanf("%d %d %d",&N, &K, &M);
        for(int i=1;i<=M;++i){
            scanf("%d %d %d",&u,&v,&w);
            v++;
            ed[i] = (edg){u,v,w};
            dp[u] = dp[v] = 1;
        }
        int cnt=0;
        for(it = dp.begin();it!=dp.end();++it){
            int id = it->first;
            dp[id] =  ++cnt;
        }
        init(cnt+5);
        int s = 0,t = cnt+1;
        addedge(s,1,K,0);
        addedge(cnt,t,K,0);
        for(int i=1;i<cnt;++i){
            addedge(i,i+1,INF,0);
        }
        for(int i=1;i<=M;++i){
            u = ed[i].u, v = ed[i].v;
            u = dp[u], v =dp[v];
            addedge(u,v,1,-ed[i].w);
        }
        int cost;
        minCostMaxflow(s,t,cost);
        printf("%d
",-cost);
    }
    return 0;
}