2016 Multi-University Training Contest 9

#include <bits/stdc++.h>

const int N = 200 + 5;
const int INF = 0x3f3f3f3f;
int pay
, t
;
int pro
;
std::vector<int> need
;
int n, m;
int L;

/*
*最大流之Dinic算法：不停地构造层次图，然后用阻塞流增广。
*时间复杂度为 O(n^2*m)。
*如果容量为1，复杂度为 O(min(n^(2/3), m^(1/2)*m)。
*对于二分图最大匹配这样的特殊图，复杂度为 O(n^(1/2)*m)
*/
struct Max_Flow {
struct Edge {
int from, to, cap, flow;
};
std::vector<Edge> edges;
std::vector<int> G[2*N]; //保存每个结点的弧在edges里的序号
int level[2*N], cur[2*N]; //结点在层次图中的等级。结点当前弧下标。
int n, m, s, t;
//初始化顶点个数n，边的个数m在加边时统计，s和t分别为源点和汇点
void init(int n) {
this->n = n;
for (int i=0; i<=n; ++i) {
G[i].clear ();
}
edges.clear ();
}
void add_edge(int from, int to, int cap) {
edges.push_back ((Edge) {from, to, cap, 0});
edges.push_back ((Edge) {to, from, 0, 0});
m = edges.size ();
G[from].push_back (m - 2);
G[to].push_back (m - 1);
}
bool BFS() {
std::fill (level, level+1+n, -1);
std::queue<int> que;
level[s] = 0; que.push (s);
while (!que.empty ()) {
int u = que.front (); que.pop ();
for (int i=0; i<G[u].size (); ++i) {
Edge &e = edges[G[u][i]];
if (level[e.to] == -1 && e.cap > e.flow) {
level[e.to] = level[u] + 1;
que.push (e.to);
}
}
}
return level[t] != -1;
}
int DFS(int u, int a) {
if (u == t || a == 0) {
return a; //a表示当前为止所有弧的最小残量
}
int flow = 0, f;
for (int &i=cur[u]; i<G[u].size (); ++i) {
Edge &e = edges[G[u][i]];
if (level[u] + 1 == level[e.to]
&& (f = DFS (e.to, std::min (a, e.cap - e.flow))) > 0) {
e.flow += f;
edges[G[u][i]^1].flow -= f;
flow += f; a -= f;
if (a == 0) {
break;
}
}
}
return flow;
}
int Dinic(int s, int t) {
this->s = s; this->t = t;
int flow = 0;
while (BFS ())  {
std::fill (cur, cur+1+n, 0);
flow += DFS (s, INF);
}
return flow;
}
}max_flow;

int check(int max_t) {
int S = 0, T = n + m + 1;
int sum = 0;
max_flow.init (n+m+2);
for (int i=1; i<=m; ++i) {
max_flow.add_edge (S, i, pro[i]);
bool flag = true;
for (int j: need[i]) {
if (t[j] > max_t) {
flag = false;
break;
}
}
if (flag) {
for (int j: need[i]) {
max_flow.add_edge (i, m+j, INF);
}
sum += pro[i];
}
}
for (int i=1; i<=n; ++i) {
if (t[i] <= max_t)
max_flow.add_edge (m+i, T, pay[i]);  //abs (-pay[i])
}
int min_cut = max_flow.Dinic (S, T);
if (sum - min_cut >= L)
return sum - min_cut;
else
return -1;
}

void solve(int cas) {
printf ("Case #%d: ", cas);
int best_t = INF, best_p = 0;
int l = 1, r = 1000000000;
while (l <= r) {
int mid = l + r >> 1;
int res = check (mid);
if (res != -1) {
best_t = std::min (best_t, mid);
best_p = res;
r = mid - 1;
} else
l = mid + 1;
}
if (best_t < INF)
printf ("%d %d\n", best_t, best_p);
else
puts ("impossible");
}

int main() {
int T;
scanf ("%d", &T);
for (int cas=1; cas<=T; ++cas) {
scanf ("%d%d%d", &n, &m, &L);
for (int i=1; i<=n; ++i) {
scanf ("%d%d", pay+i, t+i);
}
for (int i=1; i<=m; ++i) {
scanf ("%d", pro+i);
need[i].clear ();
int k;
scanf ("%d", &k);
while (k--) {
int id;
scanf ("%d", &id);
need[i].push_back (id);
}
}
solve (cas);
}
return 0;
}

#include <bits/stdc++.h>

const int N = 200 + 5;
const int INF = 0x3f3f3f3f;

struct Plant {
int pay, t;
}p
;
std::vector<int> id
;

struct Shop {
int pro;
std::vector<int> need;
int pay;
int max_t;
int done;
}s
;

int n, m;
int L;

bool vis_p
, vis_s
;

int check(int max_t) {
memset (vis_p, false, sizeof (vis_p));
memset (vis_s, false, sizeof (vis_s));
for (int i=0; i<m; ++i)
s[i].done = 0;
int ret = -INF, tmp = 0;
for (; ;) {
int max_val = -INF, k = -1;
for (int i=0; i<m; ++i) {
if (!vis_s[i] && s[i].max_t <= max_t) {
if (max_val < s[i].pro - s[i].pay + s[i].done) {
max_val = s[i].pro - s[i].pay + s[i].done;
k = i;
}
}
}
if (max_val == -INF)
break;
vis_s[k] = true;  //max m times
tmp += max_val;
ret = std::max (ret, tmp);
for (int j: s[k].need) {
if (!vis_p[j]) {
vis_p[j] = true;
for (int l: id[j]) {
if (!vis_s[l]) {
s[l].done += p[j].pay;
}
}
}
}
}
return ret >= L ? ret : -1;
}

void solve(int cas) {
printf ("Case #%d: ", cas);
int best_t = INF, best_p = 0;
int l = 1, r = 1000000000;
while (l <= r) {
int mid = l + r >> 1;
int res = check (mid);
if (res != -1) {
best_t = std::min (best_t, mid);
best_p = res;
r = mid - 1;
} else
l = mid + 1;
}
if (best_t < INF)
printf ("%d %d\n", best_t, best_p);
else
puts ("impossible");
}

int main() {
int T;
scanf ("%d", &T);
for (int cas=1; cas<=T; ++cas) {
scanf ("%d%d%d", &n, &m, &L);
for (int i=0; i<n; ++i) {
scanf ("%d%d", &p[i].pay, &p[i].t);
id[i].clear ();
}
for (int i=0; i<m; ++i) {
scanf ("%d", &s[i].pro);
s[i].need.clear ();
s[i].max_t = -1;
s[i].pay = 0;
int k;
scanf ("%d", &k);
while (k--) {
int j;
scanf ("%d", &j);
j--;
if (p[j].t > s[i].max_t)
s[i].max_t = p[j].t;
s[i].pay += p[j].pay;
s[i].need.push_back (j);
id[j].push_back (i);
}
}
solve (cas);
}
return 0;
}