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
原题链接
思路分析
赛时比较蠢,写了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
原题链接
思路分析
赛时没看到条件,考虑交叉情况写了半天并查集,后来看见条件直接线段树秒了
我们把权值后移(前移也行)
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
原题链接
思路分析
树状数组+有序集合
比较考验码力,赛时一眼有思路,但是没调出来,赛后平心静气,捋顺逻辑一下就过了……
本题一是心态要稳,而是对于大数据结构题要有一定练习,码力要上去
我们要用到两个树状数组,一个有序集合
树状数组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;
}
};