Social

咪路 — Tue, 02 Jun 2026 13:29:21 GMT

我把 Arc 分頁開到閃退了 OAO

Solution

class Solution {
  public:
    vector<int> solveQueries(vector<int> &nums, vector<int> &queries) {
        vector<int> results;
        map<int, vector<int>> pos;
        int size = nums.size();

        for (int i = 0; i < size; ++i) {
            pos[nums[i]].push_back(i);
        }

        for (auto &_p : pos) {
            auto &p = _p.second;

            p.insert(p.begin(), p.back() - size);
            p.push_back(p[1] + size);
        }

        for (int query : queries) {
            int cur = nums[query];
            vector<int> &p = pos[cur];

            if (p.size() <= 3) {
                results.push_back(-1);
                continue;
            }

            auto it = lower_bound(p.begin(), p.end(), query);
            int index = distance(p.begin(), it);

            results.push_back(min(p[index + 1] - query, query - p[index - 1]));
        }

        return results;
    }
};

Solution

class Solution {
public:
    int closestTarget(vector<string>& words, string target, int startIndex) {
        int size = words.size();
        int min = INT_MAX;

        for (int i = 0; i < size; ++i) {
            if (target != words[i]) {
                continue;
            }

            int d1 = (i + size - startIndex) % size;
            int d2 = size - d1;

            if (min > d1) {
                min = d1;
            }

            if (min > d2) {
                min = d2;
            }
        }

        return min == INT_MAX ? -1 : min;
    }
};

Problem

會拿到一個整數陣列 nums。

要從裡面選三個不同的索引 (i, j, k)，而且要滿足這三個位置的數值相等，也就是：

nums[i] == nums[j] == nums[k]

在所有符合條件的數組裡，找出「距離最小」的那一組，並回傳那個最小值。

距離就是兩兩相差的總和：

abs(nums[i] - nums[j]) + abs(nums[i] - nums[k]) + abs(nums[j] - nums[k])

Solution

class Solution {
public:
    int minimumDistance(vector<int>& nums) {
        map<int, vector<int>> m;

        for (int i = 0; i < nums.size(); ++i) {
            m[nums[i]].push_back(i);
        }

        int result = INT_MAX;
        for (auto p = m.begin(); p != m.end(); ++p) {
            int size = p->second.size();

            if (size >= 3) {
                for (int i = 0; i < size - 2; ++i) {
                    int value = p->second[i + 2] - p->second[i];

                    if (value < result) {
                        result = value;
                    }
                }
            }
        }

        if (result == INT_MAX) {
            return -1;
        }

        return result << 1;
    }
};

Writeup

今天剛好是 Easy 的題目，然後也沒有多想，幾乎一次就過了，所以就留 Code 就好了 XD

Problem

給你一個整數陣列 nums，還有一堆操作 queries，每個 query 長 queries[i] = [l, r, k, v]。

然後題目給了一系列的操作：

從 index = l 開始
每次加 k，直到超過 r

每次迴圈就：

nums[index] = (nums[index] * v) % (1e9 + 7)

最後回傳 nums 所有數值的 XOR。

Solution

class Solution {
public:
    static constexpr int mod = 1e9 + 7;
    inline static int xorAfterQueries(vector<int>& nums, vector<vector<int>>& queries) {
        
        for (vector<int>& query : queries) {
            int idx = query[0];

            while (idx <= query[1]) {
                long n = (long)nums[idx] * query[3];
                nums[idx] = n % mod;

                idx += query[2];
            }

        }

        int result = 0;

        for (int num : nums) {
            result ^= num;
        }

        return result;
    }
};

Write up

OK! 妥妥的就是把演算法直接寫在題目裡了！最大的問題應該就是數值操作可能會有 overflow 的問題了。

先什麼都不處理看看結果

class Solution {
public:
    int xorAfterQueries(vector<int>& nums, vector<vector<int>>& queries) {
        for (vector<int> query : queries) {
            int idx = query[0];

            while (idx <= query[1]) {
                nums[idx] = ((long)nums[idx] * query[3]) % (1e9 + 7);
                idx += query[2];
            }
        }

        int result = 0;

        for (int num : nums) {
            result ^= num;
        }

        return result;
    }
};

果然 overflow 了，那加上 long (?

class Solution {
public:
    int xorAfterQueries(vector<int>& nums, vector<vector<int>>& queries) {
        for (vector<int> query : queries) {
            int idx = query[0];

            while (idx <= query[1]) {
                nums[idx] = ((long)nums[idx] * query[3]) % (1e9 + 7);
                idx += query[2];
            }
        }

        int result = 0;

        for (int num : nums) {
            result ^= num;
        }

        return result;
    }
};

好的！過了…

後來研究了一下其他人的 code，有幾個可以改善的地方：

inline 建議編譯器將函數展開，消除函數呼叫的 overhead（push/pop stack frame）。
在迴圈當中用 Reference，防止每次迴圈都重新建立新的變數。