NOIP模拟：Box（费用流）

题意：
有n个盒子，每个盒子长$l_i$，宽$r_i$，大的盒子可以装一个比他小的盒子（可以不断嵌套，但不能并排装），且这一堆盒子的费用为大的盒子的费用，最小化费用。

题解：费用流。

一开始建图想了半天，一直往最小费用上想，思考怎么把一串盒子串起来。

后来发现这种方法行不通，可以换一种思路：
一个盒子只能选一次，且只能被一个盒子嵌套（总费用会减少较小该盒子的费用），不妨一开始就把所有盒子的费用加上，如果一个盒子能嵌套入另一个盒子那么就把这个盒子的费用减去。

关键的是，嵌套之间其实并无关联。也就是1装2和2装3是独立的（1装不装2都不会影响3装入2这一操作）。

可以看出，一个盒子能取选择嵌套入另一个大盒子，且操作彼此独立，就是一个带权最大匹配问题，可以用费用流解决。

具体实现就是拆点后两边连边匹配。

注意去重。

#include<bits/stdc++.h>
using namespace std;
inline int read(){
    char ch=getchar();int i=0,f=1;
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){i=(i<<1)+(i<<3)+ch-'0';ch=getchar();}
    return i*f;
}
const int Maxn=4e2+50;
const int INF=0x3f3f3f3f;
int n,m,s,des,ans,cur[Maxn],dis[Maxn],walk[Maxn],totarea;
struct Box{int x,y,area;}box[Maxn];
inline bool cmpx(const Box &a,const Box &b){
    if(a.x!=b.x)return a.x<b.x;
    else return a.y<b.y;
}
struct node{int to,cap,rev,cost;};
vector<node>edge[Maxn];
#define in(x) (x<<1)
#define out(x) ((x<<1)-1)
inline void add(int x,int y,int c,int w){
    edge[x].push_back((node){y,c,edge[y].size(),w});
    edge[y].push_back((node){x,0,edge[x].size()-1,-w});
}
inline bool SPFA(){
    static queue<int> q;
    static int exi[Maxn];
    memset(exi,0,sizeof(exi));
    memset(walk,0,sizeof(walk));
    while(!q.empty())q.pop();
    for(int i=0;i<=des;i++)cur[i]=edge[i].size()-1,dis[i]=-INF;
    dis[s]=0;q.push(s);
    while(!q.empty()){
        int u=q.front();q.pop();exi[u]=0;
        for(int e=edge[u].size()-1;e>=0;e--){
            int v=edge[u][e].to,w=edge[u][e].cost;
            if(!edge[u][e].cap)continue;
            if(dis[v]<dis[u]+w){
                dis[v]=dis[u]+w;
                if(!exi[v])q.push(v),exi[v]=1;
            }
        }
    }
    return (dis[des]>-INF);
}
inline int dinic(const int &now,int flow,int cost){
    if(now==des){
        ans+=flow*dis[now];
        return flow;
    }
    walk[now]=1;
    int res=0;
    for(int &e=cur[now];e>=0;e--){
        int v=edge[now][e].to,w=edge[now][e].cost;
        if(!edge[now][e].cap||dis[v]>dis[now]+w||walk[v])continue;
        int o=dinic(v,min(flow-res,edge[now][e].cap),cost+w);
        res+=o;edge[now][e].cap-=o;edge[v][edge[now][e].rev].cap+=o;
        if(res==flow)return res;
    }
    dis[now]=-INF;
    return res;
}
inline void maxflow(){
    static int last[Maxn];
    while(SPFA()){
        memcpy(last,cur,sizeof(cur));
        while(dinic(0,INF,0)){
            memcpy(cur,last,sizeof(last));
            memset(walk,0,sizeof(walk));
        }
    }
}
int main(){
    n=read();des=in(n)+1;
    for(int i=1;i<=n;i++){
        box[i].x=read(),box[i].y=read();
        box[i].area=box[i].x*box[i].y;
        totarea+=box[i].area;
    }
    static int tot=0;
    sort(box+1,box+n+1,cmpx);
    for(int i=1;i<=n;i++){
        (i==1||(box[i].x!=box[i-1].x)||(box[i].y!=box[i-1].y))?(++tot):totarea-=box[i].area;
        box[tot]=box[i];
    }
    n=tot;
    for(int i=1;i<=n;i++)add(s,in(i),1,0),add(out(i),des,1,0);
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            if(i==j)continue;
            if(box[j].x<=box[i].x&&box[j].y<=box[i].y){
                add(in(i),out(j),1,box[j].area);
            }
        }
    }
    printf("%d\n",(maxflow(),totarea-ans));
}