Acwing393. 雇佣收银员 题解 差分约束

题目链接：https://www.acwing.com/problem/content/description/395/

解题思路：

差分约束。

为了方便起见，定义第 \(i\) 个时间段为 \(i-1:00\) 到 \(i:00\) 这个时间段。

首先，为了方便开一个额外的点，令 \(R_i\) 对应为题目中的 \(R(i+1)\)，即 \(R_i\) 表示 \(i-1:00\) 到 \(i:00\) 这个时间段的最小需求人数。即用 \(R_i\) 替代 \(R(i+1)\) 表示第 \(i\) 个时间段人数的需求量。

然后，统计一下每个时间段能够供给的最大人数，用 \(num_i\) 表示第 \(i\) 个时间段能够供给的最大人数。

用 \(x_i\) 表示第 \(i\) 个时间段需要分配的最小人数，可以得到以下式子：

• \(0 \le x_i \le num_i\)，①
• \(x_{i-7} + x_{i-6} + \cdots + x_i \ge r_i\)，②

上述这个式子不具有差分约束的一般性，所以开一个前缀和，定义 \(S_i = \sum\limits_{j=1}^i x_j\)，上述不等式组转换为：

• \(0 \le S_i - S_{i-1} \le num_i\)，对任意 \(1 \le i \le 24\)
• 当 \(8 \le i \le 24\) 时，有
  • \(S_i - S_{i-8} \ge r_i\)
• 当 \(1 \le i \le 7\) 时，有
  • \(S_i + S_{24} - S_{i+16} \ge r_i\)

将上面这些式子重新梳理一下得：

1. 对于任意 \(1 \le i \le 24\)，有 \(S_i \ge S_{i-1} + 0\)
2. 对于任意 \(1 \le i \le 24\)，有 \(S_{i-1} \ge S_i - num_i\)
3. 对于任意 \(8 \le i \le 24\)，有 \(S_i \ge S_{i-8} + r_i\)
4. 对于任意 \(1 \le i \le 7\)，有 \(S_i \ge S_{i+16} + r_i - S_{24}\)

显然第 \(4\) 种情况还是不具有差分约束的一般性。

但是可以发现 \(S_{24} \le N \le 1000\)，所以可以从 \(0\) 到 \(N\)枚举 \(S_{24}\) 的值，差分约束建图判断是否存在负环。不存在负环的最小的 \(S_{24}\) 就是我们所需的答案。

另外，因为 \(S_{24}\) 目前是一个固定值，所以我们还可以得到一个等式：

\(S_{24} = S_0 + C\)

其中 \(C\) 对应的就是 \(S_{24}\) 的固定的值。

所以，还需满足如下两个式子：

• \(S_{24} \ge S_0 + C\)
• \(S_0 \ge S_{24} - C\)

对应需要额外加两条边。

示例程序：

#include <bits/stdc++.h>
using namespace std;
const int maxn = 25;
struct Edge {
    int v, w;
};
vector<Edge> g[maxn];

int dis[maxn], cnt[maxn];
bool ins[maxn];
bool spfa() {
    stack<int> stk;
    memset(cnt, 0, sizeof(cnt));
    memset(ins, 0, sizeof(ins));
    memset(dis, -0x3f, sizeof(dis));
    dis[0] = 0;
    stk.push(0);
    while (!stk.empty()) {
        int u = stk.top();
        stk.pop();
        ins[u] = false;
        if (++cnt[u] >= 25)
            return false;
        for (auto e : g[u]) {
            int v = e.v, w = e.w;
            if (dis[v] < dis[u] + w) {
                dis[v] = dis[u] + w;
                if (!ins[v])
                    ins[v] = true, stk.push(v);
            }
        }
    }
    return true;
}

int T, r[maxn], N, num[maxn];

int cal() {
    for (int S24 = 0; S24 <= N; S24++) {
        for (int i = 0; i < 25; i++) g[i].clear();
        for (int i = 1; i <= 24; i++) {
            g[i-1].push_back({i, 0});
            g[i].push_back({i-1, -num[i]});
            if (i >= 8)
                g[i-8].push_back({i, r[i]});
            else
                g[i+16].push_back({i, r[i] - S24});
        }
        g[0].push_back({24, S24});
        g[24].push_back({0, -S24});
        if (spfa())
            return S24;
    }
    return -1;
}

int main() {
    scanf("%d", &T);
    while (T--) {
        for (int i = 1; i <= 24; i++)
            scanf("%d", r + i);
        memset(num, 0, sizeof(num));
        scanf("%d", &N);
        for (int i = 0; i < N; i++) {
            int t;
            scanf("%d", &t);
            t++;
            num[t]++;
        }
        int ans = cal();
        if (ans == -1)
            puts("No Solution");
        else
            printf("%d\n", ans);
    }
    return 0;
}