BZOJ 1930: [Shoi2003]pacman 吃豆豆 最大费用最大流

title

BZOJ 1930
LUOGU 4066
Description

两个PACMAN吃豆豆。一开始的时候，PACMAN都在坐标原点的左下方，豆豆都在右上方。PACMAN走到豆豆处就会吃掉它。PACMAN行走的路线很奇怪，只能向右走或者向上走，他们行走的路线不可以相交。 请你帮这两个PACMAN计算一下，他们俩加起来最多能吃掉多少豆豆。

Input

第一行为一个整数N，表示豆豆的数目。 接下来 N 行，每行一对正整数，表示第i个豆豆的坐标。任意两个豆豆的坐标都不会重合。

Output

仅有一行包含一个整数，即两个PACMAN加起来最多能吃掉的豆豆数量

Sample Input

8
8 1
1 5
5 7
2 2
7 8
4 6
3 3
6 4

Sample Output

7

HINT

N < = 2000

analysis

第一眼，费用流版的传纸条，不过要求路线不能相交，但其实是无所谓的，我们可以把相交的两条路线转化成不相交的两条路线（当然，在交点处就没有那么多讲究了。）

建图：

1. 每个点拆成两个，之间连一条流量为 1，费用为 1 的边；
2. 如果从 \(a\) 出发可以到达 \(b\) ，就将 \(a\) 的出点连向 \(b\) 的入点；
3. 跑费用流，但是，很明显，点过多，容易 \(TLE\)。
4. 于是，我们来考虑剪枝（不知道把这个词语用到这里好不好，网上都是这么说的，┐(‘～`；)┌ ）：如果 \(a\) 能到 \(b\)， \(b\) 能到 \(c\)，显然 \(a\) 到 \(c\) 就不用再连边了；
5. 只这样的话，是不行的，因为一个点是可能多次经过的，所以还要把一个点拆点后的两个点之间连一条流量为 1，费用为 0 的边；
6. 这样就好了。

code

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e5+10,maxm=1e6+10,inf=0xcfcfcfcf,INF=0x3f3f3f3f;
 
char buf[1<<15],*fs,*ft;
inline char getc() { return (ft==fs&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),ft==fs))?0:*fs++; }
template<typename T>inline void read(T &x)
{
    x=0;
    T f=1, ch=getchar();
    while (!isdigit(ch) && ch^'-') ch=getchar();
    if (ch=='-') f=-1, ch=getchar();
    while (isdigit(ch)) x=(x<<1)+(x<<3)+(ch^48), ch=getchar();
    x*=f; 
}
 
template<typename T>inline void write(T x)
{
    if (!x) { putchar('0'); return ; }
    if (x<0) putchar('-'), x=-x;
    T num=0, ch[20];
    while (x) ch[++num]=x%10+48, x/=10;
    while (num) putchar(ch[num--]);
}
 
int ver[maxm<<1],edge[maxm<<1],Next[maxm<<1],cost[maxm<<1],head[maxn],len=1;
inline void add(int x,int y,int z,int c)
{
    ver[++len]=y,edge[len]=z,cost[len]=c,Next[len]=head[x],head[x]=len;
    ver[++len]=x,edge[len]=0,cost[len]=-c,Next[len]=head[y],head[y]=len;
}
 
int s,t,ss,tt;
int dist[maxn],incf[maxn],pre[maxn];
bool vis[maxn];
inline bool spfa()
{
    memset(dist,0xcf,sizeof(dist));
    memset(vis,0,sizeof(vis));
    queue<int>q;q.push(s);
    dist[s]=0,vis[s]=1,incf[s]=1<<30;
    while (!q.empty())
    {
        int x=q.front();
        q.pop();
        vis[x]=0;
        for (int i=head[x]; i; i=Next[i])
        {
            if (!edge[i]) continue;
            int y=ver[i];
            if (dist[y]<dist[x]+cost[i])
            {
                dist[y]=dist[x]+cost[i];
                incf[y]=min(incf[x],edge[i]);
                pre[y]=i;
                if (!vis[y]) q.push(y),vis[y]=1;
            }
        }
    }
    if (dist[t]==inf) return false;
    else return true;
}
 
long long maxflow,ans;
inline void update()
{
    int x=t;
    while (x!=s)
    {
        int i=pre[x];
        edge[i]-=incf[t];
        edge[i^1]+=incf[t];
        x=ver[i^1];
    }
    maxflow+=incf[t];
    ans+=dist[t]*incf[t];
}
 
struct Orz{int x,y;}o[maxn];
inline bool cmp(Orz a,Orz b)
{
    return a.x<b.x || (a.x==b.x&&a.y<b.y);
}
 
int main()
{
    int n;read(n);
    s=0,t=n<<1|1;
    ss=t+1,tt=ss+1;
    for (int i=1; i<=n; ++i)
    {
        read(o[i].x),read(o[i].y);
        add(ss,i,1,0),add(i,i+n,1,1);//只有第一次经过才能拿到价值
        add(i,i+n,1,0),add(i+n,t,1,0);
    }
    sort(o+1,o+n+1,cmp);
    add(s,ss,2,0),add(t,tt,2,0);//此处容量为2，限制最多两条路线
    for (int i=1; i<=n; ++i)
    {
        int limy=INF;
        for (int j=i+1; j<=n; ++j)
        {
            if (o[j].y<limy && o[j].y>=o[i].y) add(i+n,j,2,0);
            if (o[j].y>=o[i].y) limy=min(limy,o[j].y);//更低则必须加边
        }
    }
    while (spfa()) update();
    write(ans),puts("");
    return 0;
}

转载于:https://www.cnblogs.com/G-hsm/p/11323283.html