本文涉及知识点

C++BFS算法

LeetCode2998. 使 X 和 Y 相等的最少操作次数

给你两个正整数 x 和 y 。
一次操作中，你可以执行以下四种操作之一：
如果 x 是 11 的倍数，将 x 除以 11 。
如果 x 是 5 的倍数，将 x 除以 5 。
将 x 减 1 。
将 x 加 1 。
请你返回让 x 和 y 相等的 最少 操作次数。

示例 1：
输入：x = 26, y = 1
输出：3
解释：我们可以通过以下操作将 26 变为 1 ：

1. 将 x 减 1
2. 将 x 除以 5
3. 将 x 除以 5
   将 26 变为 1 最少需要 3 次操作。
   示例 2：

输入：x = 54, y = 2
输出：4
解释：我们可以通过以下操作将 54 变为 2 ：

1. 将 x 加 1
2. 将 x 除以 11
3. 将 x 除以 5
4. 将 x 加 1
   将 54 变为 2 最少需要 4 次操作。
   示例 3：

输入：x = 25, y = 30
输出：5
解释：我们可以通过以下操作将 25 变为 30 ：

1. 将 x 加 1
2. 将 x 加 1
3. 将 x 加 1
4. 将 x 加 1
5. 将 x 加 1
   将 25 变为 30 最少需要 5 次操作。

提示：
1 <= x, y <= 10⁴

堆优化迪斯氏单源最短路

令最优解为path = {n0,n1,n2,n3,$\dots$nn}。x=n1,y=nn。
性质一：path中不会存在重复的元素。令path[i]等于path[j]，则删除path[i…j-1]是更优解。
性质二：i < j path[i] < path[j]，则path[i+1…j-1]一定包括path[i+1]到path[j-1]之间所有数。下面用反证法来证明：
令x$\in$[path[i]+1,path[j]-1],path[i+1…j-1]之间不存在x。令path[k]是第一个大于x，故path[k-1] < x。path[k-1]无论如何操作，都<=x，与假设矛盾。
推论一：根据性质二，i < j path[i] < path[j] j-i >= path[j]-path[i]。 存在最优解：path[i] path[i]+1 path[i]+2$\cdots$path[j]。故x1 < x2，x1变x2 最少需要x2-x1次。

path[i]都在[0,10000]中，那状态数只有10000种。我们来分析存是否存在path[i]<1或path[i] >10000。
一，不会存在path[i2]<0。
令path[i2]不在[0,10000]，前面在[0,10000]的数i1，后面在[0,10000]的数i3。path[i1]和path[i2]一定都是0，和性质一矛盾。
二，存在path[i2] > 10000。
path[i2…i3-1]一定不是除法的结果。反证法：令path[i4]除法的结果，则path[i4-1] > 50000。根据性质二：path[i2…i4-1]一定包括path[i4]，与性质一矛盾。path[i3]可能是除法的结果。
不会有减法：令path[i4]是减法，则path[i1] <= 10000 < path[i4] < path[i4-1]=path[i4]+1，根据性质二：path[i1…i4-1]之间一定有path[i4]，与性质一矛盾。故只有一种可能：
path[i1…i3-1]全部是++，path[i3-1]除以5或11。即path[i1]一定是10000。
如果n1$\in$[0,9999]则顶多4条出边。
n1=10000顶多20000左右出边。
n1$\to$ 11x $\to$ x
n1$\to$ 5x $\to$ x
由于权重不为1，所以不能使用BFS。由于是稀疏图，故用堆优化迪斯氏单源最短路。

BFS

根据推论一，y >=x，需要y-x次。下面只讨论y < x。
一，假定path没有除法，即只有加减法。则一定是n1个++,n2个–。n2-n1=x-y。显然最优解是：x-y个减法。
二，如果有除法，则除法之前可能有加法。不失一般性，只讨论除以5，不讨论除以11。
如果x是5的倍数，则直接除，不需要加。
如果x不是5倍数，则加到x1就不加了。x1是5倍数，x1 > x ,x1尽可能的小。
这两个本质是一个问题，下面来证明：
令x=5$\times$x1
$x\to x+5\to x1+1$ 操作6次
$x\to x1\to x1$操作2次
故:path[i]$\in$[0,10011]，状态只需要考虑[0,10011]
BSF的状态：leves[i] 记录x经过i次操作能形成的数。
BFS的后续状态：cur经过4种操作得到的数next,next$\in$[0,10011]。
BFS的初始状态：leves[0] = {x}
BFS的返回值：如果cur等于y，返回i。
BFS的重复处理：数组leves出重。

核心代码

class CBFSLeve {
public :
	static vector<int> Leve(const vector<vector<int>>& neiBo, vector<int> start) {
		vector<int> leves(neiBo.size(), -1);
		for (const auto& s : start) {
			leves[s] = 0;
		}
		for (int i = 0; i < start.size(); i++) {
			for (const auto& next : neiBo[start[i]]) {
				if (-1 != leves[next]) { continue; }
				leves[next] = leves[start[i]]+1;
				start.emplace_back(next);
			}
		}
		return leves;
	}

	
};

class Solution {
		public:
			int minimumOperationsToMakeEqual(int x, int y) {
				if (y >= x) { return y - x; }
				const int iMax = 10011;
				vector<vector<int>> neiBo(iMax + 1);
				auto Add = [&](int cur, int next) {
					if ((next < 0) || (next > iMax)) { return; }
					neiBo[cur].emplace_back(next);
				};
				for (int i = 0; i <= iMax; i++) {
					Add(i, i + 1);
					Add(i, i - 1);
					if (0 == i % 5) { Add(i, i / 5); }
					if (0 == i % 11) { Add(i, i / 11); }
				}
				auto leve = CBFSLeve::Leve(neiBo, { x });
				return leve[y];
			}
};

单元测试

int x, y;
		TEST_METHOD(TestMethod1)
		{
			x = 3, y = 4;
			auto res = Solution().minimumOperationsToMakeEqual(x, y);
			AssertEx(1, res);
		}
		TEST_METHOD(TestMethod2)
		{
			x = 5, y = 4;
			auto res = Solution().minimumOperationsToMakeEqual(x, y);
			AssertEx(1, res);
		}
		TEST_METHOD(TestMethod3)
		{
			x = 4, y = 4;
			auto res = Solution().minimumOperationsToMakeEqual(x, y);
			AssertEx(0, res);
		}
		TEST_METHOD(TestMethod4)
		{
			x = 44, y = 4;
			auto res = Solution().minimumOperationsToMakeEqual(x, y);
			AssertEx(1, res);
		}
		TEST_METHOD(TestMethod5)
		{
			x = 20, y = 4;
			auto res = Solution().minimumOperationsToMakeEqual(x, y);
			AssertEx(1, res);
		}
		TEST_METHOD(TestMethod21)
		{			
			x = 26, y = 1;
			auto res = Solution().minimumOperationsToMakeEqual(x, y);
			AssertEx(3, res);
		}
		TEST_METHOD(TestMethod22)
		{
			x = 54, y = 2;
			auto res = Solution().minimumOperationsToMakeEqual(x, y);
			AssertEx(4, res);
		}
		TEST_METHOD(TestMethod23)
		{
			x = 25, y = 30;
			auto res = Solution().minimumOperationsToMakeEqual(x, y);
			AssertEx(5, res);
		}