HYSBZ 1061,线性规划转最小费用流

志愿者招募

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

思路1：最小费用流
设第i类人招募了xi个，aij表示第i个人第j天是否工作，工作为1，不工作为0，则应满足对于所有j， $\sum_i^na_{ij}x_i >= A_j$，需要最小化 $z=\sum_1^nC_ix_i$，对于第j天的不等式 $\sum_i^na_{ij}x_i >= A_j$在左侧减去一个p[j]得到 $\sum_i^na_{ij}x_i -p[j]= A_j$，对于将任意两个相邻的等式相减可以得到n+1个等式，并且 $x_i$将在第l[i]个等式处取正，在r[i]+1号等式处取负，p[j]将在第j+1个等式处取正，在第j个等式处取负，故对于第i个人，连一条(l[i],r[i],INF,c[i])的边，对于相邻的两个等式连一条(i-1,i,INF,0)的边，最后根据 $A_j-A_{j-1}$的正负来决定源点和汇点的边，然后跑最小费用最大流即可

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#define MAXN 10010
#define MAXM 40010
using namespace std;
const int INF = 0x3f3f3f3f;
int tot,head[MAXN],cnt;
struct edge
{
    int u,v,c,w,nxt;
}edg[MAXM<<1];
inline void addedg(int u,int v,int c,int w)
{
    edg[tot].u = u;
    edg[tot].v = v;
    edg[tot].c = c;
    edg[tot].w = w;
    edg[tot].nxt = head[u];
    head[u] = tot++;
}
inline void add(int u,int v,int c,int w)
{
    addedg(u,v,c,w);
    addedg(v,u,0,-w);
}
int vis[MAXN],d[MAXN],pre[MAXN],path[MAXN],cost;
//d用来存最短路,pre用来存路径,path用来存用了哪条边,cost用来保存最小费用
inline bool SPFA(int st,int ed)
{
    memset(d,0x3f,sizeof(int)*(cnt+3));
    memset(pre,-1,sizeof(int)*(cnt+3));
    memset(path,-1,sizeof(int)*(cnt+3));
    memset(vis,0,sizeof(int)*(cnt+3));
    queue<int> qu;
    d[st] = 0;
    vis[st] = 1;
    qu.push(st);
    while(!qu.empty())
    {
        int u = qu.front();
        qu.pop();
        vis[u] = 0;
        for(int i = head[u];i != -1;i = edg[i].nxt)
        {
            int v = edg[i].v;
            if(d[u] + edg[i].w < d[v] && edg[i].c > 0)
            {
                d[v] = d[u] + edg[i].w;
                pre[v] = u;
                path[v] = i;
                if(!vis[v])
                {
                    vis[v] = 1;
                    qu.push(v);
                }
            }
        }
    }
    return pre[ed] != -1;
}
inline int minCostMaxFlow(int st,int ed)
{
    int flow = 0;
    while(SPFA(st,ed))
    {
        int minn = INF;
        for(int i = ed;i != st;i = pre[i])
            minn = min(minn,edg[path[i]].c);//求出新增加的流量
        for(int i = ed;i != st;i = pre[i])
        {
            edg[path[i]].c -= minn;
            edg[path[i]^1].c += minn;
        }
//        if(d[ed] >= 0) //保证费用最小，去掉后保证流量最大
//            break;
        flow += minn;
        cost += minn * d[ed];
    }
    return flow;
}
inline void init()
{
    tot = cost = 0;
    memset(head,-1,sizeof(int)*(cnt+3));
}
struct node
{
    int l,r,w;
}nod[MAXN];
int n,m,a[MAXN];
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        int s = 0,t = n+2;
        cnt = n+1;
        init();
        for(int i = 2;i <= n+1;++i)
            add(i,i-1,INF,0);
        int l,r,p;
        for(int i = 1;i <= n;++i)
            scanf("%d",&a[i]);

        for(int i = 1;i <= m;++i)
        {
            scanf("%d%d%d",&l,&r,&p);
            add(l,r+1,INF,p);
        }

        a[0] = a[n+1] = 0;
        for(int i = 1;i <= n+1;++i)
        {
            int x = a[i] - a[i-1];
            if(x > 0)
                add(s,i,x,0);
            if(x < 0)
                add(i,t,-x,0);
        }

        minCostMaxFlow(s,t);
        printf("%d\n",cost);
    }
    return 0;
}

思路2：单纯形
https://blog.csdn.net/xing_mo/article/details/103980501