牛客网编程题：跳石板 解法

题目描述

小易来到了一条石板路前，每块石板上从1挨着编号为：1、2、3…
这条石板路要根据特殊的规则才能前进：对于小易当前所在的编号为K的 石板，小易单次只能往前跳K的一个约数(不含1和K)步，即跳到K+X(X为K的一个非1和本身的约数)的位置。 小易当前处在编号为N的石板，他想跳到编号恰好为M的石板去，小易想知道最少需要跳跃几次可以到达

例如：
N = 4，M = 24：
4->6->8->12->18->24
于是小易最少需要跳跃5次，就可以从4号石板跳到24号石板

输入描述：输入为一行，有两个整数N，M，以空格隔开。 (4 ≤ N ≤ 100000) (N ≤ M ≤ 100000)
输出描述：输出小易最少需要跳跃的步数,如果不能到达输出-1

AC解法（一维动规）：

我们使用动态规划来解决此题，首先注意到，根据题目中的条件： (4 ≤ N ≤ 100000) (N ≤ M ≤ 100000)，如果使用二维表进行动规，则会超出时间和空间限制。因此我们应该建立并维护一个一维表进行动规操作

建立并维护一个一维表dp，长度为M+1。dp[i]记录从n号石板到i号石板的最少步数，将dp[n]初始化0，其余值为MATH.MAX_VALUE。从n开始遍历并更新dp表：若dp[i]==MATH.MAX_VALUE，则表示从n到i不可达，跳过并继续循环；若dp[i]!=MATH.MAX_VALUE，表示从n到i可达，求i的约数进行动态规划，状态转移方程为：

dp[i+j]=min(dp[i]+1,dp[i+j])       // i%j==0(j是i的约数) 且 i+j<=m
dp[n]=0                            // 从n到n自身0步

完整代码：

import java.util.Scanner;
import java.lang.Math;
import java.lang.Integer;
public class Main {
    public static void main(String[] args)
    {
        Scanner input=new Scanner(System.in);
        int n=input.nextInt();
        int m=input.nextInt();
        if(n==m)
        {
            System.out.println(0);
            return;
        }
        int[] dp=new int[m+1]; //用于动规的记录表，dp[i]记录从n号石板跳到i号石板的最少步数，dp[i]=Integer.MAX_VALUE时为不可达
        for(int i=0;i<=m;i++)
        {
            dp[i]=Integer.MAX_VALUE;
        }
        dp[n]=0;
        for(int i=n;i<m;i++)
        {
            if(dp[i]==Integer.MAX_VALUE) //不可达
            {
                continue;
            }
            for(int j=2;(j*j)<=i;j++)
            {
                if(i%j==0) //j是i的约数
                {
                    if(i+j<=m)
                    {
                        dp[i+j]=Math.min(dp[i+j],dp[i]+1);
                    }
                    if(i+(i/j)<=m)
                    {
                        dp[i+(i/j)]=Math.min(dp[i+(i/j)],dp[i]+1);
                    }
                }
            }
        }
        if(dp[m]==Integer.MAX_VALUE)
        {
            System.out.println(-1);
        }
        else
        {
            System.out.println(dp[m]);
        }

    }
}

时间复杂度：对一维线性表遍历一遍，元素的约数近似有n/2个，因此需要计算大约n*(n/2)次，时间复杂度为O(n²)
空间复杂度：建立一个线性动规表，O(n)

除了上面所说的根据数据取值范围确定动规表维度之外，这个解法还有一个值得注意的点：一般情况下的状态转移方程，以二位dp表为例，dp[i][j]=min(dp[i][j],dp[i+k][j]) 或 dp[i][j]=max(dp[i][j],dp[i+k][j])，是遍历到dp[i][j]时，根据表中其他位置的值计算更新dp[i][j]；而本题状态转移方程：dp[i+k]=min(dp[i]+1,dp[i+k]),是遍历到dp[i]时，根据dp[i]已有的值计算更新dp[i+k]

下面记录作者在解题过程中的两个未通过的解法——能够计算出正确答案，但超出了时间及空间限制

未AC的解法一（二维动规）

建立并维护一个二维表dp，dp[i][j]存储从编号i到编号j的石板的最少步数。dp[i][j]=-1时表示从i到j不可达。状态转移方程如下：

dp[i][j]=min(dp[i][j],dp[i+k][j])        //1<k<i、i%k、i!=j、dp[i+k][j]!=-1
dp[i][j]=0                               //i==j

完整代码：

import java.util.Scanner;
import java.lang.Math;
import java.lang.Integer;
public class Main {
    public static void main(String[] args)
    {
        if(n==m)
        {
            System.out.println(0);
            return;
        }
        int[][] dp=new int[m+1][m+1]; //用于动规的记录表,dp[i][j]表示从编号为i的石板跳到编号为j的石板的最少步数
        for(int i=n;i<m;i++)
        {
            dp[i][i+1]=-1;
        }
        for(int l=2;l<=(m-n);l++) //起始编号到目标编号的距离
        {
            for(int i=n;i<=(m-l);i++) //起始编号
            {
                int j=i+l; //目标编号
                int temp=Integer.MAX_VALUE;
                for(int k=2;k<Math.min(i,l+1);k++)
                {
                    if(i%k==0 && dp[i+k][j]!=-1) //k是i的约数且从i起始跳k步的方法可达
                    {
                        temp=Math.min(temp,1+dp[i+k][j]);
                    }
                }
                if(temp==Integer.MAX_VALUE)
                {
                    dp[i][j]=-1;
                }
                else
                {
                    dp[i][j]=temp;
                }
            }
        }
        System.out.println(dp[n][m]);
    }
}

时间复杂度：需要遍历二维表，元素的约数近似有n/2个，因此为O(n³)
空间复杂度：建立维护一个二维表，因此为O(n²)

这个解法能计算出正确答案，但是无法AC。在测试用例n=8,m=85678中，程序抛出java.lang.OutOfMemoryError: Java heap space。JVM中数组的实例存储空间在堆（heap）中，当m=85678是，建立的dp[m+1][m+1]过大造成堆溢出Error。不满足空间限制

未AC解法二（另一种动规+贪心）：

建立一个动规表dp，由二维ArrayList实现，dp[s]存储最少需要s步到m号石板的石板的编号。已知m号石板达到自身需要0步，从m-1到n遍历，对于i号石板(n=<i<=m)，它最少到达m的步数是它可以一步到达的石板中花费的最少步数+1（贪心），对于不可到达m的石板不用存储。

状态转移方程：

step[i]=min(s|j∈dp[s],i+k=j,i%k==0)                 //i!=m
step[i]=0                                            //i==m

完整代码：

import java.util.Scanner;
import java.lang.Math;
import java.lang.Integer;
import java.util.ArrayList;
public class Main {
    public static void main(String[] args)
    {
        if(n==m)
        {
            System.out.println(0);
            return;
        }
        ArrayList<ArrayList<Integer>> stepNumTable=new ArrayList<>(); //记录最少可用x步到达编号m的石板的标号
        for(int i=0;i<m-n;i++)
        {
            stepNumTable.add(new ArrayList<>());
        }
        stepNumTable.get(0).add(m); //m到达自身0步
        for(int i=m-2;i>=n;i--)
        {
            int step=-1;
            for(int s=0;s<=(m-i);s++) //s是最少可用s步到m号石板
            {
                for(int j=0;j<stepNumTable.get(s).size();j++)
                {
                    int diff=stepNumTable.get(s).get(j)-i; //跳跃步数
                    if(i%diff==0 && diff!=1 && diff<i) //步数diff是i的约数
                    {
                        step=s+1; //i号石板最少需要step=s+1步到m号石板
                        break;
                    }
                }
                if(step!=-1)
                {
                    stepNumTable.get(step).add(i);
                    if(i==n)
                    {
                        System.out.println(step);
                        return;
                    }
                    break;
                }
            }
        }
        System.out.println(-1);
    }
}

时间复杂度：O(n²)
空间复杂度：O(n)
本题不会出现堆溢出Error，但依然超出了时间限制