【牛客网】—— 跳石板

接着上次整理的2017年校招真题 2 我们继续看一下2017年校招真题中比较经典的一道题 —— 跳石板

2017年校招真题 —— 跳石板

题目描述

小易来到了一条石板路前，每块石板上从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

解题思路

• 思路一：一般解题法
  将1 - M个石板看做一个结果数组stepNum，每个stepNum[i]储存着从起点到这一步最小的步数，其中0为不能到达。从 起点开始对stepNum进行遍历，先求i的所有约数(即从stepNum[i]能走的步数)，然后更新那几个能到达的位置的 最 小步数。如果不能到达则更新为此时位置的最小步数 + 1，如果是能到达的就更新为min(已记录的最小步数，此处的 最小步数 + 1))，遍历一遍后得到结果。

• 思路二：动态规划
  采用动态规划思想求解。创建一个vector容器steps，steps[i]表示到达i号石板所需的最小步数。初始化为steps容器为INT_MAX。从序号N的石板开始逐个遍历，若steps[i]为INT_MAX，表示该点不可到达，直接开始下次循环。若steps[i]不为INT_MAX，表示该点可以到达，下面求解编号i的约数，进行动态规划。动态规划的转移方程为：

• steps[i+j] = min(steps[i]+1,steps[i+j]) //i为石板编号，j为i的约束

• steps[N] = 0

• 思路三：贪婪算法
  贪婪算法并不一定能得到最优解，但是一个可行的，较好的解。

• 该问题若采用贪婪算法求解，并不会得到最优解，只会得到一个可行的，较好的解。例如，下述程序中采用了贪婪算法求解。每次都选取最大的约数前进一步。若后续发生不可到达目标点，则进行回溯，取第2大的约数作为步进值。下述程序通过率为80%，并不能AC。例如，对于N=676, M=12948情况，贪婪算法求解为13步，而动态规划算法求解为10步。

代码实现和效率测试

• 思路一，一般求解法

#include <iostream> 
#include <vector> 
#include <algorithm> 

using namespace std;
//计算约数，求除了1和本身的约数
void divisorNum(int n, vector<int> &divNum)
{
	for (int i = 2; i <= sqrt(n); i++) {
		if (n%i == 0)
		{
			divNum.push_back(i); //非平方数时还有另一个数也要加入 
			if (n / i != i)
				divNum.push_back(n / i);
		}
	}	
}
int Jump(int N, int M) {
	//储存的到达此stepNum点的步数，初始N为1步，从N到N为1步 
	vector<int> stepNum(M + 1, 0);
	stepNum[N] = 1;
	for (int i = N; i < M; i++)
	{//N的所有约数，即为从本身这个点开始能走的数量
		vector<int> divNum;
		//0代表这个点不能到
		if (stepNum[i] == 0)
			continue; //求出所有能走的步数储存在divNum的容器中
		divisorNum(i, divNum);
		for (int j = 0; j < divNum.size(); j++) {
			//由位置i出发能到达的点为 stepNum[divNum[j]+i]
			if ((divNum[j] + i) <= M && stepNum[divNum[j] + i] != 0)
				stepNum[divNum[j] + i] = min(stepNum[divNum[j] + i], stepNum[i] + 1);
			else if ((divNum[j] + i) <= M)
				stepNum[divNum[j] + i] = stepNum[i] + 1;
		}
	}
	if (stepNum[M] == 0) 
		return -1;
	else
		//初始化时多给了一步，故需要减1 
		return stepNum[M] - 1;
}
int main() 
{
	int n, m;
	cin >> n >> m;
	cout << Jump(n, m) << endl;
	return 0;	
}

• 思路二，动态规划

#include <iostream>
#include <vector>
#include <climits>
#include <cmath>
#include <algorithm>
using namespace std;

int main(){
	int N, M;
	while (cin >> N >> M){
		vector<int> steps(M + 1, INT_MAX);
		steps[N] = 0;
		for (int i = N; i <= M; i++){
			if (steps[i] == INT_MAX){
				continue;
			}
			for (int j = 2; (j*j) <= i; j++){
				if (i%j == 0){
					if (i + j <= M){
						steps[i + j] = min(steps[i] + 1, steps[i + j]);
					}
					if (i + (i / j) <= M){
						steps[i + (i / j)] = min(steps[i] + 1, steps[i + (i / j)]);
					}

				}

			}
		}
		if (steps[M] == INT_MAX){
			steps[M] = -1;
		}
		cout << steps[M] << endl;
	}
	return 0;
}

• 思路三：贪婪算法，虽然不能百分之百通过测试用例，但是贪婪算法求解能够得到一个较好的解，并且效率很高。

#include <iostream>
using namespace std;

int stepSearch(int N, int M) {
	if (N > M) {
		return -1;
	}
	if (N == M) {
		return 0;
	}
	int res = 0;
	for (int i = 2; i<N; i++) {
		if (i*(N / i) == N) {
			res++;
			if (stepSearch(N + N / i, M) != -1) {
				res += stepSearch(N + N / i, M);
				return res;
			}
			else {
				res--;
			}
		}
	}
	return -1;
}

int main() {
	int N, M;
	while (cin >> N >> M) {
		cout << stepSearch(N, M) << endl;
	}
	return 0;
}