LeetCode 第 409 场力扣周赛个人题解

100378. 设计相邻元素求和服务

原题链接

100378. 设计相邻元素求和服务

思路分析

直接模拟

时间复杂度：O(MN)

AC代码

int dir[5] { -1, 0, 1, 0, -1 };
int dir1[4][2] = { {-1, -1}, {-1, 1}, {1, -1}, {1, 1} };
class neighborSum {
public:
    unordered_map<int, int> mp1, mp2;
    neighborSum(vector<vector<int>>& grid) {
        for (int i = 0; i < grid.size(); ++ i)
            for (int j  = 0; j < grid[0].size(); ++ j) {
                for (int k = 0; k < 4; ++ k) {
                    int ii = i + dir[k], jj = j + dir[k + 1];
                    if (ii < 0 || ii >= grid.size() || jj < 0 || jj >= grid[0].size()) continue;
                    mp1[grid[i][j]] += grid[ii][jj];
                    
                }
                for (int k = 0; k < 4; ++ k) {
                    int ii = i + dir1[k][0], jj = j + dir1[k][1];
                    if (ii < 0 || ii >= grid.size() || jj < 0 || jj >= grid[0].size()) continue;
                    mp2[grid[i][j]] += grid[ii][jj];
                }
            }
    }
    
    int adjacentSum(int value) {
        return mp1[value];
    }
    
    int diagonalSum(int value) {
        return mp2[value];
    }
};

/**
 * Your neighborSum object will be instantiated and called as such:
 * neighborSum* obj = new neighborSum(grid);
 * int param_1 = obj->adjacentSum(value);
 * int param_2 = obj->diagonalSum(value);
 */

100379. 新增道路查询后的最短距离 I

原题链接

100379. 新增道路查询后的最短距离 I

思路分析

赛时比较蠢，写了floyd，事实上，用bfs或者线性dp可以做到O(NQ)

时间复杂度：O(N^2 Q)

AC代码

auto FIO = []{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    return 0;
} ();
class Solution {
public:
    vector<int> shortestDistanceAfterQueries(int n, vector<vector<int>>& queries) {
        vector<vector<int>> f(n, vector<int>(n, INT_MAX));
        for (int i = 0; i < n; i++) {
            for (int j = i; j < n; j++) {
                f[i][j] = j - i;
            }
        }

        vector<int> res;
        for (const auto& query : queries) {
            int x = query[0], y = query[1];
            for (int i = 0; i < n; i++) {
                for (int j = i; j < n; j++) {
                    if (f[i][x] < INT_MAX && f[y][j] < INT_MAX) {
                        f[i][j] = min(f[i][j], f[i][x] + f[y][j] + 1);
                    }
                }
            }
            res.push_back(f[0][n - 1]);
        }

        return res;
    }
};

100376. 新增道路查询后的最短距离 II

原题链接

100376. 新增道路查询后的最短距离 II

思路分析

赛时没看到条件，考虑交叉情况写了半天并查集，后来看见条件直接线段树秒了

我们把权值后移（前移也行）

1~n-1初始权值是1

我们连接(a, b) 相当于把a~b的边合为1条，等价于(a + 1, b - 1)都置0

为什么是(a + 1, b - 1）置0呢？因为连接后如果变成了最短路，那么路径为0 -> a -> b，所以a的权值不能动

如果不是最短路也不影响最短路的值

时间复杂度：O(qlogN)

AC代码

template <class Info, class Tag>
struct LazySegmentTree {
    const int n;
    std::vector<Info> info;
    std::vector<Tag> tag;
    LazySegmentTree(int _n) : n(_n), info(2 << (32 - __builtin_clz(n))), tag(2 << (32 - __builtin_clz(n))){}
    
    void pull(int p) {
        info[p] = info[p << 1] + info[p << 1 | 1];
    }

    void apply(int p, const Tag &t) {
        info[p].apply(t);
        tag[p].apply(t);
    }

    void push(int p) {
        apply(p << 1, tag[p]);
        apply(p << 1 | 1, tag[p]);
        tag[p] = Tag();
    }

    template<class T>
    LazySegmentTree(std::vector<T>& _init): LazySegmentTree(_init.size()) {
        auto build = [&](auto&& self, int p, int l, int r) {
            if (l == r) {
                info[p] = { _init[l] };
                return;
            }
            int mid = l + r >> 1;
            self(self, p << 1, l, mid), self(self, p << 1 | 1, mid + 1, r);
            pull(p);
        };
        build(build, 1, 0, n - 1);
    }

    Info rangeQuery(int p, int l, int r, int x, int y) {
        if (l > y || r < x) return Info();
        if (x <= l && r <= y) 
            return info[p];
        push(p);
        int mid = l + r >> 1;
        return rangeQuery(p << 1, l, mid, x, y) + rangeQuery(p << 1 | 1, mid + 1, r, x, y);
    }

    Info rangeQuery(int l, int r) {
        return rangeQuery(1, 0, n - 1, l, r);
    }

    void rangeApply(int p, int l, int r, int x, int y, const Tag &v){
        if (l > y || r < x) return;
        if (x <= l && r <= y) { 
            apply(p, v);
            return;
        }

        int mid = l + r >> 1;
        push(p);
        rangeApply(p << 1, l, mid, x, y, v);
        rangeApply(p << 1 | 1, mid + 1, r, x, y, v);
        pull(p);
    }

    void rangeApply(int l, int r, const Tag &v) {
        if (l > r) return;
        return rangeApply(1, 0, n - 1, l, r, v);
    }
};

struct Tag {
    bool add = 0;

    void apply(const Tag& t) {
        add = add || t.add;
    }
};

struct Info {
    int sum = 0;
    void apply(const Tag &t) {
        if (t.add)
            sum = 0;
    }
};

Info operator + (const Info &x, const Info &y) {
    return { x.sum + y.sum };
}

class Solution {
public:
    vector<int> shortestDistanceAfterQueries(int n, vector<vector<int>>& queries) {
        std::vector<int> a(n, 1);
        a[0] = 0;
        LazySegmentTree<Info, Tag> sgt(a);
        std::vector<int> res;
        for (auto& q : queries) {
            int a = q[0], b = q[1];
            sgt.rangeApply(a + 1, b - 1, Tag{true});
            res.push_back(sgt.rangeQuery(0, n - 1).sum);
        }
        return res;
    }
};

100388. 交替组 III

原题链接

100388. 交替组 III

思路分析

树状数组+有序集合

比较考验码力，赛时一眼有思路，但是没调出来，赛后平心静气，捋顺逻辑一下就过了……

本题一是心态要稳，而是对于大数据结构题要有一定练习，码力要上去

---

我们要用到两个树状数组，一个有序集合

树状数组tr1: 记录交替组长度小于等于 size 的数目

树状数组tr2: 记录交替组长度小于等于 size 的长度和

有序集合st：维护交替组的断点，如 [0, 1, 1, 0]，有两个连续交替组：[0, 1], [1, 0], 则下标1就是一个断点

有序集合只维护断点可以做到什么？

可以获取该断点所处交替组的长度，我们查找前一个断点，二者在循环数组中的距离就是长度

如何处理操作1？

操作1即求 Σ sz[i] - size + 1 = Σ sz[i] - Σ(size - 1)，其中sz[i] >= size，其个数cnt的获取我们可以通过tr1获取，那么两项求和自然都可以通过两个树状数组获取

如何处理操作2？

操作1十分好维护，本题的难点在于操作2.

color[i] = col之前：

即循环数组中，i的前一个位置为pre = (i - 1 + n) % n, 下一个位置为nxt = (i + 1) % n

如果pre为断点，先删去pre，如果i是断点，先删去i

删除断点对两个树状数组的影响可以看代码逻辑，十分易懂

color[i] = col之后：

如果pre是断点，那么添加pre，如果i是断点，那么添加i

判断 任意下标i 是否是断点：color[i] == color[(i + 1) % n]，那么就是断点

详细看代码

时间复杂度：O((n + q)logn)

AC代码

template<typename T = int>
class FenWick {
private:
    int n;
    std::vector<T> tr;
public:
    FenWick(int _n) : n(_n), tr(_n + 1) 
    {}
    FenWick(const std::vector<T> &_init) : FenWick(_init.size()) {
        init(_init);
    }

    void init(const std::vector<T> &_init) {
        for (int i = 1; i <= n; ++ i) {
            tr[i] += _init[i - 1];
            int j = i + (i & -i);
            if (j <= n)
                tr[j] += tr[i];
        }
    }

    void add(T x, T k) {
        for (; x <= n; x += x & -x) tr[x] += k;
    }

    void add(T l, T r, T k) {
        add(l, k), add(r + 1, -k);
    }

    T query(T x) const {
        T res = T{};
        for (; x; x &= x - 1) res += tr[x];
        return res;
    }

    T query(T l, T r) const {
        if (l > r) return T{};
        return query(r) - query(l - 1);
    }

    int select(const T &k) {
        int x = 0;
        T cur{};
        for (int i = 1 << std::__lg(n); i; i /= 2) {
            if (x + i <= n && cur + tr[x + i] <= k) {
                x += i;
                cur = cur + tr[x];
            }
        }
        return x;
    }
};

class Solution {
public:
    vector<int> numberOfAlternatingGroups(vector<int>& colors, vector<vector<int>>& queries) {
        int n = colors.size();
        FenWick tr1(n), tr2(n); // tr1 个数，tr2 和
        std::set<int> st;

        auto update = [&](int l, int r, int i, int k) -> void {
            int len = (r - l + n) % n;
            if (!len) len = n;
            tr1.add(len, -k), tr2.add(len, -k * len);

            len = (i - l + n) % n;
            if (!len) len = n;
            tr1.add(len, k), tr2.add(len, k * len);

            len = (r - i + n) % n;
            if (!len) len = n;
            tr1.add(len, k), tr2.add(len, k * len);
        };

        auto add = [&](int i) -> void {
            if (st.empty()) {
                st.insert(i);
                tr1.add(n, 1), tr2.add(n, n);
            }
            else {
                auto it = st.insert(i).first;
                auto pre = it == st.begin() ? std::prev(st.end()) : std::prev(it);
                auto nxt = std::next(it) == st.end() ? st.begin() : std::next(it);
                update(*pre, *nxt, i, 1);
            }
        };

        auto rem = [&](int i) -> void {
            if (st.size() == 1) {
                st.erase(i);
                tr1.add(n, -1), tr2.add(n, -n);
            }
            else {
                auto it = st.find(i);
                auto pre = it == st.begin() ? std::prev(st.end()) : std::prev(it);
                auto nxt = std::next(it) == st.end() ? st.begin() : std::next(it);
                st.erase(it);
                update(*pre, *nxt, i, -1);
            }
        };

        for (int i = 0; i < n; ++ i)
            if (colors[i] == colors[(i + 1) % n])
                add(i);
        
        std::vector<int> ans;

        for (auto &q : queries) {
            if (q[0] == 1) {
                if (st.empty()) ans.push_back(n);
                else {
                    int s = tr2.query(q[1], n);
                    int cnt = tr1.query(q[1], n);
                    ans.push_back(s - cnt * q[1] + cnt);
                }
            }
            else {
                int i = q[1], col = q[2];
                int pre = (i - 1 + n) % n, nxt = (i + 1) % n;

                if (colors[i] == colors[pre]) rem(pre);
                if (colors[i] == colors[nxt]) rem(i);

                colors[i] = col;

                if (colors[pre] == colors[i]) add(pre);
                if (colors[i] == colors[nxt]) add(i);
            }
        }

        return ans;
    }
};