[poj1275] 出纳员的雇佣Cashier Employment

---

题目描述

　　Tehran的一家每天24小时营业的超市，需要一批出纳员来满足它的需要。超市经理雇佣你来帮他解决问题—超市在每天的不同时段需要不同数目的出纳员（例如：午夜时只需一小批，而下午则需要很多）来为顾客提供优质服务。他希望雇佣最少数目的出纳员。
　　经理已经提供你一天的每一小时需要出纳员的最少数量——R0, R1, …, R23。R0表示从午夜到上午1：00需要出纳员的最少数目，R1表示上午1：00到2：00之间需要的，等等。每一天，这些数据都是相同的。有N人申请这项工作，每个申请者i在每24小时中，从一个特定的时刻开始连续工作恰好8小时，定义ti （0 <= ti<= 23）为上面提到的开始时刻。也就是说，如果第i个申请者被录取，他（她）将从ti 时刻开始连续工作8小时。
　　你将编写一个程序，输入Ri（i = 0..23）和ti （i = 1..N），它们都是非负整数，计算为满足上述限制需要雇佣的最少出纳员数目。在每一时刻可以有比对应的Ri更多的出纳员在工作。

---

输入格式

输入文件的第一行为测试数据组数（最多20组），每一组数据的第一行有24个整数表示R0，R1，…， R23（Ri<= 1000）。接下来一行是N，表示申请者数目（0 <= N <= 1000），接下来每行包含一个整数ti （0 <= ti <= 23）。

---

输出格式

对于每组数据输出只有一行，包含一个整数，表示需要出纳员的最少数目。如果无解，你应当输出“No Solution”。

---

样例数据

样例输入

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

---

题目分析

挺难的差分约束
设x[i]表示i时雇佣的人数（0时视为24时）
Need[i]表示i时需求的人数
Num[i]表示i时有多少申请的员工
令

si=∑j=1ixi

$$s_i=\sum_{j=1}^ix_i$$
则有：
$$0\le s_i-s_{i-1}\le Num_i（1\le i\le 24）$$
$$s_i-s_{i-8}\ge Need_i（8\le i\le 24）$$
$$s_i+s_{24}-s_{i-8+24}\ge （1\le i\le 7）$$
但因为第三式中有s[24]，不符合差分约束形式，故枚举s[24]求解
同时有
$$s_{24}-s_{0}=k$$
故构造差分约束模型最短路求解

---

源代码

#include<algorithm>
#include<iostream>
#include<iomanip>
#include<cstring>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<cmath>
#include<queue>
using namespace std;
inline const int Get_Int() {
    int num=0,bj=1;
    char x=getchar();
    while(x<'0'||x>'9') {
        if(x=='-')bj=-1;
        x=getchar();
    }
    while(x>='0'&&x<='9') {
        num=num*10+x-'0';
        x=getchar();
    }
    return num*bj;
}
const int maxn=5005;
struct Edge {
    int from,to,dist;
};
struct Difference_Constraints { //差分约束系统
    int n,m;
    vector<Edge>edges;
    vector<int>G[maxn];
    bool inque[maxn];
    int dist[maxn],used[maxn];
    int ans[maxn]; //ans表示不等式组答案
    void init(int n) {
        this->n=n;
        edges.clear();
        for(int i=1; i<=n; i++)G[i].clear();
    }
    void AddEdge(int from,int to,int dist) {
        edges.push_back((Edge) {
            from,to,dist
        });
        m=edges.size();
        G[from].push_back(m-1);
    }
    void insert(int x,int y,int v,bool flag) { //x-y<=v (flag=0),x-y>=v (flag=1)
        if(flag==0)AddEdge(y,x,v);
        if(flag==1)AddEdge(y,x,-v);
    }
    bool spfa(int s) {
        for(int i=1; i<=n; i++)dist[i]=0x7fffffff/2;
        memset(inque,0,sizeof(inque));
        memset(used,0,sizeof(used));
        deque<int>Q;
        Q.push_back(s);
        dist[s]=0;
        inque[s]=1;
        used[s]++;
        while(!Q.empty()) {
            int Now=Q.front();
            Q.pop_front();
            inque[Now]=0;
            for(int i=0; i<G[Now].size(); i++) {
                Edge& e=edges[G[Now][i]];
                int Next=e.to;
                if(dist[Next]>dist[Now]+e.dist) {
                    dist[Next]=dist[Now]+e.dist;
                    if(!inque[Next]) {
                        used[Next]++;
                        if(used[Next]>n+1)return false; //负权回环
                        if(!Q.empty()&&dist[Next]<dist[Q.front()])Q.push_front(Next); //SLF优化
                        else Q.push_back(Next);
                        inque[Next]=1;
                    }
                }
            }
        }
        return true;
    }
    bool main(int Start,bool flag) { //求出正整数解
        if(spfa(Start)==0)return false;
        int Min=0x7fffffff/2;
        if(flag==1) { //最长路
            for(int i=1; i<=n; i++)dist[i]*=-1;
        }
        for(int i=1; i<=n; i++)Min=min(Min,dist[i]); //转为正数
        for(int i=1; i<=n; i++)ans[i]=dist[i]-Min;
        return true;
    }
    void Output() {
        for(int i=1; i<=n; i++)printf("%d\n",ans[i]);
    }
};
Difference_Constraints dc;
int n,Need[35],Num[35],bj=0,t;
int main() {
    t=Get_Int();
    for(int k=1; k<=t; k++) {
        bj=0;
        memset(Num,0,sizeof(Num));
        Need[24]=Get_Int();
        for(int i=1; i<=23; i++)Need[i]=Get_Int();
        n=Get_Int();
        for(int i=1; i<=n; i++) {
            int x=Get_Int();
            if(x==0)x=24;
            Num[x]++;
        }
        for(int i=1; i<=n; i++) { //枚举s[24]
            dc.init(35);
            for(int j=1; j<=24; j++) {
                dc.insert(j,j-1,Num[j],0);
                dc.insert(j-1,j,0,0);
                if(j>=8)dc.insert(j-8,j,-Need[j],0);
            }
            dc.insert(24,0,i,0);
            dc.insert(0,24,-i,0);
            for(int j=1; j<=7; j++)dc.insert(j+16,j,i-Need[j],0);
            if(dc.main(0,0)) {
                printf("%d\n",i);
                bj=1;
                break;
            }
        }
        if(bj==0)puts("No Solution");
    }
    return 0;
}

---