[NOI2008] 志愿者招募（线性规划-对偶问题-费用流）

ikrvxt

于 2022-03-06 15:46:56 发布

阅读量536

点赞数 1

分类专栏： # 网络流

本文链接：https://blog.csdn.net/Emm_Titan/article/details/123311490

版权

网络流最长可重区间集志愿者调度最小费用最大流 SPFA算法

关键词由CSDN通过智能技术生成

网络流专栏收录该内容

24 篇文章 1 订阅

订阅专栏

problem

luogu-P3980

solution

志愿者连续工作 $s_i,t_i]$ 天，我们可以提炼出网络流二十四题中《最长k可重区间集问题》的模型。

同样地，把 $1\sim n$ 天抽象成一条 $1\sim n+1$ 个点的链条。

源点 $s\rightarrow 1$ 容量无穷费用零， $n+1\rightarrow t$ 汇点容量无穷费用零。
然后 $i\rightarrow i+1$ 容量 $\infty-a_i$ 费用零。
对于第 $i$ 种志愿者， $s_i\rightarrow t_i+1$ 容量无穷费用 $c_i$ 。

最后跑最小费用最大流即为答案。

如果无法直接理解这样建图的正确性，可以考虑把网络图中的流量流起来。

如果从 $s$ 沿着费用零的边向 $t$ 流，由于链条上的边流量为 $\infty-a_i$ ，所以先前 $\infty$ 的不能流完。

那么势必要通过有志愿者（花费）的边流。

假设流到了点 $i$ ，那么剩下不能流过 $(i, i + 1)$ 的流量我们得从 $i$ 连出去的志愿者边流，并且流一个就要花费 $c_i$ 的代价。

然后在点 $x + 1$ 的时候这些流量又会汇合。

这就相当于招募了从 $i$ 开始到 $x$ 结束的志愿者。（当然可能有多个 $x$ 结束点）

反正到最后 $t$ 的时候，流量总和一定会汇聚成从 $s$ 开始流的 $\infty$ 。

你可以理解一队人去闯密室逃脱，在一定关卡要进行多人支线任务，需要大部队派一些人去完成，然后主线队继续往下走主线任务，到了一定关卡有些人完成了自己的支线任务可以归队了。最后通关的时候，一定是大家都从主线任务关卡口出来。

code

#include <bits/stdc++.h>
using namespace std;
#define maxn 2000
#define maxm 50000
#define int long long
#define inf 0x3f3f3f3f
struct node { int to, nxt, flow, cost; }E[maxm];
int head[maxn], dis[maxn], lst[maxn], vis[maxn], a[maxn];
int cnt = -1, n, m, s, t;
queue < int > q;

void addedge( int u, int v, int w, int c ) {
    E[++ cnt] = { v, head[u], w, c }; head[u] = cnt;
    E[++ cnt] = { u, head[v], 0,-c }, head[v] = cnt;
}

bool SPFA() {
    memset( lst, -1, sizeof( lst ) );
    memset( dis, 0x3f, sizeof( dis ) );
    q.push( dis[s] = 0 );
    while( ! q.empty() ) {
        int u = q.front(); q.pop(); vis[u] = 0;
        for( int i = head[u];~ i;i = E[i].nxt ) {
            int v = E[i].to;
            if( dis[v] > dis[u] + E[i].cost and E[i].flow ) {
                dis[v] = dis[u] + E[i].cost; lst[v] = i;
                if( ! vis[v] ) vis[v] = 1, q.push( v );
            }
        }
    }
    return ~ lst[t];
}

int MCMF() {
    int ans = 0;
    while( SPFA() ) {
        int flow = inf;
        for( int i = lst[t];~ i;i = lst[E[i ^ 1].to] )
            flow = min( flow, E[i].flow );
        for( int i = lst[t];~ i;i = lst[E[i ^ 1].to] ) {
            E[i ^ 1].flow += flow;
            E[i].flow -= flow;
            ans += flow * E[i].cost;
        }
    }
    return ans;
}

signed main() {
    memset( head, -1, sizeof( head ) );
    scanf( "%lld %lld", &n, &m );
    s = 0, t = n + 2;
    for( int i = 1;i <= n;i ++ ) scanf( "%lld", &a[i] );
    for( int i = 1;i <= n;i ++ ) addedge( i, i + 1, inf - a[i], 0 );
    addedge( s, 1, inf, 0 );
    addedge( n + 1, t, inf, 0 );
    for( int i = 1, u, v, w;i <= m;i ++ ) {
        scanf( "%lld %lld %lld", &u, &v, &w );
        addedge( u, v + 1, inf, w );
    }
    printf( "%lld\n", MCMF() );
    return 0;
}

solution(流量平衡)

假设共 $3$ 天，第 $i$ 天招募 $p_i$ 人。

共有三类志愿者：

从第 $1$ 天工作到第 $3$ 天，费用为 $c_1$ ，招募了 $b_1$ 人。
从第 $2$ 天工作到第 $3$ 天，费用为 $c_2$ ，招募了 $b_2$ 人。
从第 $1$ 天工作到第 $2$ 天，费用为 $c_3$ ，招募了 $b_3$ 人。

则有以下不等式：
$\begin{cases} b_1+b_3\ge a_1\\b_1+b_2+b_3\ge a_2\\b_1+b_2\ge a_3 \end{cases}$
记第 $i$ 天招募的志愿者超出最少要求人数 $d_i$ 人，显然 $d_i\ge 0$ 。则可改写成以下等式：
$\begin{cases}p_1=b_1+b_3=a_1+d_1\\p_2=b_1+b_2+b_3=a_2+d_2\\p_3=b_1+b_2=a_3+d_3\end{cases}$
将相邻两两等式作差后移项整理得：
$\begin{cases}p_1=b_1+b_3=a_1+d_1\\p_2-p_1=b_2-b_3=a_2-a_1+d_2-d_1\\ p_3-p_2=-b_3=a_3-a_2+d_3-d_2\\-p_3=-b_1-b_2=-a_3-d_3\end{cases}\Rightarrow \begin{cases}p_1-p_0=b_1+b_3-a_1-d_1=0\\p_2-p_1=b_2-b_3-a_2+a_1-d_2+d_1=0\\ p_3-p_2=-b_3-a_3+a_2-d_3+d_2=0\\p_4-p_3=-b_1-b_2+a_3+d_3=0 \end{cases}$
网络流中除了源汇点，其余点都应满足流量平衡，即流入流量等于流出流量；若将流入记为正，流出记为负，则应满足流入流出流量的代数和为 $0$ 。

网络图中一条连接 $x, y$ 的边，在 $x, y$ 的流量平衡等式中各出现一次，且一次为正一次为负。

所以我们可以对上面最后化出的等式每个建立一个点，这个等式表示的就是这个点流量平衡。

再观察最后的等式：

$\text{observationⅠ.}$ $b_i,d_i$ 都在恰好两个等式出现，且是一正一负。所以每一个变量 $b_i,d_i$ 都可以作为网络图中的一条边。

$\text{observationⅡ.}$ 常量 $a_i$ 也恰好在两个等式中出现，且是一正一负。为正时表示流入，可以和源点连边；为负时表示流出，可以和汇点连边。

根据作差规则， $a_i$ 一定是出现在第 $i, i + 1$ 两个等式中，且一定第 $i$ 个等式为负，第 $i + 1$ 个为正。

常量与源汇点连边，变量表示常量点之间的边跑平衡。

最后答案是 $\min \sum b_i·c_i$ ，可以以“费用”的形式表示出来。

简述建图方式：

假设 $a_0=a_{n+1}=0$ 。
- 建立源汇点 $s, t$ 。
- 建立点 $1\sim n+1$ ，代表 $n + 1$ 个等式。
- 第 $i + 1$ 个点向第 $i$ 个点连一条容量无穷，费用为零的边。对应 $b_i,d_i$ 的平衡。
- 第 $i$ 类志愿者连边 $s_i\rightarrow t_i+1$ ，容量无穷，费用为 $c_i$ 。
- 对于第 $i$ 个点，若 $a_i-a_{i-1}$ 为正，连边 $s\rightarrow i$ ，容量 $a_i-a_{i-1}$ 费用为零；若为负，连边 $i\rightarrow t$ ，容量 $a_{i-1}-a_i$ 费用为零。相当于等式中的常数项。

实际理解上可以把常数项提到右边：
$\begin{cases} b_1+b_3-d_1=a_1-a_0\\ b_2-b_3-d_2+d_1=a_2-a_1\\ -b_3-d_3+d_2=a_3-a_2\\ -b_1-b_2+d_3=a_4-a_3 \end{cases}$
把 $a_i-a_{i-1}$ 当成第 $i$ 个等式的盈亏量，这样你就能理解正负与源汇连边的意义了。

code

#include <bits/stdc++.h>
using namespace std;
#define maxn 2000
#define maxm 50000
#define int long long
#define inf 0x3f3f3f3f
struct node { int to, nxt, flow, cost; }E[maxm];
int head[maxn], dis[maxn], lst[maxn], vis[maxn], a[maxn];
int cnt = -1, n, m, s, t;
queue < int > q;

void addedge( int u, int v, int w, int c ) {
    E[++ cnt] = { v, head[u], w, c }; head[u] = cnt;
    E[++ cnt] = { u, head[v], 0,-c }, head[v] = cnt;
}

bool SPFA() {
    memset( lst, -1, sizeof( lst ) );
    memset( dis, 0x3f, sizeof( dis ) );
    q.push( dis[s] = 0 );
    while( ! q.empty() ) {
        int u = q.front(); q.pop(); vis[u] = 0;
        for( int i = head[u];~ i;i = E[i].nxt ) {
            int v = E[i].to;
            if( dis[v] > dis[u] + E[i].cost and E[i].flow ) {
                dis[v] = dis[u] + E[i].cost; lst[v] = i;
                if( ! vis[v] ) vis[v] = 1, q.push( v );
            }
        }
    }
    return ~ lst[t];
}

int MCMF() {
    int ans = 0;
    while( SPFA() ) {
        int flow = inf;
        for( int i = lst[t];~ i;i = lst[E[i ^ 1].to] )
            flow = min( flow, E[i].flow );
        for( int i = lst[t];~ i;i = lst[E[i ^ 1].to] ) {
            E[i ^ 1].flow += flow;
            E[i].flow -= flow;
            ans += flow * E[i].cost;
        }
    }
    return ans;
}

signed main() {
    memset( head, -1, sizeof( head ) );
    scanf( "%lld %lld", &n, &m );
    s = 0, t = n + 2;
    for( int i = 1;i <= n;i ++ ) scanf( "%lld", &a[i] );
    for( int i = 1;i <= n;i ++ ) addedge( i + 1, i, inf, 0 );
    for( int i = 1, u, v, w;i <= m;i ++ ) {
        scanf( "%lld %lld %lld", &u, &v, &w );
        addedge( u, v + 1, inf, w );
    }
    for( int i = 1;i <= n + 1;i ++ )
        if( a[i] - a[i - 1] > 0 ) addedge( s, i, a[i] - a[i - 1], 0 );
        else addedge( i, t, a[i - 1] - a[i], 0 );
    printf( "%lld\n", MCMF() );
    return 0;
}