2245: [SDOI2011]工作安排
Time Limit: 20 Sec Memory Limit: 512 MBSubmit: 1177 Solved: 567
[Submit][Status][Discuss]
Description
你的公司接到了一批訂單。訂單要求你的公司提供n類產品，產品被編號爲1~n，其中第i類產品共需要Ci件。公司共有m名員工，員工被編號爲1~m員工能夠製造的產品種類有所區別。一件產品必須完整地由一名員工製造，不可以由某名員工製造一部分配件後，再轉交給另外一名員工繼續進行製造。
我們用一個由0和1組成的m*n的矩陣A來描述每名員工能夠製造哪些產品。矩陣的行和列分別被編號爲1~m和1~n，Ai,j爲1表示員工i能夠製造產品j，爲0表示員工i不能製造產品j。
如果公司分配了過多工作給一名員工，這名員工會變得不高興。我們用憤怒值來描述某名員工的心情狀態。憤怒值越高，表示這名員工心情越不爽，憤怒值越低，表示這名員工心情越愉快。員工的憤怒值與他被安排製造的產品數量存在某函數關係，鑑於員工們的承受能力不同，不同員工之間的函數關係也是有所區別的。
對於員工i，他的憤怒值與產品數量之間的函數是一個Si+1段的分段函數。當他製造第1~Ti,1件產品時，每件產品會使他的憤怒值增加Wi,1，當他製造第Ti,1+1~Ti,2件產品時，每件產品會使他的憤怒值增加Wi,2……爲描述方便，設Ti,0=0,Ti,si+1=+∞，那麼當他製造第Ti,j-1+1~Ti,j件產品時，每件產品會使他的憤怒值增加Wi,j， 1≤j≤Si+1。
你的任務是制定出一個產品的分配方案，使得訂單條件被滿足，並且所有員工的憤怒值之和最小。由於我們並不想使用Special Judge，也爲了使選手有更多的時間研究其他兩道題目，你只需要輸出最小的憤怒值之和就可以了。
Input
第一行包含兩個正整數m和n，分別表示員工數量和產品的種類數；
第二行包含n 個正整數，第i個正整數爲Ci；
以下m行每行n 個整數描述矩陣A；
下面m個部分，第i部分描述員工i的憤怒值與產品數量的函數關係。每一部分由三行組成：第一行爲一個非負整數Si，第二行包含Si個正整數，其中第j個正整數爲Ti,j，如果Si=0那麼輸入將不會留空行（即這一部分只由兩行組成）。第三行包含Si+1個正整數，其中第j個正整數爲Wi,j。
Output
僅輸出一個整數，表示最小的憤怒值之和。
Sample Input
2 3
2 2 2
1 1 0
0 0 1
1
2
1 10
1
2
1 6
Sample Output
HINT
.jpg)
解題思路：
裸的費用流。
源點向每件物品連邊，容量爲C[i], 費用爲0。
每個人向匯點連S[i]+1條邊，每條邊的容量爲T[i][j] - T[i][j-1], 費用爲W[i][j]。
物品和員工之間直接按所給的矩陣連容量爲無窮大的邊。
結果要用long long 。
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#define LL long long
using namespace std;
const int MAXN = 1000 + 10;
const int MAXM = 500000 + 10;
const int INF = 0x3f3f3f3f;
int read()
{
int x = 0, f = 1; char ch = getchar();
while(ch < '0' || ch > '9') {if(ch == '-') f *= -1; ch = getchar();}
while(ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
struct Edge
{
int to, next, cap, flow, cost;
}edge[MAXM];
int head[MAXN], tot, pre[MAXN], dis[MAXN];
bool vis[MAXN];
int N;
void init(int n)
{
N = n; tot = 0;
memset(head, -1, sizeof(head));
}
void addedge(int u, int v, int cap, int cost)
{
edge[tot].to = v; edge[tot].cap = cap;
edge[tot].cost = cost; edge[tot].flow = 0;
edge[tot].next = head[u]; head[u] = tot++;
edge[tot].to = u; edge[tot].cap = 0;
edge[tot].cost = -cost; edge[tot].flow = 0;
edge[tot].next = head[v]; head[v] = tot++;
}
bool spfa(int s, int t)
{
queue<int>q;
for(int i=0;i<N;i++)
{
dis[i] = INF, vis[i] = false, pre[i] = -1;
}
dis[s] = 0, vis[s] = true, q.push(s);
while(!q.empty())
{
int u = q.front();q.pop();
vis[u] = false;
for(int i=head[u];i!=-1;i=edge[i].next)
{
int v = edge[i].to;
if(edge[i].cap > edge[i].flow && dis[v] > dis[u] + edge[i].cost)
{
dis[v] = dis[u] + edge[i].cost;
pre[v] = i;
if(!vis[v]){vis[v] = true; q.push(v);}
}
}
}
if(pre[t] == -1) return false;
else return true;
}
int minCostMaxflow(int s, int t, LL& cost)
{
int flow = 0;cost = 0;
while(spfa(s, t))
{
int Min = INF;
for(int i=pre[t];i!=-1;i=pre[edge[i^1].to])
{
if(Min > edge[i].cap - edge[i].flow)
Min = edge[i].cap - edge[i].flow;
}
for(int i=pre[t];i!=-1;i=pre[edge[i^1].to])
{
edge[i].flow += Min;
edge[i^1].flow -= Min;
cost += edge[i].cost * Min;
}
flow += Min;
}
return flow;
}
int m, n, C[MAXN], A[300][300];
int S[MAXN], T[300][300], W[300][300];
int main()
{
m = read(), n = read();
for(int i=1;i<=n;i++) C[i] = read();
for(int i=1;i<=m;i++) for(int j=1;j<=n;j++) A[i][j] = read();
for(int i=1;i<=m;i++)
{
S[i] = read();
for(int j=1;j<=S[i];j++) T[i][j] = read();
for(int j=1;j<=S[i]+1;j++) W[i][j] = read();
T[i][0] = 0, T[i][S[i]+1] = INF;
}
init(n + m + 2); int start = 0, end = n + m + 1;
for(int i=1;i<=n;i++) addedge(start, i, C[i], 0);
for(int i=1;i<=m;i++) for(int j=1;j<=n;j++) if(A[i][j]) addedge(j, i + n, INF, 0);
for(int i=1;i<=m;i++)
{
for(int j=1;j<=S[i]+1;j++)
addedge(i + n, end, T[i][j] - T[i][j-1], W[i][j]);
}
LL cost = 0;
int ans = minCostMaxflow(start, end, cost);
printf("%lld\n", cost);
return 0;
}