update

src/2/22/T294677.cpp

@@ -0,0 +1,141 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+
+struct SegmentTree {
+  int n;
+  vector<int> tree;
+  SegmentTree(int size) {
+    n = size;
+    tree.assign(4 * n + 4, 0);
+  }
+  void build(vector<int> &last, int node, int l, int r) {
+    if (l == r) {
+      tree[node] = last[l];
+    } else {
+      int mid = (l + r) / 2;
+      build(last, 2 * node, l, mid);
+      build(last, 2 * node + 1, mid + 1, r);
+      tree[node] = max(tree[2 * node], tree[2 * node + 1]);
+    }
+  }
+  void upd(int node, int l, int r, int pos, int val) {
+    if (l == r) {
+      tree[node] = val;
+    } else {
+      int mid = (l + r) / 2;
+      if (pos <= mid)
+        upd(2 * node, l, mid, pos, val);
+      else
+        upd(2 * node + 1, mid + 1, r, pos, val);
+      tree[node] = max(tree[2 * node], tree[2 * node + 1]);
+    }
+  }
+  int getmax(int node, int l, int r, int L, int R) {
+    if (r < L || l > R)
+      return -1;
+    if (L <= l && r <= R)
+      return tree[node];
+    int mid = (l + r) / 2;
+    return max(getmax(2 * node, l, mid, L, R),
+               getmax(2 * node + 1, mid + 1, r, L, R));
+  }
+};
+int main() {
+  ios::sync_with_stdio(false);
+  cin.tie(0);
+  int n, q;
+  cin >> n >> q;
+  vector<int> a(n + 1);
+  for (int i = 1; i <= n; i++)
+    cin >> a[i];
+  const int MAX_COLOR = 1000001;
+  vector<set<int> *> cp(MAX_COLOR, nullptr);
+  for (int i = 1; i <= n; i++) {
+    int c = a[i];
+    if (cp[c] == nullptr) {
+      cp[c] = new set<int>();
+    }
+    cp[c]->insert(i);
+  }
+  vector<int> last(n + 1, 0);
+  for (int c = 0; c < MAX_COLOR; c++) {
+    if (cp[c] == nullptr)
+      continue;
+    int prev = 0;
+    for (auto it = cp[c]->begin(); it != cp[c]->end();
+         ++it) {
+      int pos = *it;
+      last[pos] = prev;
+      prev = pos;
+    }
+  }
+  SegmentTree st(n);
+  st.build(last, 1, 1, n);
+  while (q--) {
+    int type;
+    cin >> type;
+    if (type == 1) {
+      int id, x;
+      cin >> id >> x;
+      int c_old = a[id];
+      if (c_old == x) {
+        continue;
+      }
+      if (cp[c_old] != nullptr) {
+        auto it_old = cp[c_old]->find(id);
+        if (it_old != cp[c_old]->end()) {
+          int p_prev = 0;
+          if (it_old != cp[c_old]->begin()) {
+            auto it_prev = it_old;
+            --it_prev;
+            p_prev = *it_prev;
+          }
+          auto it_next = it_old;
+          ++it_next;
+          if (it_next != cp[c_old]->end()) {
+            int p_next = *it_next;
+            last[p_next] = p_prev;
+            st.upd(1, 1, n, p_next, last[p_next]);
+          }
+          cp[c_old]->erase(it_old);
+        }
+      }
+      if (cp[x] == nullptr) {
+        cp[x] = new set<int>();
+      }
+      auto &s_new = *cp[x];
+      auto it_new = s_new.lower_bound(id);
+      int ppn = 0;
+      if (it_new != s_new.begin()) {
+        auto it_prev_new = it_new;
+        --it_prev_new;
+        ppn = *it_prev_new;
+      }
+      int pnn = 0;
+      if (it_new != s_new.end()) {
+        pnn = *it_new;
+      }
+      s_new.insert(id);
+      last[id] = ppn;
+      st.upd(1, 1, n, id, last[id]);
+      if (pnn != 0) {
+        last[pnn] = id;
+        st.upd(1, 1, n, pnn, last[pnn]);
+      }
+      a[id] = x;
+    } else if (type == 2) {
+      int l, r;
+      cin >> l >> r;
+      int max_last = st.getmax(1, 1, n, l, r);
+      if (max_last >= l) {
+        cout << "yes\n";
+      } else {
+        cout << "no\n";
+      }
+    }
+  }
+  for (int c = 0; c < MAX_COLOR; c++)
+    if (cp[c] != nullptr)
+      delete cp[c];
+}

src/2/22/T461834.cpp

@@ -0,0 +1,98 @@
+#include <bits/stdc++.h>
+using namespace std;
+typedef long long ll;
+const int MAX = 300005;
+const int MOD = 998244353;
+ll c[MAX];
+ll psc[MAX];
+ll a_init[MAX];
+struct SegNode {
+  int l, r;
+  ll sum_a_c;
+  ll lazy;
+} tree_nodes[4 * MAX];
+int n, m;
+ll safe(ll x, ll y) { return (x - y + MOD) % MOD; }
+void build(int node, int l, int r) {
+  tree_nodes[node].l = l;
+  tree_nodes[node].r = r;
+  tree_nodes[node].lazy = -1;
+  if (l == r) {
+    tree_nodes[node].sum_a_c = (a_init[l] % MOD) * c[l] % MOD;
+    return;
+  }
+  int mid = (l + r) / 2;
+  build(2 * node, l, mid);
+  build(2 * node + 1, mid + 1, r);
+  tree_nodes[node].sum_a_c =
+      (tree_nodes[2 * node].sum_a_c + tree_nodes[2 * node + 1].sum_a_c) % MOD;
+}
+void pushdown(int node) {
+  if (tree_nodes[node].lazy != -1) {
+    ll x = tree_nodes[node].lazy;
+    int left = 2 * node;
+    int l_start = tree_nodes[left].l;
+    int l_end = tree_nodes[left].r;
+    ll sum_c_left = safe(psc[l_end], psc[l_start - 1]);
+    tree_nodes[left].sum_a_c = (x % MOD) * sum_c_left % MOD;
+    tree_nodes[left].lazy = x;
+    int right = 2 * node + 1;
+    int r_start = tree_nodes[right].l;
+    int r_end = tree_nodes[right].r;
+    ll sum_c_right = safe(psc[r_end], psc[r_start - 1]);
+    tree_nodes[right].sum_a_c = (x % MOD) * sum_c_right % MOD;
+    tree_nodes[right].lazy = x;
+    tree_nodes[node].lazy = -1;
+  }
+}
+void getrange(int node, int l, int r, ll x) {
+  if (tree_nodes[node].l > r || tree_nodes[node].r < l)
+    return;
+  if (tree_nodes[node].l >= l && tree_nodes[node].r <= r) {
+    ll sum_c = safe(psc[tree_nodes[node].r],
+                        psc[tree_nodes[node].l - 1]);
+    tree_nodes[node].sum_a_c = (x % MOD) * sum_c % MOD;
+    tree_nodes[node].lazy = x;
+    return;
+  }
+  pushdown(node);
+  getrange(2 * node, l, r, x);
+  getrange(2 * node + 1, l, r, x);
+  tree_nodes[node].sum_a_c =
+      (tree_nodes[2 * node].sum_a_c + tree_nodes[2 * node + 1].sum_a_c) % MOD;
+}
+ll query_sum(int node, int l, int r) {
+  if (tree_nodes[node].l > r || tree_nodes[node].r < l)
+    return 0;
+  if (tree_nodes[node].l >= l && tree_nodes[node].r <= r) {
+    return tree_nodes[node].sum_a_c;
+  }
+  pushdown(node);
+  ll res = (query_sum(2 * node, l, r) + query_sum(2 * node + 1, l, r)) % MOD;
+  return res;
+}
+int main() {
+  ios::sync_with_stdio(false);
+  cin.tie(0);
+  cin >> n >> m;
+  for (int i = 1; i <= n; i++)
+    cin >> a_init[i];
+  for (int i = 1; i <= n; i++) {
+    c[i] = (1LL * i * (n - i + 1)) % MOD;
+  }
+  psc[0] = 0;
+  for (int i = 1; i <= n; i++) {
+    psc[i] = (psc[i - 1] + c[i]) % MOD;
+  }
+  build(1, 1, n);
+  ll total = query_sum(1, 1, n);
+  cout << total % MOD << "\n";
+  for (int i = 0; i < m; i++) {
+    int l, r;
+    ll x;
+    cin >> l >> r >> x;
+    getrange(1, l, r, x % MOD);
+    total = query_sum(1, 1, n);
+    cout << total % MOD << "\n";
+  }
+}

src/3/T179940_chat.cpp

@@ -0,0 +1,114 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+typedef long long ll;
+
+// 定义一个极大值
+const ll INF = 1e18;
+
+// 线段树支持区间最小查询和点更新
+struct SegmentTree {
+    int n;
+    vector<ll> tree;
+
+    SegmentTree(int size) {
+        n = 1;
+        while(n < size) n <<= 1;
+        tree.assign(2*n, INF);
+    }
+
+    // 更新位置 pos (0-based) 的值为val
+    void update(int pos, ll val) {
+        pos += n;
+        tree[pos] = min(tree[pos], val);
+        while(pos > 1){
+            pos >>= 1;
+            tree[pos] = min(tree[2*pos], tree[2*pos+1]);
+        }
+    }
+
+    // 查询区间 [l, r) 的最小值
+    ll query(int l, int r) const {
+        ll res = INF;
+        int left = l + n;
+        int right = r + n;
+        while(left < right){
+            if(left & 1){
+                res = min(res, tree[left++]);
+            }
+            if(right & 1){
+                res = min(res, tree[--right]);
+            }
+            left >>= 1;
+            right >>= 1;
+        }
+        return res;
+    }
+};
+
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(0);
+    int n;
+    ll m;
+    cin >> n >> m;
+    vector<ll> a(n);
+    for(auto &x:a) cin >> x;
+    
+    // 计算前缀和
+    vector<ll> s(n+1, 0);
+    for(int i=1;i<=n;i++) s[i] = s[i-1] + a[i-1];
+    
+    // 离散化前缀和
+    vector<ll> all_s = s;
+    // 还需要 x = s[i] - m
+    for(int i=0;i<=n;i++) all_s.push_back(s[i] - m);
+    sort(all_s.begin(), all_s.end());
+    all_s.erase(unique(all_s.begin(), all_s.end()), all_s.end());
+    
+    // 映射 s[j] 和 x 到离散化后的索引
+    auto get_idx = [&](ll val) -> int {
+        return lower_bound(all_s.begin(), all_s.end(), val) - all_s.begin();
+    };
+    
+    int size = all_s.size();
+    // 初始化两个线段树
+    SegmentTree st1(size); // 存 dp[j] - s[j]
+    SegmentTree st2(size); // 存 dp[j] + s[j]
+    
+    // 初始化 dp[0] = 0
+    // 插入 j=0 的情况
+    st1.update(get_idx(s[0]), 0 - s[0]);
+    st2.update(get_idx(s[0]), 0 + s[0]);
+    
+    // 初始化 dp array
+    // 可以不存储全 dp array，因为只需要 dp[j] 继续更新下去
+    vector<ll> dp(n+1, INF);
+    dp[0] = 0;
+    
+    for(int i=1;i<=n;i++){
+        ll x = s[i] - m;
+        // 找到 x 在 all_s 中的离散化索引
+        // 对于 st1，查询 s[j] <= x
+        // 找最大的 s[j] <= x，即 upper_bound(x) - 1
+        int pos1 = upper_bound(all_s.begin(), all_s.end(), x) - all_s.begin() - 1;
+        ll res1 = INF;
+        if(pos1 >= 0){
+            res1 = st1.query(0, pos1+1) + x;
+        }
+        // 对于 st2，查询 s[j] >= x
+        // 找最小的 s[j] >= x，即 lower_bound(x)
+        int pos2 = lower_bound(all_s.begin(), all_s.end(), x) - all_s.begin();
+        ll res2 = INF;
+        if(pos2 < size){
+            res2 = st2.query(pos2, size) - x;
+        }
+        // 取两者最小值作为 dp[i]
+        dp[i] = min(res1, res2);
+        // 更新线段树
+        st1.update(get_idx(s[i]), dp[i] - s[i]);
+        st2.update(get_idx(s[i]), dp[i] + s[i]);
+    }
+    
+    cout << dp[n] << "\n";
+}

src/3/T225686.cpp

@@ -0,0 +1,75 @@
+#include <bits/stdc++.h>
+using namespace std;
+using ll = int64_t;
+
+ll n, m;
+
+pair<ll, ll> bfs(ll start, const vector<vector<ll>> &adj) {
+    vector<ll> dist(n + 1, -1);
+    queue<ll> q;
+    q.push(start);
+    dist[start] = 0;
+    ll far = start;
+
+    while (!q.empty()) {
+        ll u = q.front(); q.pop();
+        for (auto &v : adj[u]) {
+            if (dist[v] == -1) {
+                dist[v] = dist[u] + 1;
+                q.push(v);
+                if (dist[v] > dist[far]) {
+                    far = v;
+                }
+            }
+        }
+    }
+    return {far, dist[far]};
+}
+
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    cin >> n >> m;
+    vector<vector<ll>> adj(n + 1, vector<ll>());
+
+    for (ll i = 0; i < m; i++) {
+        ll u, v;
+        cin >> u >> v;
+        adj[u].push_back(v);
+        adj[v].push_back(u);
+    }
+
+    vector<bool> vis(n +1, false);
+
+    ll sum_d = 0;
+    ll k = 0;
+    
+    for(ll u =1; u <=n; u++) {
+        if(!vis[u]){
+            k++;
+            auto [ff, fd1] = bfs(u, adj);
+            auto [sf, sd] = bfs(ff, adj);
+            sum_d += sd;
+
+            queue<ll> qvis;
+            qvis.push(u);
+            vis[u] = true;
+            while(!qvis.empty()){
+                ll node = qvis.front(); qvis.pop();
+                for(auto &v : adj[node]){
+                    if(!vis[v]){
+                        vis[v] = true;
+                        qvis.push(v);
+                    }
+                }
+            }
+        }
+    }
+
+    if(k == 1){
+        cout << sum_d + 1 << '\n';
+    }
+    else{
+        cout << sum_d + k << '\n';
+    }
+}

src/3/T225686_chat.cpp

@@ -0,0 +1,80 @@
+#include <bits/stdc++.h>
+using namespace std;
+using ll = int64_t;
+
+
+ll n, m;
+vector<vector<ll>> adj;
+vector<char> vis_marker; 
+
+
+pair<ll, ll> bfs(ll start){
+    deque<ll> q;
+    q.push_back(start);
+    ll farthest_node = start;
+    ll max_distance = 0;
+    vector<ll> dist(n + 1, -1);
+    dist[start] = 0;
+    vis_marker[start] = 1;
+
+    while(!q.empty()){
+        ll u = q.front();
+        q.pop_front();
+        for(auto &v : adj[u]){
+            if(!vis_marker[v]){
+                vis_marker[v] = 1;
+                dist[v] = dist[u] + 1;
+                q.push_back(v);
+                if(dist[v] > max_distance){
+                    max_distance = dist[v];
+                    farthest_node = v;
+                }
+            }
+        }
+    }
+    return {farthest_node, max_distance};
+}
+
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(NULL);
+
+    cin >> n >> m;
+    adj.assign(n + 1, vector<ll>());
+    ll u, v;
+
+    for(ll i = 0; i < m; ++i){
+        cin >> u >> v;
+        adj[u].emplace_back(v);
+        adj[v].emplace_back(u);
+    }
+
+    
+    vis_marker.assign(n + 1, 0);
+
+    ll sum_d = 0;
+    ll k = 0;
+
+    for(ll u = 1; u <= n; ++u){
+        if(!vis_marker[u]){
+            k++;
+            
+            pair<ll, ll> first_bfs = bfs(u);
+            ll ff = first_bfs.first;
+
+            
+            pair<ll, ll> second_bfs = bfs(ff);
+            ll sd = second_bfs.second;
+
+            sum_d += sd;
+        }
+    }
+
+    
+    if(k == 1){
+        cout << sum_d + 1 << '\n';
+    }
+    else{
+        cout << sum_d + k << '\n';
+    }
+}

src/3/T585518_chat.cpp

@@ -0,0 +1,60 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+// 定义无向图的邻接表表示
+vector<vector<int>> adj;
+
+// BFS函数，返回从起点开始的所有节点的距离
+vector<int> bfs(int start, int n) {
+    vector<int> dist(n + 1, -1); // 节点编号从1到n
+    queue<int> q;
+    q.push(start);
+    dist[start] = 0;
+    while (!q.empty()) {
+        int u = q.front(); q.pop();
+        for(auto &v : adj[u]) {
+            if(dist[v] == -1){
+                dist[v] = dist[u] + 1;
+                q.push(v);
+            }
+        }
+    }
+    return dist;
+}
+
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(0);
+    
+    int n;
+    cin >> n;
+    adj.assign(n + 1, vector<int>());
+    for(int i=0;i<n-1;i++){
+        int u, v;
+        cin >> u >> v;
+        adj[u].push_back(v);
+        adj[v].push_back(u);
+    }
+
+    // 第一次 BFS，找出u
+    vector<int> dist1 = bfs(1, n);
+    int u = 1;
+    for(int i=1;i<=n;i++) {
+        if(dist1[i] > dist1[u]) u = i;
+    }
+
+    // 第二次 BFS，从u找出v，并记录d1
+    vector<int> d1 = bfs(u, n);
+    int v = u;
+    for(int i=1;i<=n;i++) {
+        if(d1[i] > d1[v]) v = i;
+    }
+
+    // 第三次 BFS，从v找出d2
+    vector<int> d2 = bfs(v, n);
+
+    // 输出每个节点的最远距离
+    for(int i=1;i<=n;i++) {
+        cout << max(d1[i], d2[i]) << (i==n ? '\n' : ' ');
+    }
+}

src/test.cpp

@@ -0,0 +1,55 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+using namespace std;
+
+struct TreeNode {
+    vector<int> children;
+};
+
+vector<TreeNode> tree;
+vector<int> enjoyment;
+vector<vector<long long>> dp;
+
+void dfs(int u, int parent) {
+    dp[u][0] = 0; 
+    dp[u][1] = enjoyment[u]; 
+    
+    for (int v : tree[u].children) {
+        if (v == parent) continue; 
+        dfs(v, u);
+        dp[u][0] += max(dp[v][0], dp[v][1]); 
+        dp[u][1] += dp[v][0]; 
+    }
+
+    for (int v : tree[u].children) {
+        if (v == parent) continue;
+        long long option = dp[u][1] - dp[v][0] + dp[v][1] - b; 
+        dp[u][1] = max(dp[u][1], option);
+    }
+}
+
+int main() {
+    int n, b;
+    cin >> n >> b;
+    enjoyment.resize(n + 1);
+    tree.resize(n + 1);
+    dp.resize(n + 1, vector<long long>(2));
+    
+    for (int i = 1; i <= n; ++i) {
+        cin >> enjoyment[i];
+    }
+    
+    for (int i = 0; i < n - 1; ++i) {
+        int x, y;
+        cin >> x >> y;
+        tree[x].children.push_back(y);
+        tree[y].children.push_back(x);
+    }
+
+    dfs(1, -1); 
+    long long result = max(0LL, max(dp[1][0], dp[1][1])); 
+    cout << result << endl;
+
+    return 0;
+}