CodeForces 997 简要题解

最新推荐文章于 2024-10-06 17:16:01 发布
原创 最新推荐文章于 2024-10-06 17:16:01 发布 · 2.8k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文提供了四道算法竞赛题目的解答思路及代码实现：快速翻转字符串中的0为1，罗马数字构成问题，矩阵颜色配置计数，以及区间历史最小值计数问题。

Convert to Ones

翻转操作实际就是合并两段 00 ，特判全 1 的情况，假设有 kk 段 0 ，答案是 (k−1)min(x,y)+y(k−1)min(x,y)+y 。

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N = 300005;

int n, x, y;
char s[N];

int main() {
#ifdef wxh010910
  freopen("input.txt", "r", stdin);
#endif
  scanf("%d %d %d %s", &n, &x, &y, s);
  int result = 0;
  for (int i = 0; i < n; ++i) {
    if (s[i] == '0') {
      while (i < n && s[i] == '0') {
        ++i;
      }
      ++result;
    }
  }
  if (!result) {
    puts("0");
  } else {
    printf("%lld\n", (ll)min(x, y) * (result - 1) + y);
  }
  return 0;
}

Roman Digits

原问题等价于求不同的 4a+9b+49c4a+9b+49c 个数，要求 a+b+c≤na+b+c≤n 。注意到 nn 大于某个定值的时候答案是线性增长的，暴力较小的值就行了。

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int answer[] = {0, 4, 10, 20, 35, 56, 83, 116, 155, 198, 244, 292};

int main() {
#ifdef wxh010910
  freopen("input.txt", "r", stdin);
#endif
  int n;
  scanf("%d", &n);
  if (n < 12) {
    printf("%d\n", answer[n]);
  } else {
    printf("%lld\n", 49ll * (n - 11) + answer[11]);
  }
  return 0;
}

Sky Full of Stars

考虑计算每行每列都有至少 2 种颜色的方案数。如果不考虑行的要求，方案数就是 (3n−3)n(3n−3)n ，否则对行容斥，枚举有 ii 行只有一种颜色，如果这些行都是同色的，那么每一列都不能全是这种颜色，方案数是 (ni)×3(3n−i−1)n ，否则方案数是 (ni)×(3i−3)3n(n−i)(ni)×(3i−3)3n(n−i) 。

answer=3n2−(3n−3)n−∑ni=1(−1)i(ni)(3(3n−i−1)n+(3i−3)3n(n−i))answer=3n2−(3n−3)n−∑i=1n(−1)i(ni)(3(3n−i−1)n+(3i−3)3n(n−i))

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N = 1000005;
const int mod = 998244353;

int n, fac[N], ifac[N];

int add(int x, int y) {
  x += y;
  if (x >= mod) {
    x -= mod;
  }
  return x;
}

int sub(int x, int y) {
  x -= y;
  if (x < 0) {
    x += mod;
  }
  return x;
}

int mul(int x, int y) {
  return (ll)x * y % mod;
}

int power(int x, int y) {
  int result = 1;
  for (; y; y >>= 1, x = mul(x, x)) {
    if (y & 1) {
      result = mul(result, x);
    }
  }
  return result;
}

int binom(int x, int y) {
  return mul(fac[x], mul(ifac[y], ifac[x - y]));
}

int main() {
#ifdef wxh010910
  freopen("input.txt", "r", stdin);
#endif
  scanf("%d", &n);
  fac[0] = fac[1] = ifac[0] = ifac[1] = 1;
  for (int i = 2; i <= n; ++i) {
    fac[i] = mul(fac[i - 1], i);
    ifac[i] = mul(mod - mod / i, ifac[mod % i]);
  }
  for (int i = 2; i <= n; ++i) {
    ifac[i] = mul(ifac[i], ifac[i - 1]);
  }
  int answer = power(power(3, n), n);
  answer = sub(answer, power(sub(power(3, n), 3), n));
  for (int i = 1; i <= n; ++i) {
    int coef = 0;
    coef = add(coef, mul(3, power(sub(power(3, n - i), 1), n)));
    coef = add(coef, mul(sub(power(3, i), 3), power(power(3, n - i), n)));
    coef = mul(coef, binom(n, i));
    if (i & 1) {
      answer = add(answer, coef);
    } else {
      answer = sub(answer, coef);
    }
  }
  printf("%d\n", answer);
  return 0;
}

Cycles in product

设 f(i,j)f(i,j) 表示从第一棵树中 ii 出发走 j 步回到自己的方案数， g(i,j)g(i,j) 表示第二棵树中 ii 出发走 j 步回到自己的方案数，那么 answer=∑mi=0(mi)∑xf(x,i)∑yf(y,m−i)answer=∑i=0m(mi)∑xf(x,i)∑yf(y,m−i) 。

考虑求 f(i,j)f(i,j) ，枚举第一次走向哪棵子树，在子树内走了多少步转移。从下往上，从上往下分别DP一次就能求答案了。

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N = 4005;
const int M = 80;
const int mod = 998244353;

int binom[M][M];

int add(int x, int y) {
  x += y;
  if (x >= mod) {
    x -= mod;
  }
  return x;
}

int sub(int x, int y) {
  x -= y;
  if (x < 0) {
    x += mod;
  }
  return x;
}

int mul(int x, int y) {
  return (ll)x * y % mod;
}

struct tree_t {
  int n, m, dp[N][M], up[N][M], sum[N][M], down[N][M];
  vector<int> adj[N];

  void dpu(int x, int parent) {
    for (auto y : adj[x]) {
      if (y != parent) {
        dpu(y, x);
        for (int i = 0; i <= m; i += 2) {
          sum[x][i] = add(sum[x][i], up[y][i]);
        }
      }
    }
    up[x][0] = 1;
    for (int i = 2; i <= m; i += 2) {
      for (int j = 0; j <= i - 2; j += 2) {
        up[x][i] = add(up[x][i], mul(sum[x][j], up[x][i - j - 2]));
      }
    }
  }

  void dpd(int x, int parent) {
    for (int i = 0; i <= m; i += 2) {
      sum[x][i] = add(sum[x][i], down[x][i]);
    }
    dp[x][0] = 1;
    for (int i = 2; i <= m; i += 2) {
      for (int j = 0; j <= i - 2; j += 2) {
        dp[x][i] = add(dp[x][i], mul(sum[x][j], dp[x][i - j - 2]));
      }
    }
    for (auto y : adj[x]) {
      if (y != parent) {
        for (int i = 0; i <= m; i += 2) {
          sum[x][i] = sub(sum[x][i], up[y][i]);
        }
        down[y][0] = 1;
        for (int i = 2; i <= m; i += 2) {
          for (int j = 0; j <= i - 2; j += 2) {
            down[y][i] = add(down[y][i], mul(sum[x][j], down[y][i - j - 2]));
          }
        }
        for (int i = 0; i <= m; i += 2) {
          sum[x][i] = add(sum[x][i], up[y][i]);
        }
        dpd(y, x);
      }
    }
  }

  void init() {
    for (int i = 1; i < n; ++i) {
      int x, y;
      scanf("%d %d", &x, &y);
      adj[x].push_back(y);
      adj[y].push_back(x);
    }
    dpu(1, 0);
    dpd(1, 0);
  }
} p, q;

int main() {
#ifdef wxh010910
  freopen("input.txt", "r", stdin);
#endif
  int m;
  scanf("%d %d %d", &p.n, &q.n, &m);
  p.m = q.m = m;
  if (m & 1) {
    puts("0");
    return 0;
  }
  p.init();
  q.init();
  for (int i = 0; i <= m; ++i) {
    binom[i][0] = 1;
    for (int j = 1; j <= i; ++j) {
      binom[i][j] = add(binom[i - 1][j], binom[i - 1][j - 1]);
    }
  }
  int answer = 0;
  for (int i = 0; i <= m; i += 2) {
    int x = 0, y = 0;
    for (int j = 1; j <= p.n; ++j) {
      x = add(x, p.dp[j][i]);
    }
    for (int j = 1; j <= q.n; ++j) {
      y = add(y, q.dp[j][m - i]);
    }
    answer = add(answer, mul(binom[m][i], mul(x, y)));
  }
  printf("%d\n", answer);
  return 0;
}

Good Subsegments

如果不要求子区间的话，考虑 (max−min)−(r−l)(max−min)−(r−l) ，不难发现只需要用线段树维护区间最小值和最小值个数就行了。那么这里就是求区间历史最小值个数之和，线段树每个节点维护区间最小值，最小值个数，上次更新的时间，答案，以及对应的标记就可以了。

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N = 120005;

struct node_t {
  int tag, time, value, number;
  ll answer;
} tree[N << 2];

int n, m, top_max, top_min, a[N], stack_max[N], stack_min[N];
vector<pair<int, int>> queries[N];
ll answer[N];

void add_value(int x, int value) {
  tree[x].value += value;
  tree[x].tag += value;
}

void add_time(int x, int value) {
  tree[x].time += value;
  tree[x].answer += (ll)value * tree[x].number;
}

void push_up(int x) {
  tree[x].value = min(tree[x << 1].value, tree[x << 1 | 1].value);
  tree[x].answer = tree[x << 1].answer + tree[x << 1 | 1].answer;
  tree[x].number = 0;
  if (tree[x].value == tree[x << 1].value) {
    tree[x].number += tree[x << 1].number;
  }
  if (tree[x].value == tree[x << 1 | 1].value) {
    tree[x].number += tree[x << 1 | 1].number;
  }
}

void push_down(int x) {
  if (tree[x].tag) {
    add_value(x << 1, tree[x].tag);
    add_value(x << 1 | 1, tree[x].tag);
    tree[x].tag = 0;
  }
  if (tree[x].time) {
    if (tree[x].value == tree[x << 1].value) {
      add_time(x << 1, tree[x].time);
    }
    if (tree[x].value == tree[x << 1 | 1].value) {
      add_time(x << 1 | 1, tree[x].time);
    }
    tree[x].time = 0;
  }
}

void build(int x, int l, int r) {
  tree[x].value = l;
  tree[x].number = 1;
  if (l == r) {
    return;
  }
  int mid = l + r >> 1;
  build(x << 1, l, mid);
  build(x << 1 | 1, mid + 1, r);
}

void modify(int x, int l, int r, int ql, int qr, int value) {
  if (l == ql && r == qr) {
    add_value(x, value);
    return;
  }
  int mid = l + r >> 1;
  push_down(x);
  if (qr <= mid) {
    modify(x << 1, l, mid, ql, qr, value);
  } else if (ql > mid) {
    modify(x << 1 | 1, mid + 1, r, ql, qr, value);
  } else {
    modify(x << 1, l, mid, ql, mid, value);
    modify(x << 1 | 1, mid + 1, r, mid + 1, qr, value);
  }
  push_up(x);
}

ll query(int x, int l, int r, int ql, int qr) {
  if (l == ql && r == qr) {
    return tree[x].answer;
  }
  int mid = l + r >> 1;
  push_down(x);
  if (qr <= mid) {
    return query(x << 1, l, mid, ql, qr);
  } else if (ql > mid) {
    return query(x << 1 | 1, mid + 1, r, ql, qr);
  } else {
    return query(x << 1, l, mid, ql, mid) + query(x << 1 | 1, mid + 1, r, mid + 1, qr);
  }
}

int main() {
#ifdef wxh010910
  freopen("input.txt", "r", stdin);
#endif
  scanf("%d", &n);
  for (int i = 1; i <= n; ++i) {
    scanf("%d", &a[i]);
  }
  scanf("%d", &m);
  for (int i = 1; i <= m; ++i) {
    int l, r;
    scanf("%d %d", &l, &r);
    queries[r].push_back(make_pair(l, i));
  }
  build(1, 1, n);
  for (int i = 1; i <= n; ++i) {
    add_value(1, -1);
    while (top_max && a[stack_max[top_max]] < a[i]) {
      modify(1, 1, n, stack_max[top_max - 1] + 1, stack_max[top_max], a[i] - a[stack_max[top_max]]);
      --top_max;
    }
    stack_max[++top_max] = i;
    while (top_min && a[stack_min[top_min]] > a[i]) {
      modify(1, 1, n, stack_min[top_min - 1] + 1, stack_min[top_min], a[stack_min[top_min]] - a[i]);
      --top_min;
    }
    stack_min[++top_min] = i;
    add_time(1, 1);
    for (auto q : queries[i]) {
      answer[q.second] = query(1, 1, n, q.first, i);
    }
  }
  for (int i = 1; i <= m; ++i) {
    printf("%lld\n", answer[i]);
  }
  return 0;
}
wxh010910
关注
Codeforces 题解 （不断更新，一起上分）
DeathYmz的博客
08-02 9602
目录 Educational Codeforces Round 45 (Rated for Div. 2) Educational Codeforces Round 45 (Rated for Div. 2) 题目：A. Commentary Boxes题解 题目：B Micro-World 题解 题目：C Bracket Sequences Concatenation Problem 题解 题目：D Graph And Its Complement 题解 题目：E Po...
Codeforces Round 997 (Div. 2) D. Unique Median 讲思路更讲推理过程
m0_73788381的博客
01-19 972
CodeforcesRound997(Div.2)的D.UniqueMedian题解
Codeforces题目泛做解题报告许昊然.pdf
05-21
来自2012，2013年国际信息奥林匹克金牌得主许昊然
Codeforces 884 简要题解
weixin_30496431的博客
03-16 249
文章目录A题B题C题D题E题F题 传送门 A题 传送门 题意简述： 一个人要完成一件事总共需要ttt秒，现在有nnn天，每天有aia_iai​不能做事，问他可以在第几天做完。 思路：按照题意模拟。 代码： #include<bits/stdc++.h> #define ri register int using namespace st...
codeforces 题解
忘梦心的博客
01-10 1403
1285A Mezo Playing Zoma 查看题解 字符串 1285B Just Eat It! 查看题解 最大连续子序列 1285C Fadi and LCM 查看题解 数论 1285D Dr. Evil Underscores 查看题解 dfs+位运算 ...
Codeforces 845 简要题解
苟为蒟蒻又何妨
03-22 685
文章目录A题B题C题D题E题F题G题 传送门 A题 传送门 题意：2n2n2n个人下棋，分为两个阵营，每个阵营nnn个人，每个人有一个积分，积分高的能赢积分低的，问如果你可以随意选人，然后每场比赛随机安排对局，最后AAA阵的棋手能否全胜。 思路： 看积分nnn大的和n+1n+1n+1大的积分是否相同 代码： #include<bits/stdc++.h> #define ri re...
Codeforces 1110 简要题解
苟为蒟蒻又何妨
02-08 731
文章目录A题B题C题D题E题F题G题 传送门 众所周知ldxoildxoildxoi这种菜鸡选手是不会写HHH题的，因此该篇博客只有AAA题至GGG题的题解，实在抱歉。 A题 传送门 题意简述：给出b,kb,kb,k和a1,a2,...,aka_1,a_2,...,a_ka1​,a2​,...,ak​问bk−1a1+bk−2a2+...+akb^{k-1}a_1+b^{k-2}a_2+...+a_...
Codeforces1200 简要题解
苟为蒟蒻又何妨
08-13 619
文章目录ABCDEF 传送门 总结一下： CCC题读入进来的时候没开longlonglong longlonglong导致fstfstfst. FFF题最后5min5min5min才发现一个细节读错了最后凉凉. 还是挺遗憾的 A 暴力模拟即可。 #include<bits/stdc++.h> #define ri register int #define fi first #defin...
Codeforces 1197 简要题解
苟为蒟蒻又何妨
07-24 922
文章目录A题B题C题D题EF题 比赛传送门 A题 传送门 排个序然后取a[n−1]−1a[n-1]-1a[n−1]−1与n−2n-2n−2的最小值。 代码： #include<bits/stdc++.h> #define ri register int #define fi first #define se second using namespace std; inline int ...
Codeforces gym 102822 简要题解
mayaohua
11-22 908
博主诈尸啦！来更点cf题解。 A. A Colorful Grid 分类讨论鬼题。 先考虑一下最后的网格图的连通性。我们考虑某一个连通块，如果存在某个连通块外的点与连通块内至少两个点相邻，或者至少两个连通块外的点与连通块内某个点相邻，那么连通块都能继续扩大。这样容易发现，最终可能的连通块一定要么是横着切成若干块，要么是竖着切成若干块，当然也可以是整个网格图完全连通。接下来我们的算法是枚举每一类情况，看看是否能构造出解，如果均不行就无解。 如果整个网格图完全连通。不妨设n≤mn\leq mn≤m，若n≤2n\
每日一题：codeforces题解(Peculiar Movie Preferences)
qq_52598198的博客
02-11 551
题目 B. Peculiar Movie Preferences time limit per test 2 seconds memory limit per test 512 megabytes input standard input output standard output Mihai plans to watch a movie. He only likes palindromic movies, so he wants to skip some (possibly zero) scenes t
Codeforce题解：Shurikens
S__ph的博客
10-27 568
Codeforce 1413 D Shurikens 忍者买手里剑
codeforces #1 题解
知与谁i的博客
11-07 411
codeforces1A 题目链接：http://codeforces.com/problemset/problem/1/A 题意：给定一个n*m的矩形，然后给一个a*a的地板，求最少需要多少地板可以铺满这个矩形（不可以割断，可以重叠） 思路：做除法上取整，然后结果相乘即可，（注意相乘的结果用long long 保存） 【知识点】int数据范围 #include using names
Codeforces 部分题目题解（口胡）
KsCla
12-20 1139
883D题面题目大意：给你一个长度为n的字符串，上面有牛(“P”)，草(“*”)和空地(“.”)。现在你给每一头牛规定一个方向，它会一直往前吃草，直到走到边界。每一份草只会被吃1次，要求输出最多吃多少草，以及在此基础下吃完最后一份草的最小时间。n<=1000000。做法：很明显两头牛就可以吃完所有草，于是暴力处理0,1头牛的情况。然后由于具有单调性，考虑二分答案后贪心（时限3s不虚）。接下来证明两个
Codeforces Round 977 (Div. 2, based on COMPFEST 16 - Final Round) A-C1
Zhou_yu_cong的博客
10-06 984
如果这个数出现过，并且还有多余的。就可以拿来填补下一个没有出现过的数字。所以，只要这个数模x与要填补的数模x一样就可以互相填补。如果有可能完成演示，则默认每个人都去了最优的点。如果这个人已经讲过了，则再次遇到直接跳过。重点关注一次也没讲过的人，他们的相对位置改变不了。一个人演示完了后，可以去任何一个位置。我们不需要考虑它究竟去了哪里，只要知道他去了最有利于满足题目要求的位置。这样就大大化简了题目。因为只能加不能减，所以我们判断这个数用完没有，用完了再加入。思路：贪心，先升序排序，每次组合当前最小的两个数。
Codeforce 1344A Hilbert s Hotel 题解
Brian_Pan_的博客
05-15 310
题目链接 题目大意 有一条数轴，在它的每个整数位置上有一个人 现在对于所有整数 kkk，位置 kkk 上的人会移动到位置 k+akmod  nk+a_{k \mod n}k+akmodn​ 问在所有人移动一次后，是否每个位置上都恰好有一个人 解题思路 我们可以把这题当成图论来做 对于每一个人的移动操作，我们把它视为一条有向边 [k,k+akmod  n][k,k+a_{k \mod n}][k,k+akmodn​] 注意，我么需要把每条边的起点与终点 mod  n\mod nmodn，使得 aaa 中的每一
codeforces 997E 线段树
litble的成(tui)长(fei)史
07-06 1066
我除了WXH天下第一还能说什么呢…… 所谓好区间，就是(max−min)−(r−l)=0(max−min)−(r−l)=0(max-min)-(r-l)=0的区间。 我们将所有询问离线，按照右端点从小到大排序。然后从左到右处理每一个右端点，每次处理时，线段树里维护一下对于每个左端点（这个只需要用单调栈来处理最小值和最大值的更新即可），(max−min)−(r−l)(max−min)−(r−l)...
codeforces 997F Consecutive Subsequence (dp)
henuzxy
05-07 478
题意就是让你找一个最长的公差为1的等差数列，然后输出他们的下标。 思路：用一个map表示到当前这个数的最大长度为多少，则有如下递推公式 mp[a[i]]=mp[a[i]−1]+1mp[a[i]]=mp[a[i]−1]+1mp[a[i]] = mp[a[i]-1] + 1 然后用一个pre记录一下前序就行了。 代码如下: #include&lt;iostream&gt; #incl...
CodeForces 997C Sky Full of Stars
常胜将军的博客
07-14 403
题目：点击打开链接题意：给n*n个格子，每个格子可以填3种颜色。问有多少种填色方案，至少有一列或一行是同色的。分析：首先反过来考虑，找不幸运的组合，因为这样便于容斥。 要把列和行分开考虑。 首先排除掉列上出现相同的情况，也就是(3^n−3)^n种，这个也就是容斥里开始时最大的范围，显然还包括了一些行上相同的情况，所以下面开始容斥。 在列上不出现相同情况下，行出现相同的情况要分两类讨论， 1. 那些...
codeforces round 97
最新发布
03-26
接下来，用户需要问题和解决方案，所以需要简要描述每个题目的问题，并给出解决思路或示例代码。例如，对于构造排列的题目，可能需要排列的特定性质，如相邻元素满足某种条件。对于时间安排问题，可能需要计算每个...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值