BZOJ 1698 （USACO 2007 Feb）Liypad Pond (黄金)荷叶池塘

[Usaco2007 Feb] Lilypad Pond 荷叶池塘

（点击上方标题跳转至BZOJ 1698） Time Limit: 5 Sec  Memory Limit: 64 MB

Description

为了便于牛们欣赏和锻炼，农夫JOHN在他的农场上新添加了一个美丽的池塘。 JOHN的池塘是一个长方形，他已经把它划分成了M行N列的小正方行 (1 <= M <= 30; 1 <= N <= 30). 某些正方行里是石头，另外一些则是特别结实的荷叶，其余则只有清水。 为了锻炼，Bessie想从一片荷叶跳到另外一片。她的每一次跳跃都是一个象棋中的马步：两行一列或一行两列。 JOHN看到了Bessie并且发现有时Bessie没有办法达到她的目标荷叶。他准备添加一些荷叶来让Bessie完成她的目标。当然，荷叶不能放在石头上。 帮助JOHN找出他最少要放多少片荷叶和他一共有多少种放最少片荷叶的方案。

Input

第1行： 两个整数， M 和 N。

第2~M+1行： 第i+1包含N个数，分别为第i行的N个格子的情况。 0表示格子为空，1表示有一片荷叶，2表示格子里有石头，3表示此格子是Bessie的起点，4 表示此格子是Bessie的目标。

Output

第1行： 一个数，最少情况下需要添加的荷叶数目。如果没有方案存在，输出- 1。

第2行： 一个数，达到最小值的方案总数。这个数保证不超过内设64位整数(long long/ int64)的大小。如果第一行是-1，不要输出此行。

Sample Input

4 5

1 0 0 0 0

3 0 0 0 0

0 0 2 0 0

0 0 0 4 0
输入解释：
池塘含4行5列。Bessie在第2行第1列并且想跳到第4行第4列。池塘里有1块石头和3片荷叶。

Sample Output

2
3
输出解释：
至少需要2片荷叶。一共有三种摆法，如下：
第4行第2列，第2行第3列

1 0 0 0 0

3 0 X 0 0

0 0 2 0 0

0 X 0 4 0

第1行第3列，第3行第2列

1 0 X 0 0

0 3 0 0 0

0 0 X 2 0

0 0 0 0 4

第1行第3列，第2行第5列
1 0 X 0 0

3 0 0 0 X

0 0 2 0 0

0 0 0 4 0

思路：BFS+最短路

leafs[x][y]为到达点（x，y）时需要的最少荷叶数

ans[x][y]为到达点(x，y)且满足最少荷叶数时的不同方案数(必须要用long long)

重点，避免BFS中节点多次入队陷入死循环(此点和它可以扩展的点放置荷叶数相同，会不断互相扩展或形成环)，进行如下处理：

如果map[x1][y1]为0(即此处为空，可以放荷叶)，用 Flood_Fill 来处理数组can[][][][]

can[x1][y1][x2][y2]表示从(x1,y1)是否可到达(y1,y2)

初始化leafs[][]为INF

从起点(stratX,startY)开始，进行BFS每一个点(nowX,nowY),因为有can[][][][]的预处理，所以直接枚举所有的点(x，y)

如果can[nowX][nowY][x][y]==1 ：

1.该点为0(可以放荷叶)，放置荷叶(temp=leafs[nowX][nowY]+1),否则不放置(temp=leafs[nowX][nowY])

2.如果该点(x,y)的leafs[x][y]大于从(nowX,nowY)扩展过来的荷叶数temp，更新leafs[x][y]=temp,ans[x][y]=ans[nowX][nowY]，该点加入BFS的队列；

否则，如果leafs[x][y]==temp，说明这是不同的路线到达(x,y)点，说明方法数可以更新了，即ans[x][y] += ans[nowX][nowY]。

最后，如果leafs[endX][endY]的值仍然为INF，说明无法到达，输出-1；否则，输出leafs[endX][endY]和ans[endX][endY]。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

const int MAXN=30+5;
const int INF=0x3f3f3f3f;
const int dx[8]={1,-1, 1,-1,2,-2, 2,-2};
const int dy[8]={2, 2,-2,-2,1, 1,-1,-1};
int m,n,startX,startY,endX,endY;
int map[MAXN][MAXN];
int leafs[MAXN][MAXN];
long long ans[MAXN][MAXN];
bool can[MAXN][MAXN][MAXN][MAXN];
queue<pair<int,int> > Q;
int temp=0;
        
void floodfill(int x,int y)
{
    bool vis[MAXN][MAXN];
    memset(vis,0,sizeof(vis));
    Q.push(make_pair(x,y));
    while(!Q.empty())
    {
        int nowX=Q.front().first,nowY=Q.front().second;
        Q.pop();
        vis[nowX][nowY]=1;
        for(int k=0;k<8;k++)
        {
            int nx=nowX+dx[k],ny=nowY+dy[k];
            if(nx>=1 && nx<=m && ny>=1 && ny<=n)
                if(!vis[nx][ny])
                {
                    if(map[nx][ny]==1)
                        Q.push(make_pair(nx,ny));
                    else
                        if(map[nx][ny]==0 || (nx==endX && ny==endY))
                            can[x][y][nx][ny]=1;
                }
        }
    }
}

void BFS()
{
    leafs[startX][startY]=0;
    ans[startX][startY]=1;
    Q.push(make_pair(startX,startY));
    while(!Q.empty())
    {
        int nowX=Q.front().first,nowY=Q.front().second;
        Q.pop();
        for(int x=1;x<=m;x++)
            for(int y=1;y<=n;y++)
                if(can[nowX][nowY][x][y])
                {
                    if(map[x][y]==0)
                        temp=leafs[nowX][nowY]+1;
                    else
                        temp=leafs[nowX][nowY];

                    if(leafs[x][y]>temp)
                    {
                        leafs[x][y]=temp;
                        ans[x][y]=ans[nowX][nowY];
                        if(map[x][y]==0)
                            Q.push(make_pair(x,y));
                    }
                    else
                    {
                        if(leafs[x][y]==temp)
                        ans[x][y] += ans[nowX][nowY];
                    }
                }
                
    }
}

int main()
{
    cin>>m>>n;
    for(int x=1;x<=m;x++)
        for(int y=1;y<=n;y++)
        {
            scanf("%d",&map[x][y]);
            if(map[x][y]==3) startX=x,startY=y;
            if(map[x][y]==4) endX=x,endY=y;
        }

    memset(leafs,INF,sizeof(leafs));
    memset(can,0,sizeof(can));
    memset(ans,0,sizeof(ans));
    
    floodfill(startX,startY);
    for(int x=1;x<=m;x++)
        for(int y=1;y<=n;y++)
            if(map[x][y]==0)
                floodfill(x,y);

    BFS();    

    if(leafs[endX][endY]==INF)
        cout<<-1<<endl;
    else
        cout<<leafs[endX][endY]<<endl<<ans[endX][endY]<<endl;
    return 0;
}