2022-6-17 转化数字的最小运算数，员工的重要性，灯泡开关Ⅱ，复写零

1. 转化数字的最小运算数

You are given a 0-indexed integer array nums containing distinct numbers, an integer start, and an integer goal. There is an integer x that is initially set to start, and you want to perform operations on x such that it is converted to goal. You can perform the following operation repeatedly on the number x:

If 0 <= x <= 1000, then for any index i in the array (0 <= i < nums.length), you can set x to any of the following:

• x + nums[i]
• x - nums[i]
• x ^ nums[i] (bitwise-XOR)

Note that you can use each nums[i] any number of times in any order. Operations that set x to be out of the range 0 <= x <= 1000 are valid, but no more operations can be done afterward.

Return the minimum number of operations needed to convert x = start into goal, and -1 if it is not possible.

Example 1

Input: nums = [2,4,12], start = 2, goal = 12
Output: 2
Explanation: We can go from 2 → 14 → 12 with the following 2 operations.
- 2 + 12 = 14
- 14 - 2 = 12

Example 2

Input: nums = [3,5,7], start = 0, goal = -4
Output: 2
Explanation: We can go from 0 → 3 → -4 with the following 2 operations. 
- 0 + 3 = 3
- 3 - 7 = -4
Note that the last operation sets x out of the range 0 <= x <= 1000, which is valid.

Constraints:

• 1 <= nums.length <= 1000
• -10^9 <= nums[i], goal <= 10^9
• 0 <= start <= 1000
• start != goal
• All the integers in nums are distinct.

代码 [BFS]

class Solution {
public:
    int minimumOperations(vector<int> &nums, int start, int goal) {
        int n = nums.size();
        auto op1 = [](int x, int y) -> int { return x + y; };
        auto op2 = [](int x, int y) -> int { return x - y; };
        auto op3 = [](int x, int y) -> int { return x ^ y; };
        vector<function<int(int, int)>> ops{op1, op2, op3};
        vector<bool> vis(1001, false);
        queue<pair<int, int>> q;
        q.emplace(start, 0);
        vis[start] = true;
        while (!q.empty()) {
            auto[x, step]=q.front();
            q.pop();
            for (int num:nums) {
                for (auto &op:ops) {
                    int nx = op(x, num);
                    if (nx == goal) return step + 1;
                    if (nx >= 0 && nx <= 1000 && !vis[nx]) {
                        vis[nx] = true;
                        q.emplace(nx, step + 1);
                    }
                }
            }
        }
        return -1;
    }
};

2. 员工的重要性

You have a data structure of employee information, including the employee’s unique ID, importance value, and direct subordinates’ IDs.

You are given an array of employees employees where:

• employees[i].id is the ID of the ith employee.
• employees[i].importance is the importance value of the ith employee.
• employees[i].subordinates is a list of the IDs of the direct subordinates of the ith employee.

Given an integer id that represents an employee’s ID, return the total importance value of this employee and all their direct and indirect subordinates.

Example 1

Input: employees = [[1,5,[2,3]],[2,3,[]],[3,3,[]]], id = 1
Output: 11
Explanation: Employee 1 has an importance value of 5 and has two direct subordinates: employee 2 and employee 3.
They both have an importance value of 3.
Thus, the total importance value of employee 1 is 5 + 3 + 3 = 11.

Example 2

Input: employees = [[1,2,[5]],[5,-3,[]]], id = 5
Output: -3
Explanation: Employee 5 has an importance value of -3 and has no direct subordinates.
Thus, the total importance value of employee 5 is -3.

Constraints:

• 1 <= employees.length <= 2000
• 1 <= employees[i].id <= 2000
• All employees[i].id are unique.
• -100 <= employees[i].importance <= 100
• One employee has at most one direct leader and may have several subordinates.
• The IDs in employees[i].subordinates are valid IDs.

代码 [BFS]

class Solution {
public:
    int getImportance(vector<Employee *> employees, int id) {
        unordered_map<int, Employee *> mp;
        Employee *root;
        for (auto p:employees) {
            mp[p->id] = p;
            if (p->id == id) root = p;
        }
        queue<Employee *> q;
        q.push(root);
        int result = 0;
        while (!q.empty()) {
            auto node = q.front();
            q.pop();
            result += node->importance;
            for (auto sub:node->subordinates) q.push(mp[sub]);
        }
        return result;
    }
};

3. 灯泡开关 Ⅱ

There is a room with n bulbs labeled from 1 to n that all are turned on initially, and four buttons on the wall. Each of the four buttons has a different functionality where:

• Button 1: Flips the status of all the bulbs.
• Button 2: Flips the status of all the bulbs with even labels (i.e., 2, 4, ...).
• Button 3: Flips the status of all the bulbs with odd labels (i.e., 1, 3, ...).
• Button 4: Flips the status of all the bulbs with a label j = 3k + 1 where k = 0, 1, 2, ... (i.e., 1, 4, 7, 10, ...).

You must make exactly presses button presses in total. For each press, you may pick any of the four buttons to press.

Given the two integers n and presses, return the number of different possible statuses after performing all presses button presses.

Example 1

Input: n = 1, presses = 1
Output: 2
Explanation: Status can be:
- [off] by pressing button 1
- [on] by pressing button 2

Example 2

Input: n = 2, presses = 1
Output: 3
Explanation: Status can be:
- [off, off] by pressing button 1
- [on, off] by pressing button 2
- [off, on] by pressing button 3

Constraints:

• 1 <= n <= 1000
• 0 <= presses <= 1000

代码

class Solution {
public:
    int flipLights(int n, int m) {
        if (m == 0) return 1;
        if (n == 1) return 2;
        if (n == 2) return m == 1 ? 3 : 4;
        return m == 1 ? 4 : (m == 2 ? 7 : 8);
    }
};

4. 复写零

给你一个长度固定的整数数组 arr，请你将该数组中出现的每个零都复写一遍，并将其余的元素向右平移。

注意：请不要在超过该数组长度的位置写入元素。

要求：请对输入的数组 就地 进行上述修改，不要从函数返回任何东西。

Example 1

输入：[1,0,2,3,0,4,5,0]
输出：null
解释：调用函数后，输入的数组将被修改为：[1,0,0,2,3,0,0,4]

Example 2

输入：[1,2,3]
输出：null
解释：调用函数后，输入的数组将被修改为：[1,2,3]

Constraints:

• 1 <= arr.length <= 10000
• 0 <= arr[i] <= 9

代码

class Solution {
public:
    void duplicateZeros(vector<int> &arr) {
        int n = arr.size(), i = 0, j = 0;
        while (j < n) {
            if (arr[i] == 0) ++j;
            ++i, ++j;
        }
        --i, --j;
        while (i >= 0) {
            if (j < n) arr[j] = arr[i];
            if (arr[i] == 0 && --j >= 0) arr[j] = 0;
            --i, --j;
        }
    }
};