hdu 1529 Cashier Employment 差分约束系统

//hdu 1529 Cashier Employment
//差分约束系统
//还有国家集训队的黄源河的论文中的这题的后面两个不等式写错了

//不懂差分约束可以到这看看
//http://imlazy.ycool.com/post.1702305.html;
//一开始看我完全没想到可以用差分约束
//这题也主要是看了别人代码才过了的，还用了蹩脚的英文注释
//不过真感觉这题挺神奇的

//题意：
//第一行t,表示有几组测试数据；第二行24个数分别表示各个小时
//至少需要的出纳员数；接下去一行一个数表m示有几个应聘者
//接下去有m行，每行1个数表示该应聘者的开始工作时间
//每个出纳员若开始工作时间为st 则他一定连续工作8小时
//即工作到 st+8 小时

//思路：
//根据差分约束，我们可以先找出一些看的到的不等式
//s[i] 表示在从第0小时到第i个小时总的需要多少出纳员,则我们
//要求的就是s[23]了；w[i]表示应聘第i个小时开始工作的出纳员数
//所以我们要在输入的时候累加每个小时的应聘的出纳员数；
//r[i]表示第i个小时至少需要多少出纳员
//1、0 <= s[i] - s[i-1] <= w[i] (0 <= i <= 23)
//2、s[i] - s[i-8] >= r[i] (8 <= i <= 23)
//3、s[23] + s[i] - s[i+16] >= r[i] (0 <= i <= 7)

//第一个不等式s[i]-s[i-1]表示答案中第i个小时有多少个出纳员
//第二个不等式s[i]-s[i-8]表示出纳员工作的时间段有第i-8小时的人数
//第三个不等式和第二个一样的意思，只是这时是跨过一天，比如工作的
//的时间段有包括第1个小时的出纳员数即为 s[23]+s[1]-s[1+16]

//从上面的式子看，根据差分约束，我们要找出像求最短(长)路时的
//三角不等式：d[to] - d[from] >= w
//我们要转化为相同的样式，也就是不等号
//方向要相同，于是：上面3个式子就第一个式子需要转化，转化为
//s[i] - s[i-1] >= 0 和 s[i-1]-s[i] >= -w[i]
//这样子就变成4个不等式了
//接下来的难点就是最后一个式子有个s[23]这个既是我们所要求的答案
//这里又要当做常数(因为它的下标是固定的，当做常数比较好处理，而且
//按照式子把s[23]当做常数，跟上面的样式才一样，都有变量i)，
//这样我们就可以把s[23]当做常数移到右边去，然后枚举所有s[23]可能取到
//的值(0 <= s[23] <= 总的应聘人数m),这里也可以用二分，不过我们尝试过
//然后就可以根据三角不等式d[to]-d[from]>=w 建一条from 到 to的边
//因为差分约束是求单源最短路，所以要建一个源点,我把源点的下标设为24
//跟源点连边的就只要根据第1个式子跟0点建边即可(s[-1] - s[0] >= w[0])
//这里s[-1]极为源点s[24]，从0指向24
//求出来的dis数组中每个数就是有经过各个时间的的出纳员总数
//我们用的是 >= 所以我们在求最短路是要维护好,即若s[to] - s[from] < w[i]
//则要把s[to]维护为s[to] = s[from] + w[i] 这样就保持了>=号
//其他的看代码中的注释

//看不懂的话可以到这来看看，我也是看这的
//他写的解释不错，不过跟人觉得他代码风格不好，还用goto
//http://www.cnblogs.com/zhuangli/archive/2008/07/26/1252252.html

#define comein freopen("in.txt", "r", stdin);
#include <stdio.h>
#include <string.h>
#include <queue>
using namespace std;

#define INF 1<<30
#define N 30

int hour_least[N], app_st[N], hour_most[N];
//count array is to count the time of a point have been visited
int head[N], relate23[N], dis[N], count[N];
int eid, eid23, source_id;
bool vis[N];

struct EDGE
{
    int to, dis, next;
}edge[1005];

void buildMap() //build map
{
    eid = 0;
    memset(head, -1, sizeof(head));
    for(int i = 1; i < 24; ++i)
    {   //s[i] represent sum of employees at before i hour
        //so s[23] is the answer which us want to get
        //0 <= s[i] - s[i-1] <= most[i] (0 <= i <= 23)

        //build edge from i-1 to i for s[i] - s[i-1] >= 0
        edge[++eid].to = i;
        edge[eid].dis = 0;
        edge[eid].next = head[i-1];
        head[i-1] = eid;

        //build edge from i to i-1 for s[i-1] - s[i] >= -most[i]
        edge[++eid].to = i-1;
        edge[eid].dis = -hour_most[i];
        edge[eid].next = head[i];
        head[i] = eid;

        if(i >= 8)   //s[i] - s[i-8] >= r[i] (8 <= i <= 23)
        {   //r[i] represent at i hour need at least r[i] employees
            edge[++eid].to = i;
            edge[eid].dis = hour_least[i];
            edge[eid].next = head[i-8];
            head[i-8] = eid;
        }
    }

    //s[i-1] - s[i] >= -Num[i] (0 <= i <= 23)   这里取i=0
    //s[-1] - s[0] >= -Num[0]   这里的Num相当于hour_most
    //from 24 to 0
    edge[++eid].to = 24;
    edge[eid].dis = -hour_most[0];
    edge[eid].next = head[0];
    head[0] = eid;

    for(int i = 0; i < 24; ++i)
    {   //s[23] + s[i] - s[i+16] >= r[i] (0 <= i <= 7)
        if(i <= 7)
        {   //build edge from (16、17...23) to (0、1、2...7)
            edge[++eid].to = i;
            edge[eid].dis = hour_least[i] - 0; //assume s[23] zero
            edge[eid].next = head[i+16];
            head[i+16] = eid;
            relate23[i] = eid; //mark the id which relate to s[23]
        }
        //Add a source point 24
        //build edge from source to i, and value of edge is zero
        edge[++eid].to = i;
        edge[eid].dis = 0;      //24到23的距离最长先设为0
        edge[eid].next = head[24];
        head[24] = eid;
        if(i == 23)
            source_id = eid;
    }
}

bool spfa()
{
    for(int i = 0; i < 25; ++i)
    {
        vis[i] = false;
        dis[i] = -(INF);
        count[i] = 0;
    }
    dis[24] = 0;    //这个记得赋值为0，刚开始一直没找到错误，原来是这里
    queue<int>que;
    que.push(24);
    vis[24] = true;
    while(!que.empty())
    {
        int now = que.front();
        que.pop();
        for(int i = head[now]; i != -1; i= edge[i].next)
        {
            int to = edge[i].to;
            if(dis[to] - dis[now] < edge[i].dis)
            {
                dis[to] = dis[now] + edge[i].dis;
                if(vis[to] == false)
                {
                    vis[to] = true;
                    count[to]++;

                    //判断负环,若进队次数比边数还多，那就说明有负环
                    if(count[to] > eid)
                        return false;
                    que.push(to);
                }
            }
        }
        vis[now] = false;
    }
    return true;
}

void find(int n_app)
{
    int sum = 0;
    bool is_find = false;
    while(is_find == false && sum <= n_app)
    {   //as from point i to i+16 distanse is r[i]-s[23]
        //here r[i] equal to hour_least[i] and s[23] equal to sum
        //if s[23] too small, there will have a loop when spfa()
        for(int i = 0; i <= 7; ++i) //这里与最后一个不等式相关的边都要更新
            edge[relate23[i]].dis = hour_least[i] - sum;
        //这里要更新,当最长路和sum,即从24到23的距离跟 从24到23的最长路相等
        //时就表示找到答案了
        edge[source_id].dis = sum;  //here is most important

        is_find = spfa();   //寻找最长路

        //听说这里sum 不能等于4 不知道为什么 不过没有加上 ||sum == 4
        if(is_find == false || dis[23] != sum)//也可以过
        {
            is_find = false;
            sum++;
        }
    }
    if(is_find == true)
        printf("%d\n", sum);
    else
        puts("No Solution");
}

int main()
{
    int n_case;
    scanf("%d", &n_case);
    while(n_case--)
    {
        for(int i = 0; i < 24; ++i)
        {
            hour_most[i] = 0;    //记录
            scanf("%d", &hour_least[i]);
        }
        int n_app;  //number of applicants
        scanf("%d", &n_app);
        for(int i = 0; i < n_app; ++i)
        {
            scanf("%d", &app_st[i]);
            //the most applicant can reach to i hour
            hour_most[app_st[i]]++;
        }
        buildMap();
        find(n_app);
    }
    return 0;
}