HDU 2883 kebab(最大流)

【题意】

有一个烤肉机，每次可以同时烤M份肉。有N个顾客，第i个顾客li时刻到达，ri时刻走， 点了ai份肉，每份肉需要bi的时间烤，客人的每份肉可以分开烤，比如一份肉需要t时间烤，如果平均分出t份，那么能在1个时间内烤完。问能否满足所有顾客的需求。

【分析】

烤肉机相当于每个单位时间段都在工作，可以一直往里面加肉，每个单位时间段最多可以容下M份肉。对于每个客人，其需求需要在(li,ri)的区间内 完成，因为烤肉可以分开烤，则只需考虑单位份烤肉所需时间然后累加，即只用考虑ai*bi <=(ri - li)*M，如果满足，那么这个顾客是可以满足的。显然，问题转化为区间覆盖问题。

线段上每个单位线段的容量为M，每个顾客的区间为(li,ri)，其顾客容量为ai*bi。求能否覆盖完

【建图】

由以上分析，可以由源点到每个顾客i连边，容量为ai*bi；由每个单位时间段向汇点连边，容量为M；每个顾客i对每个时间段j连边，容量为INF.跑最大流判定即可。但是时间点有100W个，不可行。

【离散化】把时间点离散化成很多个区间，最多2*N-1 个区间。每个区间j，向汇点连边（ri - li）*M。每个顾客i向每个区间j连边，如果顾客的时间段覆盖了区间，容量为INF.

【Mark】注意建图一共有600+点，这里导致WA 2发。

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<algorithm>

using namespace std;

#define INF 1e8
#define MAX_VECT 605
#define MAX_EDGE 2200000

/************************************************************************/

/*    Name: dinic
/*  Description: Find the max flow of the network from start to
                 end point
/*  Variable Description: to[] - end point of the current edge
                          next[] - the next edge which also comes from
                                   the same point as current edge
                          cap[] - the capability of the current edge
                          v[] - the first edge index which comes from the
                                the current point
                          d[] - the layer number of current point
/************************************************************************/


int to[MAX_EDGE], next[MAX_EDGE], cap[MAX_EDGE], tot;
int v[MAX_VECT], d[MAX_VECT], queue[MAX_VECT], n;
int S, T;
inline void single_insert(int _u, int _v, int var)
{
    to[tot] = _v;
    cap[tot] = var;
    next[tot] = v[_u];
    v[_u] = tot++;
}

void insert(int from, int to,  int cap)
{
    single_insert(from, to, cap);
    single_insert(to, from, 0);
}

bool bfs_initial()
{
    memset(d, -1, sizeof(d));
    int bg, ed, x, y;
    bg = ed = d[S] = 0;
    queue[ed++] = S;
    while (bg < ed)
    {
        x = queue[bg++];
        for (int i = v[x]; i+1; i = next[i])
        {
            y = to[i];
            if (cap[i] && d[y] == -1)
            {
                d[y] = d[x] + 1;
                if (y == T) return true;
                queue[ed++] = y;
            }
        }
    }
    return false;
}

int Find(int x, int low = INF)
{
    if (x == T) return low;
    int ret, y, ans = 0;
    for (int i = v[x]; (i+1) && low; i = next[i])
    {
        y = to[i];
        if (cap[i] && d[y] == d[x] + 1 && (ret = Find(y, min(low, cap[i]))))
        {
            cap[i] -= ret;
            cap[i^1] += ret;
            low -= ret;
            ans += ret;
        }
    }
    return ans;
}
int dinic()
{
    int ans = 0;
    while (bfs_initial())
        ans += Find(S);
    return ans;
}


int dinicc()
{
    int ans = 0;
    while(bfs_initial())
    {
        int edge, x, y, back, iter = 1;
        while(iter)
        {
            x = (iter == 1) ? S : to[queue[iter - 1]];
            if (x == T)
            {
                int minE, minCap = INF;
                for (int i = 1; i < iter; i++)
                {
                    edge = queue[i];
                    if (cap[edge] < minCap)
                    {
                        minCap = cap[edge];
                        back = i;
                    }
                }
                for (int i = 1; i < iter; i++)
                {
                    edge = queue[i];
                    cap[edge] -= minCap;
                    cap[edge ^ 1] += minCap;
                }
                ans += minCap;
                iter = back;
            }
            else
            {
                for (edge = v[x]; edge + 1; edge = next[edge])
                {
                    y = to[edge];
                    if (cap[edge] && d[y] == d[x] + 1)
                        break;
                }
                if (edge+1)
                    queue[iter++] = edge;
                else
                {
                    d[x] = -1;
                    iter--;
                }
            }
        }
    }
    return ans;
}
int m;
struct time{
    int l,r;
    int a,b;
}seq[MAX_VECT];
int ttt[MAX_VECT*2];
int cnt = 0;

int check(int L,int R,int l,int r)
{
    return (L<=l && r<=R);
}
int main()
{
    while (scanf("%d%d",&n,&m)==2)
    {
        tot = 0;
        memset(v,-1,sizeof(v));
        cnt = 0;
        for (int i=1;i<=n;i++)
        {
            scanf("%d%d%d%d",&seq[i].l,&seq[i].a,&seq[i].r,&seq[i].b);
            ttt[++cnt] = seq[i].l;
            ttt[++cnt] = seq[i].r;
        }
        sort(ttt+1,ttt+1+cnt);

        S = 0;
        T = n + cnt;
        int sum = 0;
        for (int i=1;i<=n;i++)
        {
            insert(S,i,seq[i].a*seq[i].b);
            sum += seq[i].a * seq[i].b;
        }
        for (int i=1;i<cnt;i++)
        {
            insert(n+i,T,(ttt[i+1] - ttt[i])*m);
        }
        for (int i=1;i<=n;i++)
            for (int j=1;j<cnt;j++)
            {
                if (check(seq[i].l, seq[i].r, ttt[j],ttt[j+1]))
                {
                    insert(i,n+j,INF);
                }
            }

        n = n + cnt;

        int ans = dinic();
        if (ans == sum)
            printf("Yes\n");
        else
            printf("No\n");
    }
    return 0;
}

 

 

/****

Author:wangsouc

****/