NOIP模拟（10.19）T3 放盒子

放盒子

题目背景：

10.19 NOIP模拟T3

分析：费用流

这个题，我是真的没有往费用流想······

考场上还出了点问题，明明应该写双关键字排序的····然后我只排了一个关键词····明明有50分的暴力的，挂成了15分······悲剧，下次一定要注意，怎么错都轻松过样例······

这个题，考虑怎么办，显然我们对于每一个盒子要看第一，是否有盒子可以装他，第二，是否可以装下其他盒子，第三，装哪一个盒子，第四，哪一个盒子装它，每一个盒子只能用一次，有没有感觉到什么2333，我们对于每个盒子拆成两个点，为x1,
x2,如果对于两个盒子，x, y, x可以装下y盒子，那么我们从x1向y2连边，流量为1，费用为y盒子的面积（注意是y，就是y），然后从S向所有的第一部分点连边，流量为1，费用为0，从所有第二部分点向T连边，流量为1，费用为0，然后跑一遍最大费用最大流，用总的盒子的面积减去最大费用即可，流量限制满足每个盒子只用一次，选中了的盒子表示它可以被套住，减去费用，正确性合理。

Source：

/*
created by scarlyw
*/
#include <iostream>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#include <cstdio>
#include <cctype>
#include <vector>
#include <queue>
#include <map>
#include <set>

inline char read() {
static const int IN_LEN = 1024 * 1024;
static char buf[IN_LEN], *s, *t;
if (s == t) {
t = (s = buf) + fread(buf, 1, IN_LEN, stdin);
if (s == t) return -1;
}
return *s++;
}

/*
template<class T>
inline void R(T &x) {
static bool iosig;
static char c;
for (iosig = false, c = read(); !isdigit(c); c = read()) {
if (c == -1) return ;
if (c == '-') iosig = true;
}
for (x = 0; isdigit(c); c = read()) x = ((x << 2) + x << 1);
if (iosig) x = -x;
}
//*/

const int OUT_LEN = 1024 * 1024;
char obuf[OUT_LEN], *oh = obuf;
inline void write_char(char c) {
if (oh == obuf + OUT_LEN) fwrite(obuf, 1, OUT_LEN, stdout), oh = obuf;
*oh++ = c;
}

template<class T>
inline void W(T x) {
static int buf[30], cnt;
if (x == 0) write_char('0');
else {
if (x < 0) write_char('-'), x = -x;
for (cnt = 0; x; x /= 10) buf[++cnt] = x % 10 + 48;
while (cnt) write_char(buf[cnt--]);
}
}

inline void flush() {
fwrite(obuf, 1, oh - obuf, stdout);
}

///*
template<class T>
inline void R(T &x) {
static bool iosig;
static char c;
for (iosig = false, c = getchar(); !isdigit(c); c = getchar()) {
if (c == -1) return ;
if (c == '-') iosig = true;
}
for (x = 0; isdigit(c); c = getchar()) x = ((x << 2) + x << 1) + (c ^ '0');
if (iosig) x = -x;
}
//*/

const int MAXN = 400 + 10;
const int INF = ~0u >> 2;

int n, final = ~0u >> 1;

struct data {
int l, w;
inline bool operator < (const data &a) const {
return (l == a.l) ? (w < a.w) : (l < a.l);
}
} box[MAXN];

struct node {
int to, w, c, rev;
node(int to = 0, int w = 0, int c = 0, int rev = 0) : to(to), w(w), c(c),
rev(rev) {}
} ;

bool vis[MAXN];

int ans, s ,t, cnt, sum;
std::vector<node> edge[MAXN];

inline void add_edge(int x, int y, int w, int c) {
edge[x].push_back(node(y, w, c, edge[y].size()));
edge[y].push_back(node(x, 0, -c, edge[x].size() - 1));
}

inline void build_graph() {
R(n), cnt = 0;
for (int i = 1; i <= n; ++i) R(box[i].l), R(box[i].w);
std::sort(box + 1, box + n + 1);
for (int i = 1; i <= n; ++i)
if (box[i].l != box[i - 1].l || box[i].w != box[i - 1].w)
box[++cnt] = box[i], ans += box[i].l * box[i].w;
s = 0, t = 2 * cnt + 1;
for (int i = 1; i <= cnt; ++i)
for (int j = 1; j < i; ++j)
if (box[j].w <= box[i].w)
add_edge(i, j + cnt, 1, box[j].l * box[j].w);
for (int i = 1; i <= cnt; ++i)
add_edge(s, i, 1, 0), add_edge(i + cnt, t, 1, 0);
}

inline bool spfa_slf(int s, int t) {
static bool vis[MAXN];
static int dis[MAXN];
static std::deque<int> q;
for (int i = s; i <= t; ++i) vis[i] = false, dis[i] = -INF;
q.push_back(t), dis[t] = 0, vis[t] = true;
while (!q.empty()) {
int cur = q.front();
q.pop_front(), vis[cur] = false;
for (int p = 0; p < edge[cur].size(); ++p) {
node *e = &edge[cur][p];
if (edge[e->to][e->rev].w > 0 && dis[e->to] < dis[cur] - e->c) {
dis[e->to] = dis[cur] - e->c;
if (!vis[e->to]) {
if (!q.empty() && dis[e->to] > dis[q.front()])
q.push_front(e->to), vis[e->to] = true;
else q.push_back(e->to), vis[e->to] = true;
}
}
}
}
for (int i = s; i <= t; ++i)
for (int p = 0; p < edge[i].size(); ++p) {
node *e = &edge[i][p];
e->c += dis[e->to] - dis[i];
}
return sum += dis[s], (dis[s] > -INF);
}

inline int dfs(int cur, int flow, int t) {
if (cur == t) return ans -= sum * flow, flow;
int ret = 0;
vis[cur] = true;
for (int p = 0; p < edge[cur].size(); ++p) {
node *e = &edge[cur][p];
if (e->w > 0 && e->c == 0 && !vis[e->to]) {
int f = dfs(e->to, std::min(flow - ret, e->w), t);
ret += f, e->w -= f, edge[e->to][e->rev].w += f;
if (ret == flow) return flow;
}
}
return ret;
}

inline void cost_flow(int s, int t) {
while (spfa_slf(s, t)) {
do memset(vis, false, sizeof(bool) * (t + 5));
while (dfs(s, INF, t));
}
std::cout << ans;
}

int main() {
// freopen("box.in", "r", stdin);
// freopen("box.out", "w", stdout);
build_graph();
cost_flow(s, t);
return 0;
}