园龄：2年5个月粉丝：9 关注：17

A. Moving Chips[Trick]

功能区分为 $n$ 个单元格，从左到右编号为 $1$ 到 $n$ 。每个单元要么包含一个芯片，要么是免费的。

您可以执行以下操作任意次数(可能为零)：选择一个筹码并将其移动到 左侧最近的空闲单元。您可以选择任何您想要的芯片，只要其左侧至少有一个空闲单元即可。当您移动芯片时，操作前所在的单元格就会空闲。

您的目标是以这样的方式移动芯片，使得它们形成一个块，并且它们之间没有任何空闲单元。您必须执行的最少操作次数是多少？

分析

我们找出最左边和最右边的芯片 $L, R$

目标使得 $[L, R]$ 之中没有空白格

我们每次移动最右边的芯片，可以填补最右边的空白，并将空出的空白格移到 $R$ 右边

这样我们每次移动都可以减少一个空白格的数量

我们的目标是让空白格的数量为 $0$

所需的操作次数就是一开始区间中空白格的数量

code

Submission #247902579 - Codeforces

// Codeforces - Educational Codeforces Round 162 (Rated for Div. 2) A. Moving
// Chips https://codeforces.com/contest/1923/problem/0 2024-02-23 22:35:51

#include <bits/stdc++.h>
using namespace std;
#define all(a) begin(a), end(a)
#define int long long
int n, m;
void solve() {
  cin >> n;
  vector<int> a(n), s(n);
  for (auto &i : a) cin >> i;
  for (int i = 0; i < n; i++)
    if (i)
      s[i] = s[i - 1] + a[i];
    else
      s[i] = a[i];
  int l = 0, r = n - 1;
  while (l < n and a[l] == 0) l++;
  while (r >= 0 and a[r] == 0) r--;
  if (r < l)
    cout << "0\n";
  else if (l)
    cout << -s[r] + s[l - 1] + r - l + 1 << "\n";
  else
    cout << -s[r] + r - l + 1 << "\n";
}

signed main() {
  ios::sync_with_stdio(false);
  cin.tie(0), cout.tie(0);
  int __;
  cin >> __;
  while (__--) solve();
  return 0;
}

B. Monsters Attack![Trick]

您正在玩电脑游戏。该游戏的当前等级可以建模为一条直线。您的角色位于该行的点 $0$ 。有 $n$ 个怪物试图杀死你的角色；第 $i$ 个怪物的生命值等于 $a_{i}$ ，并且最初位于点 $x_{i}$ 。

每一秒都会发生以下情况：

首先，你向怪物发射最多 $k$ 颗子弹。每颗子弹只瞄准一个怪物并使其生命值降低 $1$ 。对于每颗子弹，您可以任意选择其目标(例如，您可以向一个怪物发射所有子弹，向不同的怪物发射所有子弹，或选择任何其他组合)。任何怪物都可以成为子弹的目标，无论其位置和任何其他因素如何；
然后，所有生命值小于等于 $0$ 的活着的怪物都会死亡；
然后，所有活着的怪物都会向您靠近 $1$ 点(您左边的怪物将其坐标增加 $1$ ，您右侧的怪物将其坐标减少 $1$ )。如果任何怪物到达你的角色(移动到点 $0$ )，你就输了。

您能生存并杀死所有 $n$ 个怪物而不让它们接触到您的角色吗？

分析

这个题也是一个小Trick

我们维护前缀 $X$ 秒能不能消灭所有前 $X$ 秒会靠近主角的怪兽就好

如果坐标为负数我们就取绝对值转移到正数方便处理

code

Submission #247906784 - Codeforces

// Codeforces - Educational Codeforces Round 162 (Rated for Div. 2) B. Monsters
// Attack! https://codeforces.com/contest/1923/problem/B 2024-02-23 22:47:36

#include <bits/stdc++.h>
using namespace std;
#define all(a) begin(a), end(a)
#define int long long
int n, k;
void solve() {
  cin >> n >> k;
  vector<int> a(n), x(n);
  for (auto &i : a) cin >> i;
  for (auto &i : x) cin >> i;
  map<int, int> mp;
  for (int i = 0; i < n; i++)
    if (x[i] < 0)
      mp[-x[i]] += a[i];
    else
      mp[x[i]] += a[i];
  int res = 0;
  for (auto [v, w] : mp)
    if (res + w <= v * k)
      res += w;
    else
      return (void)(cout << "NO\n");
  cout << "YES\n";
}

signed main() {
  ios::sync_with_stdio(false);
  cin.tie(0), cout.tie(0);
  int __;
  cin >> __;
  while (__--) solve();
  return 0;
}

C. Find B [贪心]

如果存在长度为 $m$ 的数组 $b$ ，并且满足以下条件，则长度为 $m$ 的数组 $a$ 被认为是良好的：

$\sum_{i = 1}^{m} a_{i} = \sum_{i = 1}^{m} b_{i}$ ；
$a_{i} \neq b_{i}$ 对于从 $1$ 到 $m$ 的每个索引 $i$ ；
$b_{i} > 0$ 对于从 $1$ 到 $m$ 的每个索引 $i$ 。

给您一个长度为 $n$ 的数组 $c$ 。该数组的每个元素都大于 $0$ 。

您必须回答 $q$ 个查询。在第 $i$ 个查询期间，您必须确定子数组 $c_{l_{i}}, c_{l_{i} + 1}, \dots, c_{r_{i}}$ 是否良好。

分析

对于一个数组

如果存在相同长度的另一个数组

使得两个数组之和相同

另一个数组每个位置都与当前数组的不同

而且另一个数组的每个位置都是大于0 的

贪心的来想

就让之前大于1 的地方全都是1

把之前是1的地方都填上2

剩余量大于等于0就行

code

Submission #247922876 - Codeforces

// Codeforces - Educational Codeforces Round 162 (Rated for Div. 2) C. Find B
// https://codeforces.com/contest/1923/problem/C 2024-02-23 22:52:06

#include <bits/stdc++.h>
using namespace std;
#define all(a) begin(a), end(a)
#define int long long
int n, q;
void solve() {
  cin >> n >> q;
  vector<int> c(n + 1), s(n + 1), cnt1(n + 1);
  for (int i = 1; i <= n; i++) cin >> c[i];
  for (int i = 1; i <= n; i++) s[i] = s[i - 1] + c[i];
  for (int i = 1; i <= n; i++) cnt1[i] = cnt1[i - 1] + (c[i] == 1);
  while (q--) {
    int l, r;
    cin >> l >> r;
    if (l == r) {
      cout << "NO\n";
      continue;
    }
    int res = s[r] - s[l - 1] - cnt1[r] + cnt1[l - 1] - r + l - 1;
    if (res >= 0)
      cout << "YES\n";
    else
      cout << "NO\n";
  }
}
signed main() {
  ios::sync_with_stdio(false);
  cin.tie(0), cout.tie(0);
  int __;
  cin >> __;
  while (__--) solve();
  return 0;
}

D. Slimes[二分]

有 $n$ 个史莱姆排成一行。史莱姆按从左到右的顺序编号为 $1$ 到 $n$ 。第 $i$ 个史莱姆的大小为 $a_{i}$ 。

每一秒，都会发生以下情况：恰好一个史莱姆会吃掉它的邻居之一，并根据被吃掉的邻居的大小来增加其大小。只有当史莱姆严格大于邻居时，它才能吃掉它的邻居。如果没有严格大于其邻居之一的史莱姆，则该过程结束。

例如，假设 $n = 5$ ， $a = [2, 2, 3, 1, 4]$ 。该过程可以如下进行：

首先，第 $3$ 个史莱姆吃掉了第 $2$ 个史莱姆。第 $3$ 个史莱姆的大小变为 $5$ ，第 $2$ 个史莱姆被吃掉。
然后， $3$ -rd 史莱姆吃掉 $1$ -st 史莱姆(它们是邻居，因为 $2$ -nd 史莱姆已经被吃掉了)。 $3$ -rd 史莱姆的大小变为 $7$ ， $1$ -st 史莱姆被吃掉。
然后，第 $5$ 个史莱姆吃掉第 $4$ 个史莱姆。第 $5$ 个史莱姆的大小变成了 $5$ ，第 $4$ 个史莱姆被吃掉。
然后，第 $3$ 个史莱姆吃掉第 $5$ 个史莱姆(它们是邻居，因为第 $4$ 个史莱姆已经被吃掉了)。第 $3$ 个史莱姆的大小变成了 $12$ ，第 $5$ 个史莱姆被吃掉。

对于每个史莱姆，计算该史莱姆被另一个史莱姆吃掉所需的最短秒数(在该过程的所有可能方式中)，或者报告这是不可能的。

分析

先处理能否在一开始被身边的吃掉

找到最近的未被吃掉的

否则的话就二分离当前位置的距离

由于相同大小的是不能互相吞噬的

所以我们把大小看成颜色

维护每个颜色的左右端点

二分的时候跳过相邻的颜色段

当有两个及以上的颜色段，这两段区间便可以合成一个很大的怪物

code

Submission #247951109 - Codeforces

// Codeforces - Educational Codeforces Round 162 (Rated for Div. 2) D. Slimes
// https://codeforces.com/contest/1923/problem/D 2024-02-23 23:18:47

#include <bits/stdc++.h>
using namespace std;
#define all(a) begin(a), end(a)
#define int long long
int n, m;
void solve() {
  cin >> n;
  vector<int> a(n + 1), L(n + 1), R(n + 1);
  for (int i = 1; i <= n; i++) cin >> a[i];
  vector<int> ans(n + 1, n + 1);
  for (int i = 1; i <= n; i++) {
    if (i < n)
      if (a[i + 1] > a[i]) ans[i] = 1;
    if (i > 1)
      if (a[i - 1] > a[i]) ans[i] = 1;
  }
  for (int i = 1; i <= n; i++) L[i] = R[i] = i;
  for (int i = 2; i <= n; i++)
    if (a[i] == a[i - 1]) L[i] = L[i - 1];
  for (int i = n - 1; i >= 1; i--)
    if (a[i] == a[i + 1]) R[i] = R[i + 1];
  vector<int> s(n + 1);
  for (int i = 1; i <= n; i++) s[i] = s[i - 1] + a[i];
  for (int i = 1; i <= n; i++) {
    if (ans[i] == n + 1) {
      if (i < n) {
        int l = R[i + 1] + 1LL, r = n;
        while (l <= r) {
          int mid = l + r >> 1;
          if (s[mid] - s[i] > a[i])
            ans[i] = min(ans[i], mid - i), r = mid - 1;
          else
            l = mid + 1;
        }
      }
      if (i > 1) {
        int l = 1, r = L[i - 1] - 1LL;
        while (l <= r) {
          int mid = l + r >> 1;
          if (s[i - 1] - s[mid - 1] > a[i])
            ans[i] = min(ans[i], i - mid), l = mid + 1;
          else
            r = mid - 1;
        }
      }
    }
  }
  for (auto &i : ans)
    if (i == n + 1) i = -1;
  for (int i = 1; i <= n; i++) cout << ans[i] << " \n"[i == n];
}
signed main() {
  ios::sync_with_stdio(false);
  cin.tie(0), cout.tie(0);
  int __;
  cin >> __;
  while (__--) solve();
  return 0;
}

E. Count Paths[启发式合并]

给您一棵树，由 $n$ 个顶点组成，编号从 $1$ 到 $n$ 。每个顶点都涂有某种颜色，用从 $1$ 到 $n$ 的整数表示。

如果满足以下条件，则树的简单路径称为美丽路径：

它至少由 $2$ 个顶点组成；
路径的第一个和最后一个顶点具有相同的颜色；
路径上没有其他顶点与第一个顶点具有相同的颜色。

数数树上美丽简单的路径有多少条。请注意，路径被视为无向（即从 $x$ 到 $y$ 的路径与从 $y$ 到 $x$ 的路径相同）。

分析

我们可以知道答案有两种

一种是父子链上的选择

另一种是一个节点的不同孩子之间

对于第一种我们需要维护子树中有没有这个父亲的颜色

对于第二种我们需要维护子树中有多少链有相同的颜色

于是我们可以用map<int,int>来维护每一种颜色

但是直接维护是 $O (n^{2})$ 的显然不可以接受

但是有一种奇妙的东西叫做启发式合并

简而言之就是在合并信息的时候，将 $s i z e$ 较小的合并到 $s i z e$ 较大的中

可以发现每一次合并对于任意一个移动的点，所在的区间的大小都会扩增至少 $2$ 倍

所以可以在 $O (l o g_{2} n)$ 次移动中完成维护

时间复杂度的上界是 $O (n l o g^{2} n)$

code

codeforces.com/contest/1923/submission/248062684

// Codeforces - Educational Codeforces Round 162 (Rated for Div. 2) E. Count
// Paths https://codeforces.com/contest/1923/problem/E 2024-02-23 23:57:48

#include <bits/stdc++.h>
using namespace std;
#define all(a) begin(a), end(a)
#define int long long
int n, m;
void solve() {
  cin >> n;
  vector<int> col(n);
  for (auto &i : col) cin >> i;
  vector<vector<int>> G(n);
  for (int i = 1; i < n; i++) {
    int x, y;
    cin >> x >> y;
    x--, y--;
    G[x].emplace_back(y);
    G[y].emplace_back(x);
  }
  vector<map<int, int>> mp(n);
  int ans = 0;
  auto merge = [&](int i, int j) -> void {
    if (mp[i].size() < mp[j].size()) swap(mp[i], mp[j]);
    for (auto [x, y] : mp[j]) mp[i][x] += y;
  };
  auto dfs = [&](auto self, int u, int fa) -> void {
    mp[u][col[u]]++;
    for (auto it : G[u]) {
      if (it == fa) continue;
      self(self, it, u);
      if (mp[it].contains(col[u]))
        ans += (mp[it][col[u]] * mp[it][col[u]] - mp[it][col[u]]) / 2LL;
      merge(u, it);
    }
    ans += mp[u][col[u]] - 1;
    mp[u][col[u]] = 1;
  };
  dfs(dfs, 0, 0);
  for (auto [x, y] : mp[0]) ans += (y * y - y) / 2LL;
  cout << ans << "\n";
}

signed main() {
  ios::sync_with_stdio(false);
  cin.tie(0), cout.tie(0);
  int __;
  cin >> __;
  while (__--) solve();
  return 0;
}

上一篇D. Concatenated Multiples[离线]

本文作者：liangqianxing

本文链接：https://www.cnblogs.com/liangqianxing/p/18031876

posted @ 2024-02-25 01:19 liangqianxing 阅读(49) 评论(1) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

liangqianxing

Edu162

Edu162[A-E]

A. Moving Chips[Trick]

B. Monsters Attack![Trick]

C. Find B [贪心]

D. Slimes[二分]

E. Count Paths[启发式合并]

公告

搜索

常用链接

随笔档案

相册

阅读排行榜

评论排行榜

推荐排行榜

最新评论