洛谷 P1606 [USACO07FEB]荷叶塘Lilypad Pond 解题报告

P1606 [USACO07FEB]荷叶塘Lilypad Pond

题目描述

FJ has installed a beautiful pond for his cows' aesthetic enjoyment and exercise.

The rectangular pond has been partitioned into square cells of M rows and N columns (1 ≤ M ≤ 30; 1 ≤ N ≤ 30). Some of the cells have astonishingly sturdy lilypads; others have rocks; the remainder are just beautiful, cool, blue water.

Bessie is practicing her ballet moves by jumping from one lilypad to another and is currently located at one of the lilypads. She wants to travel to another lilypad in the pond by jumping from one lilypad to another.

Surprising only to the uninitiated, Bessie's jumps between lilypads always appear as a chess-knight's move: one move in one direction and then two more in the orthogonal direction (or perhaps two in one direction and then one in the orthogonal direction).

Farmer John is observing Bessie's ballet drill and realizes that sometimes she might not be able to jump to her destination lilypad because intermediary lilypads are missing.

Ever thrifty, he wants to place additional lilypads so she can complete her quest (perhaps quickly, perhaps by using a large number of intermediate lilypads). Of course, lilypads cannot be placed where rocks already intrude on a cell.

Help Farmer John determine the minimum number of additional lilypads he has to place, and in how many ways he can place that minimum number.

为了让奶牛们娱乐和锻炼，农夫约翰建造了一个美丽的池塘。这个长方形的池子被分成了M行N列个方格（1≤M,N≤30）。一些格子是坚固得令人惊讶的莲花，还有一些格子是岩石，其余的只是美丽、纯净、湛蓝的水。

贝西正在练习芭蕾舞，她站在一朵莲花上，想跳到另一朵莲花上去，她只能从一朵莲花跳到另一朵莲花上，既不能跳到水里，也不能跳到岩石上。

贝西的舞步很像象棋中的马步：每次总是先横向移动一格，再纵向移动两格，或先纵向移动两格，再横向移动一格。最多时，贝西会有八个移动方向可供选择。

约翰一直在观看贝西的芭蕾练习，发现她有时候不能跳到终点，因为中间缺了一些荷叶。于是他想要添加几朵莲花来帮助贝西完成任务。一贯节俭的约翰只想添加最少数量的莲花。当然，莲花不能放在石头上。

请帮助约翰确定必须要添加的莲花的最少数量，以及有多少种放置这些莲花的方法。

输入输出格式

输入格式：

第一行：两个用空格分开的整数：M和N

第二行到M+1行：第i+1行有N个用空格分开的整数，描述了池塘第i行的状态：

0为水，1为莲花，2为岩石，3为贝西所在的起点，4为贝西想去的终点。

输出格式：

第一行：一个整数，需要增加的最少莲花数；如果无解，输出-1。

第二行：放置这些莲花的方案数量，保证这个数字不会超过一个64位的有符号整数，

如果第一行是-1，不要输出第二行。

---

很不错的题目

第一问很容易，每个点向8个方向连边遇到石头连无穷，水连1，叶子连0就可以了，然后直接跑最短路

第二问想到最短路计数，但是有0权边是没法最短路计数的

发现0权边都是叶子贡献的

我们可以先把叶子的边拿bfs跑出来连好，然后就只剩1的边啦，直接跑最短路计数

---

Code:

#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
using namespace std;
const int N=920;
const int M=200000;
const int inf=0x3f3f3f3f;
int head[N],to[M],Next[M],edge[M],cnt;
void add(int u,int v,int w)
{
    to[++cnt]=v,Next[cnt]=head[u],edge[cnt]=w,head[u]=cnt;
}
int n,m,s,t,cost[N];
int cal(int i,int j)
{
    return (i-1)*m+j;
}
const int dx[9]={0,-2,-1,1,2,2,1,-1,-2};
const int dy[9]={0,1,2,2,1,-1,-2,-2,-1};
#define P pair <int,int >
int used[N];
void bfs(int x,int y)
{
    queue <P> q;
    q.push(make_pair(x,y));
    int u=cal(x,y);
    memset(used,0,sizeof(used));
    used[u]=1;
    while(!q.empty())
    {
        int i=q.front().first,j=q.front().second;
        q.pop();
        for(int k=1;k<=8;k++)
        {
            int ti=dx[k]+i,tj=dy[k]+j;
            if(ti>0&&tj>0&&ti<=n&&tj<=m)
            {
                int v=cal(ti,tj);
                if(used[v]) continue;
                used[v]=1;
                if(cost[v]==1)
                    add(u,v,1);//连边边
                else if(!cost[v])//走花花
                    q.push(make_pair(ti,tj));
            }
        }
    }
}
void init()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        {
            int id=cal(i,j);
            scanf("%d",cost+id);
            if(cost[id]==0||cost[id]==1) cost[id]^=1;
            else if(cost[id]==2) cost[id]=inf;
            else if(cost[id]==3) s=id,cost[id]=1;//特判
            else if(cost[id]==4) t=id,cost[id]=1;
        }
    //0花 1水 2石头
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            if(cost[cal(i,j)]==1)
                bfs(i,j);
}
#define ll long long
int dis[N];ll ans[N];
struct node
{
    int id,w;
    node(){}
    node(int id,int w){this->id=id,this->w=w;}
    bool friend operator <(node n1,node n2){return n1.w>n2.w;}
};
std::priority_queue <node> q;
void disj()
{
    memset(dis,0x3f,sizeof(dis));
    memset(used,0,sizeof(used));
    dis[s]=0;
    ans[s]=1;
    node t(s,0);
    q.push(t);
    while(!q.empty())
    {
        int u=q.top().id;
        q.pop();
        if(used[u]) continue;
        used[u]=1;
        for(int i=head[u];i;i=Next[i])
        {
            int v=to[i];
            if(dis[v]>dis[u]+edge[i])
            {
                dis[v]=dis[u]+edge[i];
                ans[v]=ans[u];
                t=node(v,dis[v]);
                q.push(t);
            }
            else if(dis[v]==dis[u]+edge[i])
                ans[v]+=ans[u];
        }
    }
}
int main()
{
    init();
    disj();
    if(dis[t]==inf) printf("-1\n");
    else printf("%d\n%lld\n",dis[t]-1,ans[t]);
    return 0;
}

---

2018.9.5