HDU 6437 Problem L.Videos（最小费用最大流-mcmf）

Description

有$K$个人看$m$个电影，给出每个电影的开始时间$s$和结束时间$e$以及看这个电影收获的快乐值$w$，只有看完一个电影才能去看另一个尚未开始的电影，且一个电影至多一人看，电影分两种，如果一个人连续看两个同种电影则会损失$W$快乐值，问这些人的快乐值之和最大值

Input

第一行一整数$T$表示用例组数，每组用例首先输入四个整数$n,m,K,W$表示一天的小时数、电影数量、人数和连续看两个同种电影损失的快乐值，之后$m$行每行四个整数$s,e,w,op$表示电影的开始时间、结束时间、带来的快乐值以及类型

$(1\le T\le 20,1\le n,m,K\le 200,W\le 20,1\le S<T\le n,W\le w\le 1000,op\in \{0,1\})$

Output

输出这些人快乐值的最大值

Sample Input

2
10 3 1 10
1 5 1000 0
5 10 1000 1
3 9 10 0
10 3 1 10
1 5 1000 0
5 10 1000 0
3 9 10 0

Sample Output

2000
1990

Solution

由于不是每个人都要看电影，首先安排一种可以无限人看且对快乐值没有影响的电影类对付不看电影的人，对个电影拆点来限制一个电影只能被看一次，把一个人看的电影序列看作一个流量，快乐值体现在入边的费用上，对于同类电影，把损失快乐值放入两点之间连边的费用上，那么该问题等价于求该网络满流下的最大费用，把费用取负即为费用流

Code

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int INF=0x3f3f3f3f,maxn=500,maxm=100005;
int head[maxn],d[maxn],s,e,no,vis[maxn],pre[maxn];//s为源点,e为汇点 
struct point
{
    int u,v,flow,next,cost;
    point(){};
    point(int _u,int _v,int _next,int _flow,int _cost)
    {
        u=_u,v=_v,next=_next,flow=_flow,cost=_cost;
    } 
}p[maxm];
void add(int x,int y,int z,int c)//从x到y建一条容量为z,花费为c的边 
{
    p[no]=point(x,y,head[x],z,c);   
    head[x]=no++;
    p[no]=point(y,x,head[y],0,-c);  
    head[y]=no++;
}
void init()//初始化 
{
    memset(head,-1,sizeof(head));
    no=0;
}
bool spfa()
{
    int i,x,y;
    queue<int>q;
    memset(d,0x3f,sizeof(d));
    memset(vis,false,sizeof(vis));
    memset(pre,-1,sizeof(pre));
    d[s]=0;   
    vis[s]=true;  
    q.push(s);
    while(!q.empty())
    {
        x=q.front();  
        q.pop();    
        vis[x]=false;
        for(i=head[x];i!=-1;i=p[i].next)
        {
            if(p[i].flow&&d[y=p[i].v]>d[x]+p[i].cost)
            {
                d[y]=d[x]+p[i].cost;   
                pre[y]=i;
                if(vis[y])  
                    continue;
                vis[y]=true;  
                q.push(y);
            }  
        }  
    }
    return d[e]!=d[e+1];
}
int mcmf()//最小费用最大流 
{
    int mincost=0,maxflow=0,minflow,i;
    while(spfa())
    {
        //if(d[e]>=0)break;//可行流 
        minflow=INF;
        for(i=pre[e];i!=-1;i=pre[p[i].u])
            minflow=min(minflow,p[i].flow);
        for(i=pre[e];i!=-1;i=pre[p[i].u])
        {
            p[i].flow-=minflow;
            p[i^1].flow+=minflow;
        }
        mincost+=d[e]*minflow; 
        maxflow+=minflow;
    }
    return mincost;//最小费用,最大流为maxflow 
}
struct node
{
    int L,R,w,op;
}a[maxn];
int T,n,m,K,W;
int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d%d",&n,&m,&K,&W);
        for(int i=1;i<=m;i++)scanf("%d%d%d%d",&a[i].L,&a[i].R,&a[i].w,&a[i].op);
        init();
        s=0,e=2*m+4;
        add(s,2*m+1,K,0);
        add(2*m+2,e,K,0);
        add(2*m+1,2*m+3,INF,0);
        add(2*m+3,2*m+2,INF,0);
        for(int i=1;i<=m;i++)
        {
            add(2*m+1,i+m,1,-a[i].w);
            add(i+m,i,1,0);
            add(i,2*m+2,1,0);
        }
        for(int i=1;i<=m;i++)
            for(int j=1;j<=m;j++)
                if(i!=j&&a[i].R<=a[j].L)
                {
                    if(a[i].op!=a[j].op)add(i,j+m,1,-a[j].w);
                    else add(i,j+m,1,W-a[j].w);
                }
        printf("%d\n",-mcmf());
    }
    return 0;
}