【BZOJ-4213】贪吃蛇有上下界的费用流

4213: 贪吃蛇

Time Limit: 5 Sec Memory Limit: 64 MB
Submit: 58 Solved: 24
[Submit][Status][Discuss]

Description

最近lwher迷上了贪吃蛇游戏，在玩了几天却从未占满全地图的情况下，他不得不承认自己是一个弱菜，只能改去开发一款更弱的贪吃蛇游戏。

在开发的过程中，lwher脑洞大开，搞了一个多条蛇的模式。但由于这种模式太难操作，于是他只好改变游戏的玩法，稍微变化一下游戏目标。

新的游戏是这样的：

一些蛇覆盖了一个网格。每个格子要么是一个障碍物，要么是蛇的一部分。每条蛇占据了一条折线(拐角处只能水平和竖直连接)，且只是占据两个格子。蛇与蛇之间不能重叠，蛇也不会与自己重叠。每条蛇还必须满足以下两个条件中的一个：

1、两个端点所在的格子在网格的边界。

2、蛇构成一个环，即两个端点相邻(垂直或水平，不能斜着)，至少要占据4个格子(否则没法形成环)。

给定一个网格，用r x c的字符矩阵描述：‘#’代表障碍物，‘.’代表空地。在满足前面所述的条件下覆盖所有空地，并使得端点在网格边界(即不构成环)的蛇尽量少。（如果一条蛇既构成环，又是端点在边界，那么不计入答案）

例如，以下网格：

可以由下面三种方案覆盖。还有其他的方案，但是没法仅用一条不构成环的蛇就覆盖整个网络的方案。

给定一个网络的描述，输出最少需要多少条不构成环的蛇来覆盖这个网格。如果不存在能够覆盖网格的方案，输出-1。

Input

一个字符矩阵，行数和列数不超过12。输入文件中没有多余的空白字符，每行之后都有换行符。

Output

输出满足题目要求的那个整数。

Sample Input

......
.#.##.
.#....
....#.
.##.#.
......

Sample Output

HINT

Source

Solution

感觉是插头DP或者费用流...立马把插头DP否了

网格基本上得先黑白染色

感觉环状蛇中每个点一定与两个点相连，非环蛇只有头尾不合两个点相连，所以实际上要算的就是和一个点相连的

S-->白点，容量2 ：上下界都是2 费用为0

黑点-->T，容量2：上下界都是2 费用同样为0

表示这个点需要和别的两个点相连

然后白点向四周黑点扩展出一条边容量为1 费用为0

这样就是环状蛇的建图（显然环蛇不计入答案，所以费用全部置成0）

然后特判边界情况，边界上的白点-->T 费用1 容量1 表示非环蛇的情况

然后跑上下界最小费用流，ans/2即为答案，因为非环蛇的头尾都被累计，相当于1条蛇贡献2，所以除二即可

上下界最小费用流？理论什么的忘记了。。。

实现起来就是用超级源汇替代原来的源汇，再由次级汇连次级源INF，然后跑超级源汇之间的费用流

无解按照特有判定，S出来的边应该全都满流，否则无解

Code

#include<iostream>

#include<algorithm>

#include<cmath>

#include<cstring>

#include<cstdio>

#include<queue>

using namespace std;

inline int read()

{

    int x=,f=; char ch=getchar();

    while (ch<'' || ch>'') {if (ch=='-') f=-; ch=getchar();}

    while (ch>='' && ch<='') {x=x*+ch-''; ch=getchar();}

    return x*f;

}

#define MAXM 100010

#define MAXN 10010

int N,M,cas;

#define mN 15

#define mM 15

char G[mN][mM];

struct EdgeNode{int next,to,cap,cost;}edge[MAXM];

int head[MAXN],cnt=;

inline void AddEdge(int u,int v,int w,int c) {cnt++; edge[cnt].next=head[u]; head[u]=cnt; edge[cnt].to=v; edge[cnt].cap=w; edge[cnt].cost=c;}

inline void InsertEdge(int u,int v,int w,int c) {AddEdge(u,v,w,c); AddEdge(v,u,,-c);}

int dis[MAXN],S,T,s,t,MinCost; bool mark[MAXN];

#define INF 0x7fffffff

bool spfa()

{

    queue<int>q; memset(mark,,sizeof(mark));

    for (int i=S; i<=T; i++) dis[i]=INF;

    q.push(T); dis[T]=; mark[T]=;

    while (!q.empty())

        {

            int now=q.front(); q.pop(); mark[now]=;

            for (int i=head[now]; i; i=edge[i].next)

                if (edge[i^].cap && dis[edge[i].to]>dis[now]+edge[i^].cost)

                    {

                        dis[edge[i].to]=dis[now]+edge[i^].cost;

                        if (!mark[edge[i].to])

                            q.push(edge[i].to),mark[edge[i].to]=;

                    }

        }

    return dis[S]!=INF;

}

int dfs(int loc,int low)

{

    mark[loc]=;

    if (loc==T) return low;

    int w,used=;

    for (int i=head[loc]; i; i=edge[i].next)

        if (edge[i].cap && !mark[edge[i].to] && dis[edge[i].to]==dis[loc]-edge[i].cost)

            {

                w=dfs(edge[i].to,min(low-used,edge[i].cap));

                edge[i].cap-=w; edge[i^].cap+=w; used+=w; MinCost+=w*edge[i].cost;

                if (used==low) return low;

            }

    return used;

}

int zkw()

{

    int tmp=;

    while (spfa())

        {

            mark[T]=;

            while (mark[T])

                memset(mark,,sizeof(mark)),tmp+=dfs(S,INF);

        }

    return tmp;

}

bool Judge() {bool f=; for (int i=head[S]; i; i=edge[i].next) if (edge[i].cap) {f=;break;} return !f;}

inline bool Check(int x,int y) {if (x>= && x<=N && y>= && y<=M && G[x][y]!='#') return ; return ;}

int D[mN*mM],id[mN][mM],col[mN][mM];

void BuildGraph()

{

    S=; T=N*M+; s=N*M+; t=N*M+; int idd=;

    for (int i=; i<=N; i++)

        for (int j=; j<=M; j++)

            id[i][j]=++idd,col[i][j]=(i+j)&;

    for (int i=; i<=N; i++)

        for (int j=; j<=M; j++)

            if (col[i][j])

                if (Check(i,j)) D[s]-=,D[id[i][j]]+=; else;

            else

                if (Check(i,j)) D[id[i][j]]-=,D[t]+=; else;

    for (int i=; i<=N; i++)

        for (int j=; j<=M; j++)

            if (col[i][j] && Check(i,j))

                {

                    if (Check(i-,j)) InsertEdge(id[i][j],id[i-][j],,);

                    if (Check(i,j-)) InsertEdge(id[i][j],id[i][j-],,);

                    if (Check(i+,j)) InsertEdge(id[i][j],id[i+][j],,);

                    if (Check(i,j+)) InsertEdge(id[i][j],id[i][j+],,);

                }

    for (int i=; i<=N; i++)

        for (int j=; j<=M; j++)

            if (i== || i==N || j== || j==M)

                if (col[i][j])

                    if (Check(i,j)) InsertEdge(id[i][j],t,,); else;

                else

                    if (Check(i,j)) InsertEdge(s,id[i][j],,); else;

    for (int i=; i<=t; i++)

        if (D[i]>) InsertEdge(S,i,D[i],);

            else

        if (D[i]<) InsertEdge(i,T,-D[i],);

    InsertEdge(t,s,INF,);

}

int tp;

int main()

{

    tp=; while (scanf("%s",G[tp]+)!=EOF) tp++;

    N=tp-,M=strlen(G[]+);

    BuildGraph();

    zkw();

    if (Judge()) {puts("-1"); return ;}

    printf("%d\n",MinCost>>);

    return ;

}

什么垃圾读入方式，恶心！