HDU 4780 Candy Factory

Candy Factory

Time Limit: 2000ms

Memory Limit: 32768KB

This problem will be judged on HDU. Original ID: 4780
64-bit integer IO format: %I64d Java class name: Main

A new candy factory opens in pku-town. The factory import M machines to produce high quality candies. These machines are numbered from 1 to M.
  There are N candies need to be produced. These candies are also numbered from 1 to N. For each candy i , it can be produced in any machine j. It also has a producing time(si,ti) , meaning that candy i must start producing at time si and will finish at ti. Otherwise if the start time is pi(si < pi< ti) then candy will still finish at ti but need additional K*(pi - si) cost. The candy can’t be produced if pi is greater than or equal to ti. Of course one machine can only produce at most one candy at a time and can’t stop once start producing.
  On the other hand, at time 0 all the machines are in their initial state and need to be “set up” or changed before starting producing. To set up Machine j from its initial state to the state which is suitable for producing candiy i, the time required is Cij and cost is Dij. To change a machine from the state suitable for candy i1 into the state suitable for candy i2, time required is Ei1i2 and cost is Fi1i2.
  As the manager of the factory you have to make a plan to produce all the N candies. While the sum of producing cost should be minimized.

Input

　　There are multiple test cases.
　　For each case, the first line contains three integers N(1<=N<=100), M(1<=M<=100), K(1<=K<=100) . The meaning is described above.
　　Then N lines follow, each line contains 2 integers si and ti(0 <= si < ti <100000).
　　Then N lines follow, each line contains M integers, the j-th integer of the i-th line indicating Cij(1<=Cij<=100000) .
　　Then N lines follow, each line contains M integers, the j-th integer of the i-th line indicating Dij(1<=Dij<=100000) .
　　Then N lines follow, each line contains N integers, the i2-th integer of the i1-th line indicating Ei1i2(1<=Ei1j2<=100000) .
　　Then N lines follow, each line contains N integers, the i2-th integer of the i1-th line indicating Fi1i2(1 <= Fi1j2<=100000) .
　　Since the same candy will only be produced once, Eii and Fii are meaningless and will always be -1.
　　The input ends by N=0 M=0 K=0. Cases are separated with a blank line.

Output

For each test case, if all of M candies can be produced, output the sum of minimum producing cost in a single line. Otherwise output -1.

Sample Input

Sample Output

11

-1

Hint

For the first example, the answer can be achieved in the following way:

In the picture, S i represents setting up time for candy i, A i represents changing time for candy i and P i represents producing time for candy i . So the total cost includes: 　　setting up machine 1 for candy 1, costs 2 　　setting up machine 2 for candy 2, costs 3 　　changing state from candy 2 to candy 3, costs 5 　　late start of candy 2, costs 1

Source

2013 Asia Hangzhou Regional Contest

解题：最小费用最大流

 #include <bits/stdc++.h>

 using namespace std;

 const int INF = 0x3f3f3f3f;

 const int maxn = ;

 struct arc {

     int to,flow,cost,next;

     arc(int x = ,int y = ,int z = ,int nxt = -) {

         to = x;

         flow = y;

         cost = z;

         next = nxt;

     }

 } e[maxn*maxn];

 int head[maxn],p[maxn],d[maxn],S,T,tot,n,m,k;

 void add(int u,int v,int flow,int cost) {

     e[tot] = arc(v,flow,cost,head[u]);

     head[u] = tot++;

     e[tot] = arc(u,,-cost,head[v]);

     head[v] = tot++;

 }

 queue<int>q;

 bool in[maxn];

 bool spfa() {

     while(!q.empty()) q.pop();

     memset(p,-,sizeof p);

     memset(d,0x3f,sizeof d);

     d[S] = ;

     q.push(S);

     while(!q.empty()) {

         int u = q.front();

         q.pop();

         in[u] = false;

         for(int i = head[u]; ~i; i = e[i].next) {

             if(e[i].flow && d[e[i].to] > d[u] + e[i].cost) {

                 d[e[i].to] = d[u] + e[i].cost;

                 p[e[i].to] = i;

                 if(!in[e[i].to]) {

                     in[e[i].to] = true;

                     q.push(e[i].to);

                 }

             }

         }

     }

     return p[T] > -;

 }

 void solve() {

     int ret = ,flow = ;

     while(spfa()) {

         int minF = INF;

         for(int i = p[T]; ~i; i = p[e[i^].to])

             minF = min(minF,e[i].flow);

         for(int i = p[T]; ~i; i = p[e[i^].to]) {

             e[i].flow -= minF;

             e[i^].flow += minF;

         }

         ret += minF*d[T];

         flow += minF;

     }

     printf("%d\n",flow < n?-:ret);

 }

 int ss[maxn],tt[maxn],C[maxn][maxn],D[maxn][maxn],E[maxn][maxn],F[maxn][maxn];

 void Read() {

     memset(head,-,sizeof head);

     for(int i = tot = ; i < n; ++i)

         scanf("%d%d",ss + i,tt + i);

     for(int i = ; i < n; ++i)

         for(int j = ; j < m; ++j)

             scanf("%d",C[i] + j);

     for(int i = ; i < n; ++i)

         for(int j = ; j < m; ++j)

             scanf("%d",D[i] + j);

     for(int i = ; i < n; ++i)

         for(int j = ; j < n; ++j)

             scanf("%d",E[i] + j);

     for(int i = ; i < n; ++i)

         for(int j = ; j < n; ++j)

             scanf("%d",F[i] + j);

 }

 int main() {

     while(scanf("%d%d%d",&n,&m,&k),n||m||k) {

         Read();

         S = *n + m;

         T = S + ;

         for(int i = ; i < n; ++i) {

             add(S,i,,);

             add(i + n,T,,);

         }

         for(int i = ; i < m; ++i)

             add(n + n + i,T,,);

         for(int i = ; i < n; ++i)

             for(int j = ; j < m; ++j) {

                 if(C[i][j] >= tt[i]) continue;

                 int cost = D[i][j];

                 if(C[i][j] > ss[i]) cost += (C[i][j] - ss[i])*k;

                 add(i,*n + j,,cost);

             }

         for(int i = ; i < n; ++i)

             for(int j = ; j < n; ++j) {

                 if(i == j) continue;

                 int ctime = tt[i] + E[i][j];

                 if(ctime >= tt[j]) continue;

                 int cost = F[i][j];

                 if(ctime > ss[j]) cost += k*(ctime - ss[j]);

                 add(j,i + n,,cost);

             }

         solve();

     }

     return ;

 }