进击的青蛙

进击的青蛙

题目描述

资源限制

内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s

问题描述

青蛙X正准备跳过一座桥，这座桥被划分为N段，记青蛙所在的起始点为0，桥的末端为N。桥上的一些点有一些石子，这些点是无法跳上去的。青蛙每次跳跃能向前跳跃+1，+2，+3段，现在请你算出跳到末端的总方法数。如果无法到达，请输出”No Way!"

输入格式

输入数据共N行。

第一行一个数字N，代表桥的长度。

接下来N行，表示从点1~N的道路情况，每行一个数字0或1，1表示有石子。

输出格式

输出一行，为一个整数，代表方法数，无法到达为“No Way!" 　　由于数据过大，我们只需要求出 对 1000000007 的余数即可

样例输入

5
1
0
0
1
0

样例输出

3

数据规模和约定

N <= 10^6

题目链接：进击的青蛙

解题思路

首先就是考虑到递归，遍历所有的可能，不满足条件就返回，然后测试了一下，运行超时，时间复杂度太高了，代码如下：

import java.util.Scanner;

public class Main {

    static long sum=0L;
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int n=scanner.nextInt();
        int[] arr=new int[n+1];
        for (int i = 1; i <= n; i++) {
            arr[i] = scanner.nextInt();
        }

        if (arr[arr.length-1]!=0) {
            rec(arr, 0, 1);
            rec(arr, 0, 2);
            rec(arr, 0, 3);
        }
        if (sum!=0) {
            System.out.println(sum % 1000000007);
        }else {
            System.out.println("No Way!");
        }
    }

    public static void rec(int[] arr,int location,int choose){
        if (location+choose==arr.length-1){
            sum++;
            return;
        }
        if (location+choose>=arr.length||arr[location+choose]==1){
            return;
        }
        rec(arr,location+choose,1);
        rec(arr,location+choose,2);
        rec(arr,location+choose,3);
    }
}

改进算法

改为了动态规划的思路，res[i]=res[i-1]+res[i-2]+res[i-3]。

import java.math.BigInteger;
import java.util.Arrays;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int n=scanner.nextInt();
        int[] arr=new int[n+1];
        long[] res=new long[n+1];
        for (int i = 1; i <= n; i++) {
            arr[i] = scanner.nextInt();
        }


        if (arr[1]!=1)  res[1]= 1;
        if (arr[2]!=1)  res[2]=res[1]+1;
        if (arr[3]!=1)  res[3]=res[1]+res[2]+1;

        for (int i = 4; i <= n; i++) {
            if (arr[i]!=1) res[i]=(res[i-1]+res[i-2]+res[i-3])%1000000007;
        }

        if (res[n]!=0){
            System.out.println(res[n]%1000000007);
        }else {
            System.out.println("No Way!");
        }
        
    }

}

但是还是超了一个内存。。。

踩坑！！！

res[i]=(res[i-1]+res[i-2]+res[i-3])%1000000007

1.第一次没有取余，就一直通不过，最后发现数组后面累加已经超long的范围了。
2.采取过BigInteger，内存超的更多。
总结：BigInteger适合于数字少的情况，BigInteger的数组太占内存了。