题目描述
小易来到了一条石板路前,每块石板上从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
输入
4 24
输出
5
【题目解析】:
题目的意思是从N开始,最少需要累加几步可以变成指定的数字M,每次累加的值为当前值的一个约数。
动态规划思路
将1 - M个石板看做一个结果数组stepNum,每个stepNum[i]储存着从起点到这一步最小的步数,其中0为不能到达。 从起点开始对stepNum进行遍历,先求i的所有约数(即从stepNum[i]能走的步数),然后更新那几个能到达的位置的最小步数。
如果到达的石板之前未到达过,则更新为此时位置的最小步数 + 1;如果到达的石板之前到达过,就更新为 min(已记录的最小步数,此处的最小步数 +1))
,遍历一遍后得到结果。
动态规划的转移方程:
stepNum[divNum[j] + i] = min(stepNum[divNum[j] + i], stepNum[i] + 1);
//i为石板编号,j为i的约数
解答代码
#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;
//初始化时多给了一步,故需要减1
return stepNum[M] - 1;
}
int main() {
int N, M;
cin >> N >> M;
cout << Jump(N, M) << endl;
return 0;
}
代码生成图
贪心思路
贪婪算法并不一定能得到最优解,但是一个可行的,较好的解。
例如,给定硬币coins=[1,2,10,25],金额总数amounts=30,不限制每种币值的硬币数量,
要求用所给硬币凑出所需金额,并且硬币数量最少。
若采用贪婪算法求解,需要6枚(25+5*1)硬币。若采用动态规划求解,所需3枚(10+10+10)硬币。 --- 贪婪算法
该问题若采用贪婪算法求解,并不会得到最优解,只会得到一个可行的,较好的解。例如,下述程序中采用了贪婪算法求解。每次都选取最大的约数前进一步。若后续发生不可到达目标点,则进行回溯,取第2大的约数作为步进值。下述程序通过率为80%,并不能AC。例如,对于N=676, M=12948情况,贪婪算法求解为13步,而动态规划算法求解为10步。
解答代码:
// 程序通过率为80%,并不能AC
//对于N=676, M=12948情况,贪婪算法求解为13步,而动态规划算法求解为10步。
// 贪婪算法并不一定能得到最优解,但是一个可行的,较好的解。
#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++) {
// 此时 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;
}
如有不同见解,欢迎留言讨论~~