[每日一题]65：跳石板（动归、贪心）

题目描述

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

---

如有不同见解，欢迎留言讨论～～