BZOJ-1061 志愿者招募 线性规划转最小费用最大流+数学模型 建模

本来一眼建模,以为傻逼题,然后发现自己傻逼...根本没想到神奇的数学模型.....

1061: [Noi2008]志愿者招募
Time Limit: 20 Sec Memory Limit: 162 MB
Submit: 3014 Solved: 1864
[Submit][Status][Discuss]

Description
申奥成功后，布布经过不懈努力，终于成为奥组委下属公司人力资源部门的主管。布布刚上任就遇到了一个难题：为即将启动的奥运新项目招募一批短期志愿者。经过估算，这个项目需要N 天才能完成，其中第i 天至少需要Ai 个人。 布布通过了解得知，一共有M 类志愿者可以招募。其中第i 类可以从第Si 天工作到第Ti 天，招募费用是每人Ci 元。新官上任三把火，为了出色地完成自己的工作，布布希望用尽量少的费用招募足够的志愿者，但这并不是他的特长！于是布布找到了你，希望你帮他设计一种最优的招募方案。

Input
第一行包含两个整数N, M，表示完成项目的天数和可以招募的志愿者的种类。 接下来的一行中包含N 个非负整数，表示每天至少需要的志愿者人数。 接下来的M 行中每行包含三个整数Si, Ti, Ci，含义如上文所述。为了方便起见，我们可以认为每类志愿者的数量都是无限多的。

Output
仅包含一个整数，表示你所设计的最优方案的总费用。

Sample Input
3 3
2 3 4
1 2 2
2 3 5
3 3 2

Sample Output
14

HINT
招募第一类志愿者3名，第三类志愿者4名 30%的数据中，1 ≤ N, M ≤ 10，1 ≤ Ai ≤ 10； 100%的数据中，1 ≤ N ≤ 1000，1 ≤ M ≤ 10000，题目中其他所涉及的数据均 不超过2^31-1。

Source

关于此题一些趣事:




好吧…下面是建模:

这道题正确的解法是构造网络，求网络最小费用最大流，但是模型隐藏得较深，不易想到。构造网络是该题的关键，以下面一个例子说明构图的方法和解释。

例如一共需要4天，四天需要的人数依次是4,2,5,3。有5类志愿者，如下表所示：

种类 1 2 3 4 5
时间 1-2 1-1 2-3 3-3 3-4
费用 3 4 3 5 6
设雇佣第i类志愿者的人数为X[i]，每个志愿者的费用为V[i]，第j天雇佣的人数为P[j]，则每天的雇佣人数应满足一个不等式，如上表所述，可以列出

P[1] = X[1] + X[2] >= 4
P[2] = X[1] + X[3] >= 2
P[3] = X[3] + X[4] +X[5] >= 5
P[4] = X[5] >= 3

对于第i个不等式，添加辅助变量Y[i] (Y[i]>=0) ，可以使其变为等式

P[1] = X[1] + X[2] - Y[1] = 4
P[2] = X[1] + X[3] - Y[2] = 2
P[3] = X[3] + X[4] +X[5] - Y[3] = 5
P[4] = X[5] - Y[4] = 3

在上述四个等式上下添加P[0]=0,P[5]=0，每次用下边的式子减去上边的式子，得出

① P[1] - P[0] = X[1] + X[2] - Y[1] = 4
② P[2] - P[1] = X[3] - X[2] -Y[2] +Y[1] = -2
③ P[3] - P[2] = X[4] + X[5] - X[1] - Y[3] + Y[2] =3
④ P[4] - P[3] = - X[3] - X[4] + Y[3] - Y[4] = -2
⑤ P[5] - P[4] = - X[5] + Y[4] = -3

观察发现，每个变量都在两个式子中出现了，而且一次为正，一次为负。所有等式右边和为0。接下来，根据上面五个等式构图。

每个等式为图中一个顶点，添加源点S和汇点T。
如果一个等式右边为非负整数c，从源点S向该等式对应的顶点连接一条容量为c，权值为0的有向边；如果一个等式右边为负整数c，从该等式对应的顶点向汇点T连接一条容量为c，权值为0的有向边。
如果一个变量X[i]在第j个等式中出现为X[i]，在第k个等式中出现为-X[i]，从顶点j向顶点k连接一条容量为∞，权值为V[i]的有向边。
如果一个变量Y[i]在第j个等式中出现为Y[i]，在第k个等式中出现为-Y[i]，从顶点j向顶点k连接一条容量为∞，权值为0的有向边。
构图以后，求从源点S到汇点T的最小费用最大流，费用值就是结果。

根据上面的例子可以构造出如下网络，红色的边为每个变量X代表的边，蓝色的边为每个变量Y代表的边，边的容量和权值标已经标出(蓝色没有标记，因为都是容量∞，权值0)。

在这个图中求最小费用最大流，流量网络如下图，每个红色边的流量就是对应的变量X的值。

所以，答案为43+23+3*6=36。
上面的方法很神奇得求出了结果，思考为什么这样构图。我们将最后的五个等式进一步变形，得出以下结果

① - X[1] - X[2] + Y[1] + 4 = 0
② - X[3] + X[2] + Y[2] - Y[1] - 2 = 0
③ - X[4] - X[5] + X[1] + Y[3] - Y[2] + 3 = 0
④ X[3] + X[4] - Y[3] + Y[4] - 2 = 0
⑤ X[5] - Y[4] - 3 = 0

可以发现，每个等式左边都是几个变量和一个常数相加减，右边都为0，恰好就像网络流中除了源点和汇点的顶点都满足流量平衡。每个正的变量相当于流入该顶点的流量，负的变量相当于流出该顶点的流量，而正常数可以看作来自附加源点的流量，负的常数是流向附加汇点的流量。因此可以据此构造网络，求出从附加源到附加汇的网络最大流，即可满足所有等式。而我们还要求最小，所以要在X变量相对应的边上加上权值，然后求最小费用最大流。
(建模转自Beyond the Void,orz)

My code:

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x*=10;x+=ch-'0';ch=getchar();}
    return x*f;
}
#define inf 0x7fffffff
int n,m;
struct data{int to,next,cap,cost;}edge[50010];
int head[10005],cnt=1; 
int ans=0;
int S,T;
bool visit[10005];
int dis[10005];
int q[10005],h,t;
bool mark[10005];

void add(int u,int v,int w,int c)
{
    cnt++;
    edge[cnt].next=head[u]; head[u]=cnt;
    edge[cnt].to=v; edge[cnt].cost=c; edge[cnt].cap=w;
}
void insert(int u,int v,int w,int c)
{
    add(u,v,w,c);add(v,u,0,-c);
}

bool spfa()
{
    memset(visit,0,sizeof(visit));
    for (int i=S; i<=T; i++) dis[i]=inf;
    h=0,t=1;
    q[0]=T;dis[T]=0;visit[T]=1;
    while (h<t)
        {
            int now=q[h];h++;
            for (int i=head[now]; i; i=edge[i].next)
                if (edge[i^1].cap && dis[now]-edge[i].cost<dis[edge[i].to])
                    {
                        dis[edge[i].to]=dis[now]-edge[i].cost;
                        if (!visit[edge[i].to])
                            {
                                q[t++]=edge[i].to;
                                visit[edge[i].to]=1;
                            }
                    }
            visit[now]=0;
        }
    return dis[S]!=inf;
}

int dfs(int loc,int low)
{
    mark[loc]=1;
    if (loc==T) return low;
    int w,used=0;
    for (int i=head[loc]; i; i=edge[i].next)
        if (edge[i].cap && !mark[edge[i].to] && dis[edge[i].to]==dis[loc]-edge[i].cost)
            {
                w=dfs(edge[i].to,min(low-used,edge[i].cap));
                ans+=w*edge[i].cost;
                used+=w;
                edge[i].cap-=w;edge[i^1].cap+=w;
                if (used==low) return low;
            }
    return used;
}

void zkw()
{
    int tmp=0;
    while (spfa())
        {
            mark[T]=1;
            while (mark[T])
                {
                    memset(mark,0,sizeof(mark));
                    tmp+=dfs(S,inf);
                }
        }
}

void make()
{
    n=read();m=read();
    S=0,T=1005;
    int l=0,r;
    for (int i=1; i<=n; i++)
        {
            r=read();
            int x=r-l;
            if (x>0) insert(S,i,x,0);
                else insert(i,T,-x,0);
            insert(i+1,i,inf,0);
            l=r;
        }
    insert(n+1,T,l,0);
    for (int i=1; i<=m; i++)
        {
            int x=read(),y=read(),c=read();
            insert(x,y+1,inf,c);
        }
}

int main()
{
    make();
    zkw();
    printf("%d\n",ans);
    return 0;
}