＜算法竞赛进阶指南＞ 差分约束 雇佣收银员

一家超市要每天 24 小时营业，为了满足营业需求，需要雇佣一大批收银员。

已知不同时间段需要的收银员数量不同，为了能够雇佣尽可能少的人员，从而减少成本，这家超市的经理请你来帮忙出谋划策。

经理为你提供了一个各个时间段收银员最小需求数量的清单 R(0),R(1),R(2),…,R(23)。

R(0) 表示午夜 00:00 到凌晨 01:00 的最小需求数量，R(1) 表示凌晨 01:00 到凌晨 02:00 的最小需求数量，以此类推。

一共有 NN 个合格的申请人申请岗位，第 i 个申请人可以从 ti 时刻开始连续工作 8 小时。

收银员之间不存在替换，一定会完整地工作 8 小时，收银台的数量一定足够。

现在给定你收银员的需求清单，请你计算最少需要雇佣多少名收银员。

输入格式

第一行包含一个不超过 20 的整数，表示测试数据的组数。

对于每组测试数据，第一行包含 24 个整数，分别表示 R(0),R(1),R(2),…,R(23)。

第二行包含整数 N。

接下来 NN 行，每行包含一个整数 ti。

输出格式

每组数据输出一个结果，每个结果占一行。

如果没有满足需求的安排，输出 No Solution。

数据范围

0≤R(0)≤1000,
0≤N≤1000,
0≤ti≤23

输入样例：

1
1 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
5
0
23
22
1
10

输出样例：

1

若不清楚差分约束算法的同学可以看看这篇博客：(16条消息) 《图论：差分约束算法详解 + 算法证明》+ 模板题：糖果_wsh1931的博客-CSDN博客

假设x[i]表示第i个时间段雇用了多少人，nums[i]从 i 这个点来的人数。

1:  0 <= x[i] <= nums[i];（即第i个时间段所选择的人数必需小于等于i 这个时间段来的人数）

2: x[i - 7] + x[i - 6] + .....x[i] >=  R[i];（即第 i 个时间段之前的8个小时雇佣的人数必需大于题目要求的在第 i 个时间段的人数)。

我们可以看出条件二并不符合差分约束算法的形式，因此我们可以求一个x[i]的前缀和s[i], s[i]表示前 i 个时间段雇佣了多少人

因为涉及前缀和需要把s[0]空出，所以我们可以把所有的时间从[0, 23]映射成[1, 24];

因此条件一可以转换成：

0 <= s[i] - s[i - 1] <= nums[i];

条件二可以转换成;

(i >= 8)：s[i] - s[i - 8] >= R[i];

(0 < i < 7)：s[i] + s[24] - s[i + 16] >= R[i];

这里可以这样理解将1 2 3 4 ..... 24看成 1 2 3 4 .... 24 1 2 3 4 ... 24即若雇佣员到了24点，但还未满8小时再从1开始工作知道满8小时为止

这里求得是最少的雇佣员，则求的是最长路。

将2个条件总结一下即：
1:  s[i] >= s[i - 1];

2:  s[i - 1] >= s[i] - nums[i];

3:  (i >= 8) s[i] >= s[i - 8] + R[i];

4:  (0 < i < 7) s[i] >= R[i] + s[i + 16] - s[24]

第四条结论仍然不符合差分约束因为0≤N≤1000所以我们可以从0 到 1000枚举s[24]这样s[24]就成了常数，这里要注意要将s[24]变成常数还要加两条边分别是: s[24] >= c, s[24] <= c，s[24]最终才为c,  c为s[24]枚举的常数值

所以 5 ：s[24] >= c, s[24] <= c ->  s[24] >= s[0] + c, s[0] >= s[24] - c即从0 -> 24 连一条权值为c的边，再从24 -> 0连一条权值为c的边

因为条件一：s[i] >= s[i - 1]因此从0出发可以遍历所有的点，即可以遍历所有的边因此不需要建立超级源点

#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>

using namespace std;

const int N = 30, M = N * 3;//24个点，条件一，二的边数分别为N, 条件三，四总共的边数为N

int n;
int R[N];
int cnt[N];
bool st[N];
int nums[N];
int dist[N];
int h[N], e[M], ne[M], w[M], idx;

void add(int a, int b, int c)
{
    e[idx] = b;
    w[idx] = c;
    ne[idx] = h[a];
    h[a] = idx;
    idx ++ ;
}

void build(int s24)
{
    idx = 0;
    memset(h, -1, sizeof h);
    for (int i = 1; i <= 24; i ++ ) add(i - 1, i, 0);//条件一
    for (int i = 1; i <= 24; i ++ ) add(i, i - 1, -nums[i]);//条件二
    for (int i = 8; i <= 24; i ++ ) add(i - 8, i, R[i]);//条件三
    for (int i = 0; i < 7; i ++ ) add(i + 16, i, R[i] - s24);//条件四
    add(0, 24, s24), add(24, 0, -s24);//条件5
}

bool spfa()
{
    memset(st, 0, sizeof st);
    memset(cnt, 0, sizeof cnt);
    memset(dist, -0x3f, sizeof dist);
    
    queue<int> q;
    q.push(0);
    st[0] = true;
    dist[0] = 0;
    
    while (q.size())
    {
        int t = q.front();
        q.pop();
        
        st[t] = false;
        
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            
            if (dist[j] < dist[t] + w[i])
            {
                cnt[j] = cnt[t] + 1;
                if (cnt[j] >= 25) return false;//包括0点
                
                dist[j] = dist[t] + w[i];
                if (!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }
    
    return true;
}

int main()
{
    int T;
    cin >> T;
    while (T -- )
    {
        for (int i = 1; i <= 24; i ++ ) scanf("%d", &R[i]);
        
        cin >> n;
        memset(nums, 0, sizeof nums);
        for (int i = 0; i < n; i ++ )
        {
            int t;
            scanf("%d", &t);
            nums[++ t] ++ ;//从【0，23】映射成【1，24】
        }
        
        bool is_true = false;
        for (int i = 0; i <= 1000; i ++ ) //枚举s[24]的人数即前24的时间段内雇佣的总人数
        {
            build(i);
            if (spfa())
            {
                printf("%d\n", i);
                is_true = true;
                break;
            }
        }
        
        if (!is_true) puts("No Solution");//若没找到。
    }
    
    return 0;
}