poj 3680 用网络流解决（K次区间覆盖问题）

#include<cstdio>

 #include<cstring>

 #include<queue>

 #include<iostream>

 #include<cmath>

 using namespace std;

 #define INFINITE 1 << 26

#define MAX_NODE 1005

#define MAX_EDGE_NUM 40005

struct Edge{

    int to;

    int vol;

    int cost;

    int next;

};

Edge gEdges[MAX_EDGE_NUM];

int gHead[MAX_NODE];

int gPre[MAX_NODE];

int gPath[MAX_NODE];

int gDist[MAX_NODE];

int gEdgeCount;

void InsertEdge(int u, int v, int vol, int cost){

    gEdges[gEdgeCount].to = v;

    gEdges[gEdgeCount].vol = vol;

    gEdges[gEdgeCount].cost = cost;

    gEdges[gEdgeCount].next = gHead[u];

    gHead[u] = gEdgeCount++;

    gEdges[gEdgeCount].to = u;

    gEdges[gEdgeCount].vol = 0;         //vol为0，表示开始时候，该边的反向不通

    gEdges[gEdgeCount].cost = -cost;    //cost 为正向边的cost相反数，这是为了

    gEdges[gEdgeCount].next = gHead[v];

    gHead[v] = gEdgeCount++;

}

//假设图中不存在负权和环,SPFA算法找到最短路径/从源点s到终点t所经过边的cost之和最小的路径

bool Spfa(int s, int t){

    memset(gPre, -1, sizeof(gPre));

    memset(gDist, 0x7F, sizeof(gDist));

    gDist[s] = 0;

    queue<int> Q;

    Q.push(s);

    while (!Q.empty()){//由于不存在负权和环，因此一定会结束

        int u = Q.front();

        Q.pop();

        for (int e = gHead[u]; e != -1; e = gEdges[e].next){

            int v = gEdges[e].to;

            if (gEdges[e].vol > 0 && gDist[u] + gEdges[e].cost < gDist[v]){

                gDist[v] = gDist[u] + gEdges[e].cost;

                gPre[v] = u; //前一个点

                gPath[v] = e;//该点连接的前一个边

                Q.push(v);

            }

        }

    }

    if (gPre[t] == -1)  //若终点t没有设置pre，说明不存在到达终点t的路径

        return false;

    return true;

}

int MinCostFlow(int s, int t){

    int cost = 0;

    int flow = 0;

    while (Spfa(s, t)){

        int f = INFINITE;

        for (int u = t; u != s; u = gPre[u]){

            if (gEdges[gPath[u]].vol < f)

                f = gEdges[gPath[u]].vol;

        }

        flow += f;

        cost += gDist[t] * f;

        for (int u = t; u != s; u = gPre[u]){

            gEdges[gPath[u]].vol -= f;   //正向边容量减少

            gEdges[gPath[u]^1].vol += f; //反向边容量增加

        }

    }

    return cost;

}

int main()

{

    int n,k;

    cin>>n>>k;

    gEdgeCount=0;

    memset(gEdges,-1,sizeof(gEdges));

    for(int i=0;i<n;i++)

    {

        int aa,bb,cc;

        cin>>aa>>bb>>cc;

        InsertEdge(aa,bb,1,-cc);

    }

    for(int i=1;i<55;i++)

    {

        InsertEdge(i,i+1,k,0);

    }

    int ss=56;

    int tt=56;

    InsertEdge(ss,1,k,0);

    InsertEdge(55,tt,k,0);

    cout<<-MinCostFlow(ss,tt)<<endl;

}