CodeForces Gym 101754 简要题解

最新推荐文章于 2020-11-22 08:09:40 发布
最新推荐文章于 2020-11-22 08:09:40 发布
阅读量652 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxh010910/article/details/79574239
版权

Letters Swap

首先考虑如何判断合法，不难发现拿个栈能消就消一定是正确的。

考虑分治，处理从 [l,mid] [ l , m i d ] 和 [mid+1,r] [ m i d + 1 , r ] 中选出数交换的合法方案数，记 A A 表示 [1,l−1] 消完剩下的串， B B 表示 [r+1,n] 消完剩下的串，枚举左边交换的字符的位置和交换后的字符，那么会带来 [l,mid] [ l , m i d ] 的前后缀不断消，消的长度可以通过二分哈希来判断，右边同理，然后要求左边消完拼起来的串要等于右边消完拼起来的串，也可以通过哈希统计。

#include <bits/stdc++.h>

using namespace std;

#define X first
#define Y second
#define mp make_pair
#define pb push_back
#define Debug(...) fprintf(stderr, __VA_ARGS__)

typedef long long LL;
typedef long double LD;
typedef unsigned int uint;
typedef pair <int, int> pii;
typedef unsigned long long uLL;

template <typename T> inline void Read(T &x) {
  char c = getchar();
  bool f = false;
  for (x = 0; !isdigit(c); c = getchar()) {
    if (c == '-') {
      f = true;
    }
  }
  for (; isdigit(c); c = getchar()) {
    x = x * 10 + c - '0';
  }
  if (f) {
    x = -x;
  }
}

template <typename T> inline bool CheckMax(T &a, const T &b) {
  return a < b ? a = b, true : false;
}

template <typename T> inline bool CheckMin(T &a, const T &b) {
  return a > b ? a = b, true : false;
}

const int N = 100005;
const int bas1 = 2333333;
const int bas2 = 6666666;
const int mod1 = 1e9 + 7;
const int mod2 = 1e9 + 9;

struct Info {
  int x, y;

  Info(int x = 0, int y = 0):x(x), y(y) {}

  Info operator + (const Info &b) const {
    return Info((x + b.x) % mod1, (y + b.y) % mod2);
  }

  Info operator - (const Info &b) const {
    return Info((x - b.x + mod1) % mod1, (y - b.y + mod2) % mod2);
  }

  Info operator * (const Info &b) const {
    return Info(1LL * x * b.x % mod1, 1LL * y * b.y % mod2);
  }

  Info operator + (const int &b) const {
    return Info((x + b) % mod1, (y + b) % mod2);
  }

  Info operator * (const int &b) const {
    return Info(1LL * x * b % mod1, 1LL * y * b % mod2);
  }

  bool operator < (const Info &b) const {
    return x < b.x || (x == b.x && y < b.y);
  }

  bool operator == (const Info &b) const {
    return x == b.x && y == b.y;
  }
} pwd[N];

map <Info, int> cnt[9];
char s[N];
LL ans;
int n;

struct String {
  vector <Info> u, v;
  vector <char> w;
  int cur;

  String(int tmp = 0) {
    u.pb(Info(0, 0)), v.pb(Info(0, 0)), w.pb(0), cur = tmp;
  }

  inline int Size() {
    return w.size() - 1;
  }

  inline void Insert(char c) {
    u.pb(u.back() * pwd[1] + c), v.pb(v.back() + pwd[w.size() - 1] * (int)c), w.pb(c);
  }

  inline void Delete() {
    u.pop_back(), v.pop_back(), w.pop_back();
  }

  inline void Extend(char c) {
    if (c == w.back()) {
      Delete();
    } else {
      Insert(c);
    }
  }

  inline void MoveA(int x) {
    CheckMax(x, 0);
    for (; cur < x; Extend(s[++cur]));
    for (; cur > x; Extend(s[cur--]));
  }

  inline void MoveB(int x) {
    CheckMin(x, n + 1);
    for (; cur < x; Extend(s[cur++]));
    for (; cur > x; Extend(s[--cur]));
  }

  inline Info Query(int len) {
    return u.back() - u[u.size() - 1 - len] * pwd[len];
  }
} A, B;

inline Info Merge(String &L, char c, String &R) {
  L.Extend(c);
  int l = 1, r = min(L.Size(), R.Size()), ret = 0;
  while (l <= r) {
    int mid = l + r >> 1;
    if (L.Query(mid) == R.Query(mid)) {
      ret = mid, l = mid + 1;
    } else {
      r = mid - 1;
    }
  }
  Info cur = L.u[L.Size() - ret] * pwd[R.Size() - ret] + R.v[R.Size() - ret];
  L.Extend(c);
  return cur;
}

inline void Solve(int l, int r) {
  if (l == r) {
    return ;
  }
  int mid = l + r >> 1;
  String L(mid + 1), R(mid);
  A.MoveA(mid - 1), B.MoveB(mid + 2);
  for (int i = 0; i < 9; ++i) {
    cnt[i].clear();
  }
  for (int i = mid; i >= l; --i) {
    for (char c = 'a'; c <= 'c'; ++c) {
      if (s[i] != c) {
        ++cnt[(s[i] - 'a') * 3 + c - 'a'][Merge(A, c, L)];
      }
    }
    A.MoveA(i - 2), L.MoveB(i);
  }
  for (int i = mid + 1; i <= r; ++i) {
    for (char c = 'a'; c <= 'c'; ++c) {
      if (s[i] != c) {
        ans += cnt[(c - 'a') * 3 + s[i] - 'a'][Merge(B, c, R)];
      }
    }
    B.MoveB(i + 2), R.MoveA(i);
  }
  Solve(l, mid), Solve(mid + 1, r);
}

int main() {
#ifdef wxh010910
  freopen("d.in", "r", stdin);
#endif
  scanf("%s", s + 1), n = strlen(s + 1);
  pwd[0] = Info(1, 1), pwd[1] = Info(bas1, bas2);
  for (int i = 2; i <= n; ++i) {
    pwd[i] = pwd[i - 1] * pwd[1];
  }
  A.cur = 0, B.cur = n + 1;
  Solve(1, n);
  printf("%lld\n", ans);
#ifdef wxh010910
  Debug("My Time: %.3lfms\n", (double)clock() / CLOCKS_PER_SEC);
#endif
  return 0;
}

Big Data

最优方案一定是：向下走到 A A 最大值第一次出现的位置，然后向右走到 B 最大值，然后向下走到 A A 最大值最后出现的位置，然后向右走到底，然后向下走到底。

#include <bits/stdc++.h>

using namespace std;

#define X first
#define Y second
#define mp make_pair
#define pb push_back
#define Debug(...) fprintf(stderr, __VA_ARGS__)

typedef long long LL;
typedef long double LD;
typedef unsigned int uint;
typedef pair <int, int> pii;
typedef unsigned long long uLL;

template <typename T> inline void Read(T &x) {
  char c = getchar();
  bool f = false;
  for (x = 0; !isdigit(c); c = getchar()) {
    if (c == '-') {
      f = true;
    }
  }
  for (; isdigit(c); c = getchar()) {
    x = x * 10 + c - '0';
  }
  if (f) {
    x = -x;
  }
}

template <typename T> inline bool CheckMax(T &a, const T &b) {
  return a < b ? a = b, true : false;
}

template <typename T> inline bool CheckMin(T &a, const T &b) {
  return a > b ? a = b, true : false;
}

const int N = 100005;

int n, m, p, q, max_a, max_b, sum_a, sum_b, a[N], b[N];

int main() {
#ifdef wxh010910
  freopen("d.in", "r", stdin);
#endif
  Read(n), Read(m), max_a = max_b = -1;
  for (int i = 1; i <= n; ++i) {
    Read(a[i]), sum_a += a[i];
    if (CheckMax(max_a, a[i])) {
      p = i;
    }
    if (max_a == a[i]) {
      q = i;
    }
  }
  for (int i = 1; i <= m; ++i) {
    Read(b[i]), sum_b += b[i];
    CheckMax(max_b, b[i]);
  }
  sum_a += max_a * (m - 1), sum_b += b[1] * (p - 1) + b[m] * (n - q) + max_b * (q - p);
  printf("%lld\n", 1000000000LL * sum_a + sum_b);
#ifdef wxh010910
  Debug("My Time: %.3lfms\n", (double)clock() / CLOCKS_PER_SEC);
#endif
  return 0;
}

World of Darkraft 3

枚举用几次群体伤害然后贪心。

#include <bits/stdc++.h>

using namespace std;

#define X first
#define Y second
#define mp make_pair
#define pb push_back
#define Debug(...) fprintf(stderr, __VA_ARGS__)

typedef long long LL;
typedef long double LD;
typedef unsigned int uint;
typedef pair <int, int> pii;
typedef unsigned long long uLL;

template <typename T> inline void Read(T &x) {
  char c = getchar();
  bool f = false;
  for (x = 0; !isdigit(c); c = getchar()) {
    if (c == '-') {
      f = true;
    }
  }
  for (; isdigit(c); c = getchar()) {
    x = x * 10 + c - '0';
  }
  if (f) {
    x = -x;
  }
}

template <typename T> inline bool CheckMax(T &a, const T &b) {
  return a < b ? a = b, true : false;
}

template <typename T> inline bool CheckMin(T &a, const T &b) {
  return a > b ? a = b, true : false;
}

const int N = 105;

int n, m, a, b, c, d, ans, e[N];

int main() {
#ifdef wxh010910
  freopen("d.in", "r", stdin);
#endif
  Read(n), Read(m), Read(a), Read(b), Read(c), Read(d);
  for (int i = 1; i <= n; ++i) {
    Read(e[i]);
  }
  sort(e + 1, e + n + 1);
  for (int i = 0; i <= m / d; ++i) {
    int cur = (m - i * d) / b, dam = i * c, ret = 0;
    for (int j = 1; j <= n; ++j) {
      if (e[j] <= dam) {
        ++ret;
      } else {
        int tmp = (e[j] - dam + a - 1) / a;
        if (cur < tmp) {
          break;
        } else {
          cur -= tmp, ++ret;
        }
      }
    }
    CheckMax(ans, ret);
  }
  printf("%d\n", ans);
#ifdef wxh010910
  Debug("My Time: %.3lfms\n", (double)clock() / CLOCKS_PER_SEC);
#endif
  return 0;
}

Sports Analytics

考虑容斥，将 ai 严格小于 ai+1 a i + 1 的缩成一段，那么如果知道了一段的所有的值，那么它们对应的值也是确定的。

假设最后每段长度为 ai a i ，分配的方案数为 n!∏ai! n ! ∏ a i ! ，可以通过暴力DP计算答案。

#include <bits/stdc++.h>

using namespace std;

#define X first
#define Y second
#define mp make_pair
#define pb push_back
#define Debug(...) fprintf(stderr, __VA_ARGS__)

typedef long long LL;
typedef long double LD;
typedef unsigned int uint;
typedef pair <int, int> pii;
typedef unsigned long long uLL;

template <typename T> inline void Read(T &x) {
  char c = getchar();
  bool f = false;
  for (x = 0; !isdigit(c); c = getchar()) {
    if (c == '-') {
      f = true;
    }
  }
  for (; isdigit(c); c = getchar()) {
    x = x * 10 + c - '0';
  }
  if (f) {
    x = -x;
  }
}

template <typename T> inline bool CheckMax(T &a, const T &b) {
  return a < b ? a = b, true : false;
}

template <typename T> inline bool CheckMin(T &a, const T &b) {
  return a > b ? a = b, true : false;
}

const int N = 1005;
const int mod = 998244353;

int n, m, f[N], inv[N];

inline int Qow(int x, int y) {
  int r = 1;
  for (; y; y >>= 1, x = 1LL * x * x % mod) {
    if (y & 1) {
      r = 1LL * r * x % mod;
    }
  }
  return r;
}

int main() {
#ifdef wxh010910
  freopen("d.in", "r", stdin);
#endif
  Read(n), Read(m), inv[0] = inv[1] = f[0] = 1;
  for (int i = 2; i <= n; ++i) {
    inv[i] = 1LL * (mod - mod / i) * inv[mod % i] % mod;
  }
  for (int i = 2; i <= n; ++i) {
    inv[i] = 1LL * inv[i - 1] * inv[i] % mod;
  }
  for (int i = 1; i <= n; ++i) {
    inv[i] = Qow(inv[i], m);
  }
  for (int i = 1; i <= n; ++i) {
    for (int j = 1; j <= i; ++j) {
      if (j & 1) {
        f[i] = (1LL * f[i - j] * inv[j] + f[i]) % mod;
      } else {
        f[i] = (f[i] - 1LL * f[i - j] * inv[j] % mod + mod) % mod;
      }
    }
  }
  for (int i = 1; i <= n; ++i) {
    f[n] = 1LL * f[n] * i % mod;
  }
  printf("%d\n", f[n]);
#ifdef wxh010910
  Debug("My Time: %.3lfms\n", (double)clock() / CLOCKS_PER_SEC);
#endif
  return 0;
}

Bonsai

不难发现两棵树相等等价于它们的DFS序的节点深度相等。

注意到两个操作实际都是从深度序列删除一个元素，而反过来，从深度唯一不能表示的就是一个节点只有一个儿子的情况，但注意到在最优解中要么他和他儿子都被删除要么都保留，然后就变成了求最长公共子序列。

#include <bits/stdc++.h>

using namespace std;

#define X first
#define Y second
#define mp make_pair
#define pb push_back
#define Debug(...) fprintf(stderr, __VA_ARGS__)

typedef long long LL;
typedef long double LD;
typedef unsigned int uint;
typedef pair <int, int> pii;
typedef unsigned long long uLL;

template <typename T> inline void Read(T &x) {
  char c = getchar();
  bool f = false;
  for (x = 0; !isdigit(c); c = getchar()) {
    if (c == '-') {
      f = true;
    }
  }
  for (; isdigit(c); c = getchar()) {
    x = x * 10 + c - '0';
  }
  if (f) {
    x = -x;
  }
}

template <typename T> inline bool CheckMax(T &a, const T &b) {
  return a < b ? a = b, true : false;
}

template <typename T> inline bool CheckMin(T &a, const T &b) {
  return a > b ? a = b, true : false;
}

const int N = 5005;

int n, m, top, a[N], b[N], dep[N], f[N][N];
vector <int> adj[N], adv[N];

inline void DFS(int x, int *a, vector <int> *adj) {
  a[++top] = dep[x];
  for (auto y : adj[x]) {
    DFS(y, a, adj);
  }
}

int main() {
#ifdef wxh010910
  freopen("d.in", "r", stdin);
#endif
  Read(n), top = 0;
  for (int i = 2, x; i <= n; ++i) {
    Read(x), dep[i] = dep[x] + 1, adj[x].pb(i);
  }
  DFS(1, a, adj);
  Read(m), top = 0;
  for (int i = 2, x; i <= m; ++i) {
    Read(x), dep[i] = dep[x] + 1, adv[x].pb(i);
  }
  DFS(1, b, adv);
  for (int i = 1; i <= n; ++i) {
    for (int j = 1; j <= m; ++j) {
      if (a[i] == b[j]) {
        f[i][j] = f[i - 1][j - 1] + 1;
      } else {
        f[i][j] = max(f[i - 1][j], f[i][j - 1]);
      }
    }
  }
  printf("%d\n", n + m - (f[n][m] << 1));
#ifdef wxh010910
  Debug("My Time: %.3lfms\n", (double)clock() / CLOCKS_PER_SEC);
#endif
  return 0;
}

Alfred and Georg

考虑差分，转化成每次选择 a1,a2,⋯,an a 1 , a 2 , ⋯ , a n 并将 (i,ai) ( i , a i ) 取反，要求 ai a i 单调不降。

从右往左用两个set维护路径的轮廓线即可。

#include <bits/stdc++.h>

using namespace std;

#define X first
#define Y second
#define mp make_pair
#define pb push_back
#define Debug(...) fprintf(stderr, __VA_ARGS__)

typedef long long LL;
typedef long double LD;
typedef unsigned int uint;
typedef pair <int, int> pii;
typedef unsigned long long uLL;

template <typename T> inline void Read(T &x) {
  char c = getchar();
  bool f = false;
  for (x = 0; !isdigit(c); c = getchar()) {
    if (c == '-') {
      f = true;
    }
  }
  for (; isdigit(c); c = getchar()) {
    x = x * 10 + c - '0';
  }
  if (f) {
    x = -x;
  }
}

template <typename T> inline bool CheckMax(T &a, const T &b) {
  return a < b ? a = b, true : false;
}

template <typename T> inline bool CheckMin(T &a, const T &b) {
  return a > b ? a = b, true : false;
}

const int N = 1000005;
const int inf = 0x3f3f3f3f;

int n, m, k, ans, sum[N];
vector <int> seq, all[N];
set <int> s, t;
pii a[N];

int main() {
#ifdef wxh010910
  freopen("d.in", "r", stdin);
#endif
  Read(m), Read(n), Read(k);
  for (int i = 1; i <= k; ++i) {
    Read(a[i].Y), Read(a[i].X);
    ++a[i].X, ++a[i].Y;
  }
  sort(a + 1, a + k + 1);
  for (int i = 1, j = 1; i <= k; i = j) {
    int lst = -1;
    for (; j <= k && a[j].X == a[i].X; ++j) {
      if (~lst && lst + 1 < a[j].Y) {
        all[a[i].X].pb(lst + 1);
      }
      if (a[j].Y > lst + 1) {
        all[a[i].X].pb(a[j].Y);
      }
      lst = a[j].Y;
    }
    if (lst < m) {
      all[a[i].X].pb(lst + 1);
    }
  }
  for (int i = n; i; --i) {
    for (auto x : all[i]) {
      int u = s.empty() || *s.rbegin() < x ? inf : *s.lower_bound(x), v = t.empty() || *t.rbegin() < x ? inf : *t.lower_bound(x);
      if (u == inf && v == inf) {
        continue;
      }
      if (u < v) {
        s.erase(u);
        if (--sum[u]) {
          t.insert(u);
        }
      } else {
        t.erase(v), --sum[v], s.insert(v);
      }
    }
    seq.clear();
    for (auto x : s) {
      seq.pb(x);
    }
    s.clear();
    for (int i = 0; i < seq.size(); i += 2) {
      ++sum[seq[i]], t.insert(seq[i]);
      if (i + 1 < seq.size()) {
        if (--sum[seq[i + 1]]) {
          t.insert(seq[i + 1]);
        }
      }
    }
    for (auto x : all[i]) {
      if (t.find(x) != t.end()) {
        t.erase(x);
      }
      if (sum[x]++ & 1) {
        ++sum[x];
      }
      s.insert(x);
    }
  }
  for (int i = 1; i <= m; ++i) {
    ans += sum[i];
  }
  printf("%d\n", ans);
#ifdef wxh010910
  Debug("My Time: %.3lfms\n", (double)clock() / CLOCKS_PER_SEC);
#endif
  return 0;
}
wxh010910
关注
buaacoding ?.海洋与陆地
A land whole of flowers.
05-02 501
本来一个很简单的题因为一个极其愚蠢的错误卡了非常久…… 题目描述 **输入：**输入n+1行，第一行为正整数n，表示地图的大小，n<=100 之后n行每行输入n个字符，由*和#组成，其中*表示海洋，#表示陆地 两块陆地在上下左右四个方向上有间接接壤视为同属于一个大陆 例如 *# #* 视为拥有两块大陆 输出有多少块大陆 输入样例 5 *###* **##* #**** #*#** ***#...
buaacoding C.真心话大冒险
A land whole of flowers.
03-29 957
北航的同学扔过来的题目，我不太会写。 你航还真是凶残，同学没语言基础，下半年开学才开始接触C语言，现在就做这种题。 能写出一种能用的算法，就是直接模拟，时间复杂度O(n^2)，空间复杂度(O^2)，实在是谈不上优秀。 抛砖引玉吧。 使用自然下标操作，即从1开始计数。 #include <stdio.h> #define MAX 1000 int n; int order[MAX+1];...
【BUAA 1247】 最短路径问题
ACMer'
06-20 1041
【BUAA 1247】 最短路径问题
BuaaCoding 001-025 Problems and Solutions
sdycodes
05-20 363
汉诺塔、快速幂、Horner Rule、快排、归并、模拟、辗转相除、质数判断
CodeForces Gym 102156 简要题解
wxh010910
04-02 4912
Takeover 每次贪心选增量最小的。 #include <bits/stdc++.h> using namespace std; int main() { #ifdef wxh010910 freopen("input.txt", "r", stdin); #endif ios::sync_with_stdio(false); cin.tie(0); cout....
CodeForces Gym 102056 简要题解
wxh010910
01-09 3520
Exotic … Ancient City 注意到值域很小，所以可以对每种 www 数只考虑 ≤w\le w≤w 的边的连通块个数。维护一个大小为 2n2n2n 的并查集，表示第 iii 列和第 i+1i+1i+1 列的连通性。考虑右移一列并查集的变化，如果在之前的并查集合并了集合 u+n,v+nu+n, v+nu+n,v+n ，那么在新的并查集上 uuu 和 vvv 会变得连通。如果它们已经连通...
CodeForces Gym 101806 简要题解
wxh010910
05-26 2341
Puyo Puyo 首先把有奇数个东西的列用 [1,2],[2,2],[2,2][1,2],[2,2],[2,2][1, 2], [2, 2], [2, 2] 消成偶数个东西，然后依次放就行了。 #include &lt;bits/stdc++.h&gt; using namespace std; #define X first #define Y second #define mp ...
Codeforces gym 102822 简要题解
mayaohua
11-22 800
博主诈尸啦！来更点cf题解。 A. A Colorful Grid 分类讨论鬼题。 先考虑一下最后的网格图的连通性。我们考虑某一个连通块，如果存在某个连通块外的点与连通块内至少两个点相邻，或者至少两个连通块外的点与连通块内某个点相邻，那么连通块都能继续扩大。这样容易发现，最终可能的连通块一定要么是横着切成若干块，要么是竖着切成若干块，当然也可以是整个网格图完全连通。接下来我们的算法是枚举每一类情况，看看是否能构造出解，如果均不行就无解。 如果整个网格图完全连通。不妨设n≤mn\leq mn≤m，若n≤2n\
CodeForces Gym 102055 简要题解
wxh010910
04-22 2026
Mischievous Problem Setter 模拟。 #include <bits/stdc++.h> using namespace std; int main() { #ifdef wxh010910 freopen("input.txt", "r", stdin); #endif ios::sync_with_stdio(false); cin.tie(0...
buaacoding G.CWD的套圈游戏
A land whole of flowers.
04-09 352
计导大作业一点头绪也没有，想不到算法，连暴力都不知道往哪儿用力，话说我还没找到组织，有没有哪个大佬组能把我收了。。。 还是那个北航同学，又扔过来道题目，挺简单的，就是嵌套排序用的不太利索了。 #include <stdio.h> typedef struct _item { int x; int y; int vi; int pi; } Item; int main(int ...
【Linux】CentOS7 常用命令集合
热门推荐
o0DarkNessYY0o的博客
07-30 8万+
这两天一直在对CentOS 7.2进行初体验，各种学习命令肿么用，不过其实大多和DOS是一样的，只是命令的表达上可能有点儿不一样，毕竟这些都不是一家出来的嘛~这里就分享一些近期我常用的CentOS命令给大家，方便学习~
北航校赛 更大公约数（预处理+暴力，好题）
AK_HuangYC的博客
12-21 544
Description 有一个n×m的矩阵，元素是正整数。现在需要删除其某一行的所有元素和某一列的所有元素，使得剩下元素的最大公约数最大。（单个元素的最大公约数是自己） Input 输入包含多组测试数据，以EOF结束。 每组数据第一行两个数n，m，表示矩阵的行数和列数。（2≤n,m≤1061） 下面n行，每行m个正整数，表示矩阵的元素。 Output
第十三届北航程序设计竞赛预赛题解
skywalkert's space
12-19 4654
以下题解由北航 2017-2018 赛季 ACM-ICPC 集训队金牌、银牌成员共同编写而成，比赛链接为 https://buaacoding.cn/contest-ng/index.html#/188。 A. 五角星 B. P5 题目大意 题目解法 线性复杂度 logloglog⁡log\log\log 复杂度 loglog\log 复杂度 数据构造 C. cgxj 的设计师 D....
【贪心】Buaacoding1682 绝望的超时空步兵
BUAA_Alchemist的博客
12-04 853
绝望的超时空步兵 时间限制: 1000 ms 内存限制: 65536 kb 总通过人数: 29 总提交人数: 37 题目描述 超时空步兵的身上有一个可以用来短程传送的装置，但传送的距离是固定的，而且每次传送都要耗费使用者一定的体力值。 现在超时空步兵和大部队走散了，而且他不小心走到了辐射工兵们设下的辐射场里。留给他走出辐射场的时间已经不多了。已知： 超时空步兵每秒能奔跑17米。（请不要在意他这比博...
BuaaCoding100～103动态规划
sdycodes
06-10 216
背包问题、区间dp、递归输出、多重集合组合数
51nod 1406 与查询 DP
TYB的博客
03-14 213
有n个整数。输出他之中和x相与之后结果为x的有多少个。x从0到1，000，000 题解： 令t=akt=akt=a_k&amp;jjj，设f[i][j]f[i][j]f[i][j]表示ttt的前iii位与jjj的前iii位完全一样，后面的位与jjj后面的位完全一样的akaka_k有多少个，初始化为f[0][ai]=cnt[ai]f[0][ai]=cnt[ai]f[0][a_i]=cnt[a...
愤怒的DZY（二分）
weixin_34342578的博客
02-01 132
愤怒的DZY【问题描述】“愤怒的小鸟”如今已经是家喻户晓的游戏了，机智的WJC最近发明了一个类似的新游戏：“愤怒的DZY”。游戏是这样的：玩家有K个DZY，和N个位于不同的整数位置：X1，X2，…，XN的干草包。每一个DZY都可以站在某个位置：X 扔炸弹，扔完炸弹，这个DZY就会挂掉。扔炸弹的半径为R（且每次每个DZY扔炸弹的半径不变，都是R，而站的位置X可以改变）,破坏范围为的X−R~X+R（即...
第十四届北航程序设计竞赛预赛题解（非官方）
BUAA_Alchemist的博客
03-28 862
 最近沙河好多人生病了，我也不能幸免，今天终于舒服了。补一补上周的老坑吧。  接下来尽量每天刷题。另外要加油学习汇编语言，优化我们的密码学竞赛程序。 官方题解参见：http://clatisus.com/BCPC2018_qualification_round A 两等分的Alice https://buaacoding.cn/problem/1914/index  非常容易设计出粗暴的dp。考虑...
https://codeforces.com/gym/104377
最新发布
08-17
Gym是Codeforces的一个扩展包，用于组织私人比赛和训练。您提供的链接指向了一个问题的页面，但具体的问题内容和描述无法通过链接获取。如果您有具体的问题或需要了解关于Codeforces Gym的更多信息，请提供更详细的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值