动态规划--青蛙跳

Description
在河上有一座独木桥,一只青蛙想沿着独木桥从河的一侧跳到另一侧。在桥上有一些石子,青蛙很讨厌踩在这些石子上。由于桥的长度和青蛙一次跳过的距离都是正整数,我们可以把独木桥上青蛙可能到达的点看成数轴上的一串整点:0,1,……,L(其中L是桥的长度)。坐标为0的点表示桥的起点,坐标为L的点表示桥的终点。青蛙从桥的起点开始,不停的向终点方向跳跃。一次跳跃的距离是s到t之间的任意正整数(包括s,t)。当青蛙跳到或跳过坐标为L的点时,就算青蛙已经跳出了独木桥。

题目给出独木桥的长度L,青蛙跳跃的距离范围s,t,桥上石子的位置。你的任务是确定青蛙要想过河,最少需要踩到的石子数。

Input
有多组测试数据。
对于每组测试数据,第一行四个正整数L, s, t, n(1 <= L <= 10^5, 1 <= s <= t <= 10,1 <= n <= 100),分别表示独木桥的长度,青蛙一次跳跃的最小距离,最大距离,及桥上石子的个数。第二行有n个不同的正整数分别表示这n个石子在数轴上的位置(数据保证桥的起点和终点处没有石子)。所有相邻的整数之间用一个空格隔开。
Output
每组测试数据仅输出一行,包括一个整数,表示青蛙过河最少需要踩到的石子数。
Sample Input
10 2 3 5
2 3 5 6 7
Sample Output

2

#include<stdio.h>
#include<string.h>
const int MAXN=100020;
int flag[MAXN];
int dp[MAXN];
int main()
{
    int L,s,t,n;
    int a;
    while(scanf("%d%d%d%d",&L,&s,&t,&n)!=EOF)
    {
        memset(flag,0,sizeof(flag));
        memset(dp,-1,sizeof(dp));//初始化,-1为不能到达的
        //dp[i]表示到第 i  点需要经过的最少石子数,-1表示不能到达
        for(int i=0;i<n;i++)
        {
            scanf("%d",&a);
            flag[a]=1;//有石子为1,否则为0
        }
        dp[0]=0;
        for(int i=s;i<=L+t-1;i++)
        {
            for(int j=i-t;j<=i-s;j++)// j 点跳到 i 点
            {
                if(j>=0&&dp[j]!=-1)//j 点能够跳到
                {
                    if(dp[i]==-1)dp[i]=dp[j]+flag[i]; //第一次 直 接 给 值
                    else if(dp[i]>dp[j]+flag[i]) dp[i]=dp[j]+flag[i];//找小的值 

                }
            }
        }
        int res=10000;
        for(int i=L;i<=L+t-1;i++)//L 到 L+t-1 中最小的非 -1 值
        {
            if(dp[i]!=-1&&dp[i]<res) res=dp[i];
        }
        printf("%d\n",res);
    }
    return 0;
}    
时间: 2024-08-25 11:07:52

动态规划--青蛙跳的相关文章

一只青蛙一次可以跳上1级台阶,也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

import java.util.HashMap; //一只青蛙一次可以跳上1级台阶,也可以跳上2级.求该青蛙跳上一个n级的台阶总共有多少种跳法. public class Solution { //方法一:递归求解 public static int JumpFloor1(int n) { if(n<1){ return 0; } if(n==1){ return 1; } if(n==2){ return 2; } return JumpFloor1(n-1)+JumpFloor1(n-2)

青蛙跳台阶(Fibonacci数列)

问题 一只青蛙一次可以跳上 1 级台阶,也可以跳上2 级.求该青蛙跳上一个n 级的台阶总共有多少种跳法. 思路 当n=1时,只有一种跳法,及f(1)=1,当n=2时,有两种跳法,及f(2)=2,当n=3时,可以从n=1直接跳到n=3,也可以从n=2直接跳到n=3,及f(3)=f(1)+f(2)=3...,所以可以使用递归,自顶向下,一步一步求解,但是仔细分析一下,如果n=10,需要求得f(9)和f(8),而f(9)=f(8)+f(7),f(8)=f(7)+f(6),可以很明显看到,求了重复的f(

08.青蛙跳台阶 Java

题目描述 一只青蛙一次可以跳上1级台阶,也可以跳上2级.求该青蛙跳上一个n级的台阶总共有多少种跳法(先后次序不同算不同的结果). 思路 暴力枚举(自顶向下递归): 若台阶数小于等于0,返回0: 若台阶数为1,返回1:(1) 若台阶数为2,返回2:(1,1),(2) 否则,返回F(n-1)+F(n-2);(因为下一步只能是跳1级或者跳2级) 备忘录算法(自顶向下递归): 上面的方法包含大量重复计算,这里利用Map来记录计算过的结果,以减少计算次数. 迭代法(自底向上迭代,也许也算动态规划吧): 拿

青蛙跳台阶问题

题目:一只青蛙一次可以跳上 1 级台阶,也可以跳上2 级.求该青蛙跳上一个n 级的台阶总共有多少种跳法. 我的思路:最开始我的思路是把这个看成是一个数学问题,n=i*1+k*2先把所有可能满足这个公式的i和k求出来.然后在对i和k做排列组合.很明显i的范围应该是0<i<=n,所以我们已i开始迭代.下面贴上代码吧.把注释都写上! public int JumpFloor(int target) { int step = 0; for (int i = 0; i <= target; i++

青蛙跳台阶问题-斐波拉契数列

题目1:一个台阶总共有n级,如果一次可以跳1级,也可以跳2级.求总共有多少种跳法 首先我们考虑最简单的情况,加入只有1级台阶,那显然只有一种跳法,如果有2级台阶,那就有两种跳的方法了:一种是分两次跳,每次跳1级:另外一种就是一次跳2级 现在我们来讨论一般情况.我们把n级台阶时的跳法看成是n的函数,记为f(n).当n>2时,第一次跳的时候就有两种不同的选择:一是第一次只跳1级,此时跳法数目等于后面剩下的n-1级台阶的跳法数目,即为f(n-1):另外一种选择是第一次跳2级,此时跳法数目等于后面剩下的

剑指offer青蛙跳台阶问题

(1)一只青蛙一次可以跳上 1 级台阶,也可以跳上2 级.求该青蛙跳上一个n 级的台阶总共有多少种跳法. //递归方式 public static int f(int n) { //参数合法性验证 if (n < 1) { System.out.println("参数必须大于1!"); System.exit(-1); } if (n == 1 || n == 2) return 1; else return f(n - 1) + f(n - 2); } //非递归方式 publ

c语言:一只青蛙一次可以跳上1级台阶,也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法?

一只青蛙一次可以跳上1级台阶,也可以跳上2级.求该青蛙跳上一个n级的台阶总共有多少种跳法? 解:把n级台阶时的跳法记为f(n),当n>2时,第一次跳的时候有两种不同的选择:一是第一次只跳1级,此时跳法数目等于后面剩下的n-1级台阶的跳法数目,即为f(n-1);另外一种是第一次跳2级,此时跳法数目等于后面剩下的n-2级台阶的跳法数目,即为f(n-2);因此n级台阶时的跳法为f(n)=f(n-1)+f(n-2).不难看出这实际是斐波拉契数列的变形应用,把斐波拉契数列的每一项向前移动了1位. 程序:

青蛙跳台阶的问题

#斐波纳契 一只青蛙一次可以跳上1级台阶,也可以跳上2级.求该青蛙跳上一个n级的台阶总共有多少种跳法. # 假设最后一步到X级台阶,有F(X)种走法, # 这题求的就是F(11) # 因为每步可以迈1或2级台阶. # 所以最后一步到11级台阶, # 而倒数第2步可能是在第10或9级台阶. # 所以到11级台阶的走法,是到第10或9级台阶走法的和. # 同样到9级台阶的走法,是到第7或8级台阶走法的和. # ................... # F(11) # =F(9)+F(10) # =

HDU 5037(Frog-贪心青蛙跳石子)

Frog Time Limit: 3000/1500 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others) Total Submission(s): 1596    Accepted Submission(s): 442 Problem Description Once upon a time, there is a little frog called Matt. One day, he came to a river.