解题报告Leecode 5916. 转化数字的最小运算数

Posted 2021-12-04 来老铁干了这碗代码

题目链接：https://leetcode-cn.com/problems/minimum-operations-to-convert-number/

---

题解汇总：https://zhanglong.blog.csdn.net/article/details/121071779

---

题目描述

给你一个下标从 0 开始的整数数组 nums ，该数组由 互不相同 的数字组成。另给你两个整数 start 和 goal 。

整数 x 的值最开始设为 start ，你打算执行一些运算使 x 转化为 goal 。你可以对数字 x 重复执行下述运算：

如果 0 <= x <= 1000 ，那么，对于数组中的任一下标 i（0 <= i < nums.length），可以将 x 设为下述任一值：

x + nums[i]
x - nums[i]
x ^ nums[i]（按位异或 XOR）
注意，你可以按任意顺序使用每个 nums[i] 任意次。使 x 越过 0 <= x <= 1000 范围的运算同样可以生效，但该该运算执行后将不能执行其他运算。

返回将 x = start 转化为 goal 的最小操作数；如果无法完成转化，则返回 -1 。

示例 1：
输入：nums = [1,3], start = 6, goal = 4
输出：2
解释：
可以按 6 → 7 → 4 的转化路径进行，只需执行下述 2 次运算：
6 ^ 1 = 7
7 ^ 3 = 4

示例 2：
输入：nums = [2,4,12], start = 2, goal = 12
输出：2
解释：
可以按 2 → 14 → 12 的转化路径进行，只需执行下述 2 次运算：
2 + 12 = 14
14 - 2 = 12

示例 3：
输入：nums = [3,5,7], start = 0, goal = -4
输出：2
解释：
可以按 0 → 3 → -4 的转化路径进行，只需执行下述 2 次运算：
0 + 3 = 3
3 - 7 = -4
注意，最后一步运算使 x 超过范围 0 <= x <= 1000 ，但该运算仍然可以生效。

示例 4：
输入：nums = [2,8,16], start = 0, goal = 1
输出：-1
解释：
无法将 0 转化为 1

示例 5：
输入：nums = [1], start = 0, goal = 3
输出：3
解释：
可以按 0 → 1 → 2 → 3 的转化路径进行，只需执行下述 3 次运算：
0 + 1 = 1
1 + 1 = 2
2 + 1 = 3

提示：
1 <= nums.length <= 1000
-109 <= nums[i], goal <= 109
0 <= start <= 1000
start != goal
nums 中的所有整数互不相同

---

思路：BFS全量搜索即可，注意要输出步数。

这里附上我测试时的完整可运行代码

---

#include "iostream"
#include "algorithm"
#include "queue"
#include "vector"
#include "unordered_map"

using namespace std;

class Solution {
public:
    int minimumOperations(vector<int>& nums, int start, int goal) {
        // queue，入start，  while非空， 循环，  过0 or 1000则不入
        queue<int> q;

        // 哈希查找，去重
        unordered_map<int, int>um;

        q.push(start);
        int step = 0;
        while (!q.empty()) {
            int size = q.size();
            for (int j = 0; j < size; j++) {            //
                int t = q.front();
                q.pop();

                if (t == goal) {
                    return step;
                }

                for (auto i : nums) {
                    if ((t + i == goal) || (t - i == goal) || ((t^i) == goal)) {
                        return step + 1;
                    }

                    // 加法
                    if((t + i >= 0 && t + i <= 1000) && um[t+i] == 0) {
                        q.push(t + i);
                        um[t+i] = 1;
                    }

                    // 减法
                    if((t - i >= 0 && t - i <= 1000) && um[t-i] == 0) {
                        q.push(t - i);
                        um[t-i] = 1;
                    }

                    // 异或
                    if(((t ^ i) >= 0 && (t ^ i) <= 1000) && um[t^i] == 0) {
                        q.push(t ^ i);
                        um[t^i] = 1;
                    }
                }
            }
            step++;
        }
        return -1;

    }
};

int main() {
    Solution solution;
    vector<int> v;
    v.push_back(2);
    v.push_back(4);
    v.push_back(12);
    cout << solution.minimumOperations(v, 2, 12);
    return 0;
}