【USACO】2007 Feb Silver Lilypad Pond 白银莲花池

6 篇文章 0 订阅
3 篇文章 0 订阅

Silver Lilypad Pond 白银莲花池


  • Description

为了让奶牛们娱乐和锻炼,约翰建造了一个美丽的池塘。这个池塘是矩形的,可以分成 M×N个方格。一些格子是坚固得令人惊讶的莲花,还有一些是岩石,其余的只是美丽、纯净、湛蓝的水。
贝西正在练习芭蕾舞,她站在一朵莲花上,想跳到另一朵莲花上去,她只能从一朵莲花跳到另一朵莲花上,既不能跳到水里,也不能跳到岩石上。
贝西的舞步很像象棋中的马步:每次跳跃可以横移2格,纵移1格,或纵移1格,横移2格,最多有八个方向可供移动选择。
约翰一直在观察贝西的芭蕾练习,发现她有时不能跳到终点,因为中间缺了一些必要的莲花。约翰可以多种一些莲花来帮助贝西到达终点。不过要注意有石头的格子是不能种莲花的。
请帮助约翰求出至少要添加几朵莲花才能让贝西跳到终点,记这个数字为L,再求出添加L朵莲花后贝西跳到终点的最少步数,记这个数字为J。最后求出添加L朵莲花后跳到终点 的步数为J的路线有多少条,记这个数字为W。

  • Input Format

第一行:两个用空格分开的整数:M和N,1≤M,N≤30
第二行到M+1行:第i +1行有N个用空格分开的整数,描述了池塘第i行的状态:0为 水,1为莲花,2为岩石,3为起点,4为终点。

  • Output Format

第一行:一个整数:L,即需要添加的最少莲花数目,如果无解输出-1
第二行:一个整数:J,如果第一行是-1,不需要输出这行
第三行:一个整数:W,如果第一行是-1,不需要输出这行

  • Sample Input

4 8
0 0 0 1 0 0 0 0
0 0 0 0 0 2 0 1
0 0 0 0 0 4 0 0
3 0 0 0 0 0 1 0

  • Sample Output

2
6
2


  • 分析

首先想到的肯定是深搜的做法。(可能只是我这个辣鸡才会第一眼想到的)然而无奈的是会TLE,经本人测试越70%左右。
下面讲讲广搜的做法,(根本就是个Spfa)。
对于一个点(x,y),记录到达它的L、J、W。然后类似于Spfa的松弛操作,向外找点,然后如果这个点的L、J刚好等于从(x,y)出发所得到的L、J,那就把这个点的W加上(x,y)的W,否则就更新这个点的L、J、W。每次更新后如果不在队列中就把它入队去更新别的点。其实就是Spfa的思想。(详见代码)
Ps:对了还有一个比较坑的地方,最后的W可能会超出int范围。


  • 70%
#include <queue>
#include <stack>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int movex[8]={2,2,1,1,-1,-1,-2,-2},movey[8]={-1,1,-2,2,-2,2,-1,1};
int L=1<<30,J=1<<30,W,n,m,sx,sy,ex,ey,A[31][31],P[31][31];
void Dfs(int x,int y,int cnt,int tmp){
    if (cnt>L) return;
    if (cnt==L && tmp>J) return;
    if (x==ex && y==ey){
        if (cnt==L){
            if (tmp==J) W++;
            else if (tmp<J) J=tmp,W=1;
        }
        else if (cnt<L) L=cnt,J=tmp,W=1;
        return;
    }
    for (int i=0;i<8;i++){
        int xx=x+movex[i],yy=y+movey[i];
        if (xx>=1 && xx<=n && yy>=1 && yy<=m && A[xx][yy]!=2 && P[xx][yy]==0){
            if (A[xx][yy]==1){
                P[xx][yy]=1;
                Dfs(xx,yy,cnt,tmp+1);
                P[xx][yy]=0;
            }
            if (A[xx][yy]==0){
                P[xx][yy]=1;
                Dfs(xx,yy,cnt+1,tmp+1);
                P[xx][yy]=0;
            }
        }
    }
}
int main(){
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;i++){
        for (int j=1;j<=m;j++){
            scanf("%d",&A[i][j]);
            if (A[i][j]==3) sx=i,sy=j,A[i][j]=1;
            if (A[i][j]==4) ex=i,ey=j,A[i][j]=1;
        }
    }
    P[sx][sy]=1;
    Dfs(sx,sy,0,0);
    if (L==1<<30) printf("-1");
    else printf("%d\n%d\n%d",L,J,W);
    fclose(stdin); fclose(stdout);
    return 0;
}
  • 100%
#include <queue>
#include <stack>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
struct Data{int x,y;};
queue <Data> Q;
struct Info{int L,J;long long W;}Dist[31][31]; 
const int movex[8]={2,2,1,1,-1,-1,-2,-2},movey[8]={-1,1,-2,2,-2,2,-1,1};
int L=1<<30,J=1<<30,W,n,m,sx,sy,ex,ey,A[31][31],In[31][31];
int main(){
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);  
    scanf("%d%d",&n,&m);
    memset(Dist,127/2,sizeof(Dist));
    for (int i=1;i<=n;i++){
        for (int j=1;j<=m;j++){
            scanf("%d",&A[i][j]);
            if (A[i][j]==3) sx=i,sy=j,A[i][j]=1;
            if (A[i][j]==4) ex=i,ey=j,A[i][j]=1;
        }
    }
    Q.push((Data){sx,sy}); Dist[sx][sy]=(Info){0,0,1}; In[sx][sy]=1;
    for (;!Q.empty();){
        Data u=Q.front(); Q.pop(); In[u.x][u.y]=0;
        for (int i=0;i<8;i++){
            int xx=u.x+movex[i],yy=u.y+movey[i];
            if (xx>=1 && xx<=n && yy>=1 && yy<=m && A[xx][yy]!=2){
                if (Dist[xx][yy].L==Dist[u.x][u.y].L+1-A[xx][yy] && Dist[xx][yy].J==Dist[u.x][u.y].J+1){
                    Dist[xx][yy].W+=Dist[u.x][u.y].W;
                    if (!In[xx][yy]) In[xx][yy]=1,Q.push((Data){xx,yy});
                }
                if (Dist[xx][yy].L>Dist[u.x][u.y].L+1-A[xx][yy] || (Dist[xx][yy].L+1-A[xx][yy]==Dist[u.x][u.y].L && Dist[xx][yy].J>Dist[u.x][u.y].J+1)){
                    Dist[xx][yy].L=Dist[u.x][u.y].L+1-A[xx][yy];
                    Dist[xx][yy].J=Dist[u.x][u.y].J+1;
                    Dist[xx][yy].W=Dist[u.x][u.y].W;
                    if (!In[xx][yy]) In[xx][yy]=1,Q.push((Data){xx,yy});
                }
            }
        }
    }
    if (Dist[ex][ey].L>1e9) printf("-1");
    else printf("%d\n%d\n%lld",Dist[ex][ey].L,Dist[ex][ey].J,Dist[ex][ey].W);
    fclose(stdin); fclose(stdout);
    return 0;
}
### 回答1: 题目描述 有N头奶牛,它们在M个牛棚之间相互转移。每个牛棚里有一些奶牛,每分钟可以容纳一头奶牛。一头奶牛从一个牛棚走到另一个牛棚需要一分钟的时间。现在,这些奶牛要开一个牛派对,它们要在同一时间到达同一个牛棚,所以它们需要在某个牛棚等待一段时间。你需要计算最小的等待时间,使得所有奶牛都能够在同一时间到达同一个牛棚。 输入格式 第一行包含三个整数N,M,X。 接下来M行,每行包含三个整数a,b,t,表示牛棚a和牛棚b之间有一条双向边,需要t分钟才能通过。 输出格式 输出一个整数,表示最小等待时间。 数据范围 1≤N≤500 1≤M≤10000 1≤X≤N 1≤a,b≤N 1≤t≤1000 输入样例#1 3 3 1 1 2 5 2 3 5 1 3 10 输出样例#1 5 输入样例#2 4 5 4 1 2 10 2 3 10 3 4 10 4 1 10 1 3 20 输出样例#2 30 算法1 (最短路) $O(N^3)$ Dijkstra算法 Dijkstra(迪杰斯特拉)算法是由荷兰计算机科学家狄克斯特拉于1956年发明的,因此又叫狄克斯特拉算法。 Dijkstra算法是一种贪心算法,用于求解一个节点到其他所有节点的最短路径。它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想),直到扩展到终点为止。 具体做法是:设立一个数组dis来保存源点到各个顶点的最短距离和一个数组book[i]来记录一个顶点是否已经在队列中。 初始时,原点s的路径权重被赋为0 (dis[s] = 0)。若对于顶点s存在能直接到达的边(s,m),则把dis[m]设为w(s, m),同时把所有其他(s不能直接到达的)顶点的路径长度设为无穷大。初始时,所有顶点并不属于任何已知最短路径所包含的顶点集合,因此都被标记为未知最短路径长度。当算法结束时,dis[v]中存储的便是源点s到顶点v的最短路径,或者如果从s无法到达v,则值为INF。 Dijkstra算法流程: 算法流程: 1. 将所有顶点分为两部分:已知最短路的顶点集合P和未知最短路的顶点集合Q。 2. 初始时,顶点集合P中只有源点s一个元素,以源点s为起点向外扩展。 3. 每次从顶点集合Q中选取一个顶点u(u的dist最小),并加入到顶点集合P中,同时以u为中心进行扩展。 4. 重复步骤3,直到顶点集合Q为空或者终点被加入到顶点集合P中。 5. 算法结束,最短路径保存在dis数组中。 时间复杂度 Dijkstra算法的时间复杂度为O(N^2)。由于N较小,因此可以通过本题。 参考文献 Dijkstra算法讲解 C++ 代码 算法2 (最短路) $O(N^2)$ Floyd算法 Floyd算法又称为插点法,是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法,与Dijkstra算法类似。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名。 Floyd算法的基本思想 设G=(V,E)是一个带权有向图,其邻接矩阵为W。V={v1,v2,……,vn},W[1:n,1:n],则该图的Floyd算法可描述如下: 时间复杂度 Floyd算法的时间复杂度为O(N^3)。由于N较小,因此可以通过本题。 参考文献 Floyd算法讲解 C++ 代码 算法3 (最短路) $O(N^2)$ Bellman-Ford算法 Bellman-Ford算法是一种单源最短路径算法,可以处理负权边,但不能处理负权回路。 Bellman-Ford算法的基本思想 对于图中的任意一条边(u, v),Bellman-Ford算法会对每一条边进行一次松弛操作(Relax),并且这些操作是按照顺序进行的:当算法进行第i次松弛操作时,它只会改变长度为i+1的路径上的顶点的值。因此,当算法执行完第n-1次松弛操作后,路径长度最长不超过n-1,此时所有最短路径都已经求出。 时间复杂度 Bellman-Ford算法的时间复杂度为O(N*M)。由于N和M的范围较小,因此可以通过本题。 参考文献 Bellman-Ford算法讲解 C++ 代码 ### 回答2: Usaco 2007 Feb的问题是关于Cow Party的。这个问题中,农夫约翰有N头奶牛,它们之间通过一些路径相互连接,并且每个路径都有一个长度。约翰想要在某个时间将它的所有奶牛聚集在一起举办一个派对,现在他想知道所有奶牛从各自的位置到达聚会地点所需的最短时间。 为了解决这个问题,我们可以使用Dijkstra算法。我们首先需要创建一个节点集合,包含所有的奶牛和派对地点,并且初始化每个节点的最短时间为无穷大。接下来,我们选取一个起点节点--聚会地点,并将它的最短时间设置为0。然后我们开始遍历所有的节点,每次选择一个最短时间未确定的节点,并更新它的邻居节点的最短时间。我们重复这个过程,直到所有节点的最短时间都确定。 在更新节点的最短时间时,我们需要根据节点之间的路径长度来更新。我们检查从当前节点到邻居节点的路径长度加上当前节点的最短时间是否小于邻居节点目前的最短时间。如果是,则更新邻居节点的最短时间为新的最短时间。 最后,我们可以得到所有奶牛到达聚会地点所需的最短时间。我们找到所有奶牛起始位置的最长最短时间,即为我们的答案。 通过使用Dijkstra算法,我们可以解决这个问题并得到最优解。因此,Usaco 2007 Feb的Cow Party问题可以通过这种方法解决。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值