使 X 和 Y 相等的最少操作次数(BFS)

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

https://leetcode.cn/problems/minimum-number-of-operations-to-make-x-and-y-equal/description/
给你两个正整数 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^4\)

一看这种最小步数的这种，就是用BFS。这个题有点类似于树的层次遍历，就是一次得把一个层里面的全部遍历出来。这个就类似于一个四叉树的找一个树所在的层数。

class Solution {
public:
    int minimumOperationsToMakeEqual(int x, int y) {
        unordered_set<int> s;
        int ans=0;
        queue<int>q;
        q.push(x);;
        while(!q.empty()){
            int t=q.size();
            for(int i=0;i<t;i++){
                int xx=q.front();
                q.pop();
                if(xx==y){
                    return ans;
                }
                if(xx%11==0&&s.count(xx/11)==0){
                    q.push(xx/11);
                    s.insert(xx/11);
                }
                if(xx%5==0&&s.count(xx/5)==0){
                    q.push(xx/5);
                    s.insert(xx/5);
                }
                if(xx%5==0&&s.count(xx/5)==0){
                    q.push(xx/5);
                    s.insert(xx/5);
                }
                if(s.count(xx-1)==0){
                    q.push(xx-1);
                    s.insert(xx-1);
                }
                if(s.count(xx+1)==0){
                    q.push(xx+1);
                    s.insert(xx+1);
                }
            }
            ans++;
        }
        return ans;
    }
};

吃掉 N 个橘子的最少天数

厨房里总共有 n 个橘子，你决定每一天选择如下方式之一吃这些橘子：

• 吃掉一个橘子。
• 如果剩余橘子数 n 能被 2 整除，那么你可以吃掉 n/2 个橘子。
• 如果剩余橘子数 n 能被 3 整除，那么你可以吃掉 2*(n/3) 个橘子。

每天你只能从以上 3 种方案中选择一种方案。
请你返回吃掉所有 n 个橘子的最少天数。

示例 1：
输入：n = 10
输出：4
解释：你总共有 10 个橘子。
第 1 天：吃 1 个橘子，剩余橘子数 10 - 1 = 9。
第 2 天：吃 6 个橘子，剩余橘子数 9 - 2(9/3) = 9 - 6 = 3。（9 可以被 3 整除）
第 3 天：吃 2 个橘子，剩余橘子数 3 - 2(3/3) = 3 - 2 = 1。
第 4 天：吃掉最后 1 个橘子，剩余橘子数 1 - 1 = 0。
你需要至少 4 天吃掉 10 个橘子。

示例 2：
输入：n = 6
输出：3
解释：你总共有 6 个橘子。
第 1 天：吃 3 个橘子，剩余橘子数 6 - 6/2 = 6 - 3 = 3。（6 可以被 2 整除）
第 2 天：吃 2 个橘子，剩余橘子数 3 - 2*(3/3) = 3 - 2 = 1。（3 可以被 3 整除）
第 3 天：吃掉剩余 1 个橘子，剩余橘子数 1 - 1 = 0。
你至少需要 3 天吃掉 6 个橘子。

示例 3：
输入：n = 1
输出：1

示例 4：
输入：n = 56
输出：6

提示：
\(1 <= n <= 2*10^9\)

这个题和上面那个一样

class Solution {
public:
    int minDays(int n) {
        unordered_set<int> s;
        int ans=0;
        queue<int>q;
        q.push(n);
        while(!q.empty()){
            int t=q.size();
            for(int i=0;i<t;i++){
                int x=q.front();
                q.pop();
                if(x==0){
                    return ans;
                }
                if(s.count(x-1)==0){
                    q.push(x-1);
                    s.insert(x-1);
                }
                if(x%2==0&&s.count(x/2)==0){
                    q.push(x/2);
                    s.insert(x/2);
                }
                if(x%3==0&&s.count(x/3)==0){
                    q.push(x/3);
                    s.insert(x/3);
                }
            }
            ans++;
        }
        return ans;
    }
};