[每日一題]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;
}

---

如有不同見解，歡迎留言討論～～