2018 acm-icpc焦作网络赛 F（费用流+区间离散化）

这道题和poj3680很相似，不过这道题每个点只能重复一次。但我们可以将右端点加一，这样就可以建图了。

区间离散时加了一段代码，导致T了10多次，后来发现这段代码不加也可以，因为，离散化之后保证相对不相交就可以。。。

#include
#include
#include
#include
#include
using namespace std;
#define inf 0x3f3f3f3f
int head[1100];
int dis[1100];
int pre[1100];
int vis[1100];
int num[1100];
int tot;
struct Edge
{
    int cost;
    int flow;
    int to;
    int next;
} edge[20050];
bool spfa(int s,int t)
{
   memset(dis,inf,sizeof(dis));
    memset(pre,-1,sizeof(pre));
    memset(vis,0,sizeof(vis));
    queueQ;
    Q.push(s);
    dis[s]=0;
    vis[s]=1;
    int top;
    while(!Q.empty())
    {
        top=Q.front();
        Q.pop();
        vis[top]=0;
        for(int i=head[top]; i!=-1; i=edge[i].next)
        {//cout<0&&dis[edge[i].to]>dis[top]+edge[i].cost)
            {
                dis[edge[i].to]=dis[top]+edge[i].cost;
                pre[edge[i].to]=i;
                if(!vis[edge[i].to])
                {
                    vis[edge[i].to]=1;
                    Q.push(edge[i].to);
                }
            }
        }
    }
    if(pre[t]!=-1)return true;
    return false;
}
struct Node
{
    int l;
    int r;
    int w;
} node[500];
void addedge(int u,int v,int w,int f)
{
    edge[tot].to=v;
    edge[tot].cost=w;
    edge[tot].flow=f;
    edge[tot].next=head[u];
    head[u]=tot++;
    edge[tot].to=u;
    edge[tot].cost=0-w;
    edge[tot].flow=0;
    edge[tot].next=head[v];
    head[v]=tot++;
}
int MinCostMaxFlow(int s,int t)
{
    int minl;
    int res=0,sum;
    while(spfa(s,t))
    {

        minl=inf;
        sum=0;
        for(int i=pre[t]; i!=-1; i=pre[edge[i^1].to])
        {
            minl=min(minl,edge[i].flow);
        }
        for(int i=pre[t]; i!=-1; i=pre[edge[i^1].to])
        {
            edge[i].flow-=minl;
            edge[i^1].flow+=minl;
            sum+=minl*edge[i].cost;
        }
        res+=sum;
    }
    return res;

}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        tot=0;
        memset(head,-1,sizeof(head));
        int n,k,m,ans=0;
        scanf("%d%d%d",&n,&k,&m);
        for(int i=1; i<=m; i++)
        {
            scanf("%d%d%d",&node[i].l,&node[i].r,&node[i].w);
            num[++ans]=node[i].l;
            num[++ans]=node[i].r;
        }
        sort(num+1,num+ans+1);
        int t=unique(num+1,num+ans+1)-(num+1);
//        int tt=t;
//        for(int i=2; i<=tt; i++)
//        {
//            if(num[i]-num[i-1]>1)
//            {
//                num[++t]=num[i]+1;
//            }
//        }
//        sort(num+1,num+t+1);
        for(int i=1; i<=t; i++)
        {
            addedge(i,i+1,0,inf);
        }
        for(int i=1; i<=m; i++)
        {
            node[i].l=upper_bound(num+1,num+t+1,node[i].l)-(num+1);
            node[i].r=upper_bound(num+1,num+t+1,node[i].r)-(num+1);
            addedge(node[i].l,node[i].r+1,0-node[i].w,1);
        }
        addedge(0,1,0,k);
        int st=0,ed=t+1;
        printf("%d\n",0-MinCostMaxFlow(st,ed));

    }
}