题目描述
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时有多少申请的员工
令
则有:
但因为第三式中有s[24],不符合差分约束形式,故枚举s[24]求解
同时有
故构造差分约束模型最短路求解
源代码
#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;
}