CSP 2020-S 题解

R I P

$\Huge \mathbb{RIP}$

the problem setter

$\texttt{the problem setter}$

(1582 / 10 / 5 \sim 1582 / 10 / 14)

$(1582/10/5 \sim 1582/10/14)$

- 写在前面
- A
  - 正解
  - 暴力
- B
  - 正解
  - 暴力
- C
  - 正解
  - 暴力
- D
  - 20pts
- 70pts
- 100pts
写在后面

写在前面

挂了。
noip 还是要打的。
先来补题了，补游记看心情。

A

$\Huge \mathbb{RIP}$
$\texttt{the problem setter}$
$(1582/10/5 \sim 1582/10/14)$

正解

参考：这位神仙的提交记录。

$Q\le 10^5$ ，允许在每次询问进行一个 $O(1000)$ 的暴力。
暴力可知 $1582.10.5$ 的儒略历是 $2299161$ ，以该日期为分界线处理。

对于 $r<2299161$ ，依次计算剩下的天数中有几个 $4$ 年、 $1$ 年、 $1$ 月，再加上天数。
对于 $r\ge 2299161$ ，先将日期转化为 $1583.1.1$ ，再依次计算剩下的天数中有几个 $400$ 年、 $4$ 年、 $1$ 年、 $1$ 月，再加上天数。

复杂度上界约为 $O(4\times 10^7)$ 。

复制复制 //知识点：模拟 
/*
By:Luckyblock
*/
#include <algorithm>
#include <cctype>
#include <cstdio>
#include <cstring>
#define LL long long
const int kInf = 1e9 + 10;
const LL D[15] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 0};
//=============================================================
LL r, d, m, y;
//=============================================================
inline LL read() {
  LL f = 1, w = 0;
  char ch = getchar();
  for (; !isdigit(ch); ch = getchar())
    if (ch == '-') f = -1;
  for (; isdigit(ch); ch = getchar()) w = (w << 3) + (w << 1) + (ch ^ '0');
  return f * w;
}
void Chkmax(int &fir_, int sec_) {
  if (sec_ > fir_) fir_ = sec_;
}
void Chkmin(int &fir_, int sec_) {
  if (sec_ < fir_) fir_ = sec_;
}
bool Judge(LL y_) {
  if (y_ <= 1582ll) return 1ll * (y_ % 4ll == 0);
  return 1ll * (y_ % 400ll == 0) || (y_ % 4ll == 0 && y_ % 100ll != 0ll);
}
void Solve1() {
  d = 1, m = 1, y = -4712;
  LL cnt = (r / (3ll * 365ll + 366ll));
  y += 4ll * cnt, r -= cnt * (3ll * 365ll + 366ll);
  for (int i = 1; i <= 3; ++ i) {
    LL delta = 365ll + Judge(y);
    if (delta > r) break;
    ++ y;
    r -= delta;
  }
  for (int i = 1; i <= 12; ++ i) {
    LL delta = D[i] + (i == 2 && Judge(y));
    if (delta > r) break;
    ++ m;
    r -= delta;
  }
  d += r;
}
LL Solve2() {
  r -= 2299161ll;
  d = 15, m = 10, y = 1582;
  if (r <= 16ll) return d += r;
  d = 1, m ++, r -= 17ll;
  if (r < 30ll) return d += r;  
  m ++, r -= 30ll;
  if (r < 31ll) return d += r;
  m = 1, y ++, r -= 31ll;
  
  LL cnt = r / (1ll * (97 * 366 + 303 * 365));
  y += 400ll * cnt, r -= cnt * 1ll * (97 * 366 + 303 * 365);
  for (int i = 1; i <= 400; ++ i) {
    LL delta = 365ll + 1ll * Judge(y);
    if (delta > r) break;
    ++ y;
    r -= delta;
  }
  for (int i = 1; i <= 12; ++ i) {
    LL delta = D[i] + 1ll * (i == 2 && Judge(y));
    if (delta > r) break;
    ++ m;
    r -= delta;
  }
  return d += r;
}
//=============================================================
int main() {
  int T = read();
  while (T --) {
    r = read();
    if (r < 2299161ll) {
      Solve1();
    } else {
      LL koishi = Solve2();  
    }
    
    if (y <= 0) {
      printf("%lld %lld %lld BC\n", d, m, -y + 1);
    } else {
      printf("%lld %lld %lld\n", d, m, y);
    }
  }
  return 0;
}

暴力

 //知识点：模拟 
/*
By:Luckyblock
*/
#include <algorithm>
#include <cstdio>
#include <cctype>
#include <cstring>
#define LL long long
const int N = 100000 + 10;
const LL D[15] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
//==================================================
LL d = 1, m = 1, y = -4713;
//==================================================
LL read() {
  LL f = 1, w = 0; char ch = getchar();
  for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -1;
  for (; isdigit(ch); ch = getchar()) w = 10 * w + ch - '0';
  return f * w;
}
void SolveBC() {
  ++ d;
  if (d > D[m]) {
    if (m == 2 && 
        d == 29 && 
        (- y - 1ll) % 4 == 0) {
      int koishi;
    } else {
      ++ m;
      d = 1;  
    }
  }
  if (m > 12) {
    ++ y;
    m = 1;
  }
  if (y == 0) y = 1;
}
void Solve1() {
  ++ d;
  if (d > D[m]) {
    if (m == 2 && 
        d == 29 && 
        y % 4 == 0) {
      int koishi;
    } else {
      ++ m;
      d = 1;  
    }
  }
  if (m > 12) {
    ++ y;
    m = 1;
  }
  
  if (5 == d && m == 10 && y == 1582) {
    d = 15;
  }
}
 
void Solve2() {
  bool yes = false;
  if (y % 400 == 0) yes = true;
  if (y % 4 == 0 && y % 100 != 0) yes = true;
  ++ d;
  if (d > D[m]) {
    if (m == 2 && d == 29 && yes) {
      int koishi;
    } else {
      ++ m;
      d = 1;  
    }
  }
  if (m > 12) {
    ++ y;
    m = 1;
  }
}
//==================================================
int main() {
//  freopen("julian.in", "r", stdin);
//  freopen("julian.out", "w", stdout);
  int T;
  scanf("%d", &T);
  while (T --) {
    LL r = read();
    {
      d = 1, m = 1, y = -4713;
      while (r --) {
        if (y < 0) SolveBC();
        else if (y <= 1582) Solve1();
        else Solve2();
      }
      if (y < 0) {
        printf("%lld %lld %lld BC\n", d, m, -y);
      } else {
        printf("%lld %lld %lld\n", d, m, y);
      }
      continue ;
    }
  }
  return 0;
}
/*
1721424
2299161
*/

B

正解

给定的要求，实际上是对动物编号二进制中某一位 01 情况的限制。
若某条件满足，则存在一种动物的二进制该位为 1。
一种原来不存在的动物不能加入动物园的条件是该动物满足了 原来不满足 的一条要求，即其某二进制位上为 1。

可以通过位运算简单得到多少位上可以为 1，设有 $k'$ 位，答案即为 $2^{k'} - n$ 。

注意特判答案为 $2^{64}$ 的情况。 $2^{64}-1$ 可以通过 ull 溢出得到。

时间复杂度 $O(n + m)$ 。

 //知识点：瞎搞
/*
By:Luckyblock
*/
#include <algorithm>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <iostream>
#define ULL unsigned long long
const int N = 1e6 + 10;
//==================================================
int n, m, c, k, num, noneed[N];
ULL havea, havec, ans;
//==================================================
int read() {
  int f = 1, w = 0; char ch = getchar();
  for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -1;
  for (; isdigit(ch); ch = getchar()) w = 10 * w + ch - '0';
  return f * w;
}
//==================================================
int main() {
  n = read(), m = read(), c = read(), k = read();
  for (int i = 1; i <= n; ++ i) {
    ULL a;
    std::cin >> a;
    havea |= a;
  }
  for (int i = 1; i <= m; ++ i) {
    int p = read(), q = read();
    if (! ((1ull << (1ull * p)) & havea)) { //所有q 不相同 
      num += ! noneed[p];
      noneed[p] = true; //第 p 位上为 1 是不合法的，会加入新饲料 
    }
  }
  if ((k - num) == 64) {
    if (! n) {
      printf("18446744073709551616\n");
      return 0;
    } else {
      ans = 0 - n; 
    }
  } else {
    ans = (1ull << (1ull * k -num)) - 1ull * n; 
  }
  std::cout << ans;
  return 0;
}

暴力

 //
/*
By:Luckyblock
*/
#include <algorithm>
#include <cstdio>
#include <cctype>
#include <cstring>
#define LL long long
#define ULL unsigned long long
const int N = 2e6 + 10;
//==================================================
int n, m, c, k, ans, a[N];
int p[N], q[N];
bool visa[N], visc[N];
//==================================================
int read() {
  int f = 1, w = 0; char ch = getchar();
  for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -1;
  for (; isdigit(ch); ch = getchar()) w = 10 * w + ch - '0';
  return f * w;
}
//==================================================
int main() {
  n = read(), m = read(), c = read(), k = read();
  for (int i = 1; i <= n; ++ i) {
    a[i] = read();
    visa[a[i]] = true;
  }
  for (int i = 1; i <= m; ++ i) {
    p[i] = read(), q[i] = read();
    for (int j = 1; j <= n; ++ j) {
      if ((a[j] >> p[i]) & 1) {
        visc[q[i]] = true;
        break;
      }
    }
  }
  
  for (int i = 0, lim = (1 << k) - 1; i <= lim; ++ i) {
    if (visa[i]) continue ;
    int flag = 1;
    for (int j = 1; j <= m; ++ j) {
      if ((i >> p[j]) & (! visc[q[j]])) {
        flag = 0;
        break;
      }
    }
    ans += flag;
  }
  printf("%d\n", ans);
  return 0;
}

C

正解

参考：又一位神仙的提交记录。
参考代码中没有判 $a_i=0$ 的情况，牛客数据比较水卡过了（

先根据拓扑序记忆化搜索，求得每个操作 3 的乘法增量 mul，即会令各元素变为之前的多少倍。
完成上述过程后，可顺便得到乘法操作对原数的影响。

再考虑加法操作，再在拓扑序上 DP，求得每种操作被调用多少次，注意倒序进行，通过调用者更新被调用者。
某加法操作的贡献为调用次数 + 影响到它乘法操作的次数。
两者贡献量相同，在代码中用 cnt 记录了两者的和。

最后还原原数即可，时间复杂度 $O(n+m)$ 。

 //知识点：拓扑排序，DP
/*
By:Luckyblock
*/
#include <algorithm>
#include <cctype>
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
#define LL long long
const LL mod = 998244353;
const int N = 1e5 + 10;
//=============================================================
int n, m, q_num, t[N], pos[N], c[N], into[N], q[N];
LL a[N], val[N], cnt[N];
LL mul[N];
std::vector <int> v[N];
//=============================================================
inline int read() {
  int f = 1, w = 0;
  char ch = getchar();
  for (; !isdigit(ch); ch = getchar()) 
    if (ch == '-') f = -1;
  for (; isdigit(ch); ch = getchar()) {
    w = (w << 3) + (w << 1) + (ch ^ '0');
  } 
  return f * w;
}
void Chkmax(int &fir_, int sec_) {
  if (sec_ > fir_) fir_ = sec_;
}
void Chkmin(int &fir_, int sec_) {
  if (sec_ < fir_) fir_ = sec_;
}
void Prepare() {
  n = read();
  for (int i = 1; i <= n; ++ i) a[i] = read();
  m = read();
  for (int i = 1; i <= m; ++ i) {
    t[i] = read();
    if (t[i] == 1) {
      pos[i] = read(), val[i] = read();
    } else if (t[i] == 2) {
      val[i] = read();
    } else if (t[i] == 3) {
      c[i] = read();
      for (int j = 1; j <= c[i]; ++ j) { //
        int v_ = read();
        v[i].push_back(v_);
        into[v_] ++;
      }
    }
  }
}
LL Dfs(int u_) {
  if (mul[u_] != -1) return mul[u_];
  if (t[u_] != 3) {
    mul[u_] = (t[u_] == 1) ? 1 : val[u_];
    return mul[u_];
  }
  mul[u_] = 1;
  for (int i = c[u_] - 1; i >= 0; -- i) {
    int v_ = v[u_][i];
    mul[u_] = mul[u_] * Dfs(v_) % mod;
  }
  return mul[u_];
}
void Topsort() {
  std::queue <int> q;
  for (int i = 1; i <= m; ++ i) {
    if (! into[i]) {
      q.push(i);
    }
  }
  while (! q.empty()) {
    int u_ = q.front();
    q.pop();
    LL prod = 1;
    for (int i = c[u_] - 1; i >= 0; -- i) {
      int v_ = v[u_][i];
      cnt[v_] = (cnt[v_] + prod * cnt[u_] % mod) % mod;
      into[v_] --;
      if (! into[v_]) {
        q.push(v_);
      }
      prod = prod * mul[v_] % mod;
    }
  }
  for (int i = 1; i <= m; ++ i) {
    if (t[i] == 1) {
      a[pos[i]] = (a[pos[i]] + val[i] * cnt[i] % mod) % mod;
    }
  }
}
//=============================================================
int main() {
  Prepare();
  memset(mul, -1, sizeof (mul));
  for (int i = 1; i <= m; ++ i) {
    if (! into[i]) {
      mul[i] = Dfs(i);
    }
  }
  
  q_num = read();
  for (int i = 1; i <= q_num; ++ i) q[i] = read();
  LL prod = 1;
  for (int i = q_num; i; i --) {
    cnt[q[i]] = (prod + cnt[q[i]]) % mod;
    prod = prod * mul[q[i]] % mod;
  }
  for (int i = 1; i <= n; ++ i) {
    a[i] = a[i] * prod % mod;
  }
  Topsort();
  for (int i = 1; i <= n; ++ i) printf("%lld ", a[i]);
  return 0;
}

暴力

通过递归实现，分治了 seg 的情况。

 //
/*
By:Luckyblock
*/
#include <algorithm>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <vector>
#define LL long long
const int N = 1e5 + 10;
const int M = 1e6 + 10;
const LL mod = 998244353;
//==================================================
int n, m, a[N], t[N];
int pos[N], val[N]; //不依赖 
int alltim, prod, tim[N];
//==================================================
int read() {
  int f = 1, w = 0; char ch = getchar();
  for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -1;
  for (; isdigit(ch); ch = getchar()) w = 10 * w + ch - '0';
  return f * w;
}
namespace Sub1 {
  const int SN = 1010;
  std::vector <int> g[SN]; //依赖 
  
  void Modify(int now_) {
    int lim = g[now_].size();
    for (int i = 0; i < lim; ++ i) {
      int opt = g[now_][i];
      if (t[opt] == 3) Modify(opt);
      if (t[opt] == 1) {
        a[pos[opt]] = 1ll * (1ll * a[pos[opt]] + 1ll * val[opt]) % mod;
      }
      if (t[opt] == 2) {
        for (int j = 1; j <= n; ++ j) {
          a[j] = 1ll * a[j] * val[opt] % mod;
        }
      }
    }
  }
  void Solve() {
    for (int i = 1; i <= m; ++ i) {
      t[i] = read();
      if (t[i] == 1) {
        pos[i] = read(), val[i] = read();
      } else if (t[i] == 2) {
        val[i] = read();
      } else {
        int c = read();
        for (int j = 1; j <= c; ++ j) {
          int nowg = read();
          g[i].push_back(nowg);
        }
      }
    }
    
    int q = read();
    for (int i = 1; i <= q; ++ i) {
      int opt = read();
      if (t[opt] == 3) Modify(opt);
      if (t[opt] == 1) {
        a[pos[opt]] = 1ll * (1ll * a[pos[opt]] + 1ll * val[opt]) % mod;
      }
      if (t[opt] == 2) {
        for (int j = 1; j <= n; ++ j) {
          a[j] = 1ll * a[j] * val[opt] % mod;
        }
      }
    }
    for (int i = 1; i <= n; ++ i) {
      printf("%d ", a[i]);
    }
  }
}
 
namespace Seg {
  #define ls (now_<<1)
  #define rs (now_<<1|1)
  #define mid ((L_+R_)>>1)
  int tag[N << 2], sum[N << 2];
  void Build(int now_, int L_, int R_) {
    tag[now_] = 1;
    if (L_ == R_) {
      sum[now_] = a[L_];
      return ;
    }
    Build(ls, L_, mid);
    Build(rs, mid + 1, R_);
  }
  void Pushdown(int now_) {
    if (tag[now_] == 1) return ;
    sum[ls] = 1ll * sum[ls] * tag[now_] % mod;
    sum[rs] = 1ll * sum[rs] * tag[now_] % mod;
    tag[ls] = 1ll * (1ll * tag[ls] * tag[now_]) % mod;
    tag[rs] = 1ll * (1ll * tag[rs] * tag[now_]) % mod;
    tag[now_] = 1;
  }
  void Modify1(int now_, int L_, int R_, int pos_, int val_) {
    if (L_ == R_) {
      sum[now_] = 1ll * (1ll * sum[now_] + 1ll * val_) % mod;
      return ;
    }
    Pushdown(now_);
    if (pos_ <= mid) Modify1(ls, L_, mid, pos_, val_);
    else Modify1(rs, mid + 1, R_, pos_, val_);
  }
  void Modify2(int val_) {
    Pushdown(1);
    tag[1] = (tag[1] * val_) % mod;
  }
  void Query(int now_, int L_, int R_) {
    if (L_ == R_) {
      printf("%d ", sum[now_]);
      return ; 
    }
    Pushdown(now_);
    Query(ls, L_, mid);
    Query(rs, mid + 1, R_);
  }
  #undef ls
  #undef rs
  #undef mid
}
//==================================================
int main() {
//  freopen("call.in", "r", stdin);
//  freopen("call.out", "w", stdout);
  n = read();
  for (int i = 1; i <= n; ++ i) a[i] = read();
  m = read();
  
  if (n <= 1000 && m <= 1000) {
    Sub1::Solve();
    return 0;
  }
  
  for (int i = 1; i <= m; ++ i) {
    t[i] = read();
    if (t[i] == 1) {
      pos[i] = read(), val[i] = read();
    } else if (t[i] == 2) {
      val[i] = read();
    } else {
      int c = read();
    }
  }
  
  Seg::Build(1, 1, n);
  int q = read();
  while (q --) {
    int opt = read();
    if (t[opt] == 3) continue ;
    if (t[opt] == 1) {
      Seg::Modify1(1, 1, n, pos[opt], val[opt]);
    }
    if (t[opt] == 2) {
      Seg::Modify2(val[opt]);
    }
  }
  Seg::Query(1, 1, n);
  return 0;
}
/*
5
1 2 3 4 5 
2
1 1 1
2 2
3
1 2 1
*/

D

20pts

手玩几组小样例可得结论。

第三条蛇若可以连吃则吃，答案为 1。
否则吃掉第一条后就会被第二条吃掉，不吃更好，答案为 3。

 //
/*
By:Luckyblock
*/
#include <algorithm>
#include <cstdio>
#include <cctype>
#include <cstring>
#define LL long long
const int N = 1e5 + 10;
//==================================================
struct Sna {
  int pos, a;
} ori[N], a[N];
int n;
//==================================================
int read() {
  int f = 1, w = 0; char ch = getchar();
  for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -1;
  for (; isdigit(ch); ch = getchar()) w = 10 * w + ch - '0';
  return f * w;
}
//==================================================
int main() {
  int T = read();
  for (int nowT = 1; nowT <= T; ++ nowT) {
    if (nowT == 1) {
      n = read();
      for (int i = 1; i <= n; ++ i) {
        ori[i] = a[i] = (Sna) {i, read()};
      }  
    } else {
      int k = read();
      for (int i = 1; i <= k; ++ i) {
        int p = read();
        ori[p].a = read();
      }
      for (int i = 1; i <= n; ++ i) {
        a[i] = ori[i];
      }
    }
    
    int ans = n;
    if (n == 3) {
      if (a[3].a - a[1].a >= a[2].a) {
        ans = 1;
      } else {
        ans = 3;
      }
      printf("%d\n", ans);
      continue ;
    }
  }
  return 0;
}

70pts

在每一个回合中，若发生吞噬，则只会是最牛逼的蛇吃掉最傻逼的蛇。则操作的序列是固定的，考虑构造出这个序列，并根据这个序列求得第一个操作不进行的回合，即得答案。

考虑如何构建操作序列。
当 $n=3$ 时，按照上述 20pts 思路进行特判。
当 $n>3$ 时，需要一种支持查询最大值，最小值，动态插入删除的数据结构，平衡树简单维护即可，这里偷懒写了 multiset。

再考虑如何求得第一个操作不进行的回合。
站在最牛逼的蛇的角度想，只有它在吃掉最傻逼蛇后的所有回合中 都会不被吃掉，操作才会进行。
这里的所有回合指该回合之后，直到第一个一定不会进行操作的回合。
考虑倒序枚举操作序列，标记所有蛇是否被削除，枚举到被删除蛇时判断即可。

答案为 第一个 不会进行的回合时剩下的蛇的数量。
实现上有些细节，详见代码。

 //知识点：贪心，单调性 
/*
By:Luckyblock
70pts 
*/
#include <algorithm>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <set>
#define LL long long
const int N = 1e6 + 10;
//==================================================
int n, o_num, a[N], opt[N]; //opt：删除顺序
bool suc[N], del[N]; 
//sucess：第 i 次是否成功，del：第 i 个是否已被删除 
 
struct Snake { //蛇蛇兄弟 
  int val, id;
  bool operator < (const Snake &sec_) const {
    if (val != sec_.val) return sec_.val > val;
    return sec_.id > id;
  }
};
std::multiset <Snake> s[11];
//==================================================
int read() {
  int f = 1, w = 0; char ch = getchar();
  for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -1;
  for (; isdigit(ch); ch = getchar()) w = 10 * w + ch - '0';
  return f * w;
}
void Init(int nowt_) {
  o_num = 0;
  memset(suc, 0, sizeof (suc));
  memset(del, 0, sizeof (del));
  
  if (nowt_ == 1) {
    n = read();
    for (int i = 1; i <= n; ++ i) a[i] = read();
  } else {
    int k = read();
    for (int i = 1; i <= k; ++ i) {
      int p = read();
      a[p] = read();
    }
  }
}
void Solve(int now_, int lth_) {
  Snake fir = *s[now_].begin(), las = *s[now_].rbegin();
  if (s[now_].size() == 3) { //n = 3 特殊情况 
    std::multiset <Snake>::iterator it = s[now_].begin();
    ++ it;
    if (las.val - fir.val < (*it).val || 
        (las.val - fir.val == (*it).val && las.id < (*it).id)) {
      suc[lth_] = false;
    } else {
      suc[lth_] = suc[lth_ + 1] = true;
      opt[++ o_num] = fir.id;
      opt[++ o_num] = (*it).id;
      del[fir.id] = del[(*it).id] = true;
    }
    return ;
  }
  
  s[now_].erase(s[now_].find(las));
  s[now_].erase(s[now_].begin());
  s[now_].insert((Snake) {las.val - fir.val, las.id});
  Solve(now_, lth_ + 1);
  
  if (!del[las.id]) { //本次最大值在之后不会被删除。
    suc[lth_] = true;
    opt[++ o_num] = fir.id; //
    del[fir.id] = true;
  } else { //本次删除不成功，清除记录的之后的删除操作。 
    for (int i = 1; i <= o_num; ++ i) del[opt[i]] = false;
    o_num = 0;
  }
}
//==================================================
int main() {
  int T = read();
  for (int nowt = 1; nowt <= T; ++ nowt) {
    Init(nowt);
    for (int i = 1; i <= n; ++ i) {
      s[nowt].insert((Snake) {a[i], i});
    }
    Solve(nowt, 0);
    for (int i = 0; i < n; ++ i) {
      if (! suc[i]) { //找到 **第一个** 不成功的位置 
        printf("%d\n", n - i);
        break ;
      }
    }
  }
  return 0;
}

100pts

这个单调性的证明还不是很懂，之后再补。
贴俩神仙的博客，可以来这里学习：

题解贪吃蛇 - fight for dream - 洛谷博客。
营业日志 2020.11.7 一次信息不对称引发的 CSP2020 T4 讨论 - EntropyIncreaser 的博客 - 洛谷博客。

写在后面

这就算暂时告一段落了= =

posted @ 2020-11-08 19:45 Luckyblock 阅读(2599) 评论(4) 编辑收藏举报

刷新页面返回顶部

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

阅读排行：
· 单线程的Redis速度为什么快？
· 展开说说关于C#中ORM框架的用法！
· Pantheons：用 TypeScript 打造主流大模型对话的一站式集成库
· SQL Server 2025 AI相关能力初探
· 为什么退出登录或修改密码无法使 token 失效

公告

MathJax 渲染格式改为 SVG，缩放倍率调至 125%，可获得更好的阅读效果。

博客首页仅显示部分高质量博文，大部分博文都位于随笔分类中。请善用下方的搜索功能。

大部分博文密码为某大质数。

昵称： Luckyblock
园龄： 5年6个月
粉丝： 242
关注： 149

+加关注

Luckyblock

身与华落，心将香飞

CSP 2020-S 题解

写在前面

A

正解

暴力

B

正解

暴力

C

正解

暴力

D

20pts

70pts

100pts

写在后面

公告

搜索

积分与排名

随笔分类 (530)

相册 (32)

友链

阅读排行榜

最新评论

	//知识点：模拟
	/*
	By:Luckyblock
	*/
	#include <algorithm>
	#include <cctype>
	#include <cstdio>
	#include <cstring>
	#define LL long long
	const int kInf = 1e9 + 10;
	const LL D[15] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 0};
	//=============================================================
	LL r, d, m, y;
	//=============================================================
	inline LL read() {
	LL f = 1, w = 0;
	char ch = getchar();
	for (; !isdigit(ch); ch = getchar())
	if (ch == '-') f = -1;
	for (; isdigit(ch); ch = getchar()) w = (w << 3) + (w << 1) + (ch ^ '0');
	return f * w;
	}
	void Chkmax(int &fir_, int sec_) {
	if (sec_ > fir_) fir_ = sec_;
	}
	void Chkmin(int &fir_, int sec_) {
	if (sec_ < fir_) fir_ = sec_;
	}
	bool Judge(LL y_) {
	if (y_ <= 1582ll) return 1ll * (y_ % 4ll == 0);
	return 1ll * (y_ % 400ll == 0) \|\| (y_ % 4ll == 0 && y_ % 100ll != 0ll);
	}
	void Solve1() {
	d = 1, m = 1, y = -4712;
	LL cnt = (r / (3ll * 365ll + 366ll));
	y += 4ll * cnt, r -= cnt * (3ll * 365ll + 366ll);
	for (int i = 1; i <= 3; ++ i) {
	LL delta = 365ll + Judge(y);
	if (delta > r) break;
	++ y;
	r -= delta;
	}
	for (int i = 1; i <= 12; ++ i) {
	LL delta = D[i] + (i == 2 && Judge(y));
	if (delta > r) break;
	++ m;
	r -= delta;
	}
	d += r;
	}
	LL Solve2() {
	r -= 2299161ll;
	d = 15, m = 10, y = 1582;
	if (r <= 16ll) return d += r;
	d = 1, m ++, r -= 17ll;
	if (r < 30ll) return d += r;
	m ++, r -= 30ll;
	if (r < 31ll) return d += r;
	m = 1, y ++, r -= 31ll;

	LL cnt = r / (1ll * (97 * 366 + 303 * 365));
	y += 400ll * cnt, r -= cnt * 1ll * (97 * 366 + 303 * 365);
	for (int i = 1; i <= 400; ++ i) {
	LL delta = 365ll + 1ll * Judge(y);
	if (delta > r) break;
	++ y;
	r -= delta;
	}
	for (int i = 1; i <= 12; ++ i) {
	LL delta = D[i] + 1ll * (i == 2 && Judge(y));
	if (delta > r) break;
	++ m;
	r -= delta;
	}
	return d += r;
	}
	//=============================================================
	int main() {
	int T = read();
	while (T --) {
	r = read();
	if (r < 2299161ll) {
	Solve1();
	} else {
	LL koishi = Solve2();
	}

	if (y <= 0) {
	printf("%lld %lld %lld BC\n", d, m, -y + 1);
	} else {
	printf("%lld %lld %lld\n", d, m, y);
	}
	}
	return 0;
	}

	//知识点：瞎搞
	/*
	By:Luckyblock
	*/
	#include <algorithm>
	#include <cstdio>
	#include <cctype>
	#include <cstring>
	#include <iostream>
	#define ULL unsigned long long
	const int N = 1e6 + 10;
	//==================================================
	int n, m, c, k, num, noneed[N];
	ULL havea, havec, ans;
	//==================================================
	int read() {
	int f = 1, w = 0; char ch = getchar();
	for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -1;
	for (; isdigit(ch); ch = getchar()) w = 10 * w + ch - '0';
	return f * w;
	}
	//==================================================
	int main() {
	n = read(), m = read(), c = read(), k = read();
	for (int i = 1; i <= n; ++ i) {
	ULL a;
	std::cin >> a;
	havea \|= a;
	}
	for (int i = 1; i <= m; ++ i) {
	int p = read(), q = read();
	if (! ((1ull << (1ull * p)) & havea)) { //所有q 不相同
	num += ! noneed[p];
	noneed[p] = true; //第 p 位上为 1 是不合法的，会加入新饲料
	}
	}
	if ((k - num) == 64) {
	if (! n) {
	printf("18446744073709551616\n");
	return 0;
	} else {
	ans = 0 - n;
	}
	} else {
	ans = (1ull << (1ull * k -num)) - 1ull * n;
	}
	std::cout << ans;
	return 0;
	}

	//知识点：拓扑排序，DP
	/*
	By:Luckyblock
	*/
	#include <algorithm>
	#include <cctype>
	#include <cstdio>
	#include <cstring>
	#include <queue>
	#include <vector>
	#define LL long long
	const LL mod = 998244353;
	const int N = 1e5 + 10;
	//=============================================================
	int n, m, q_num, t[N], pos[N], c[N], into[N], q[N];
	LL a[N], val[N], cnt[N];
	LL mul[N];
	std::vector <int> v[N];
	//=============================================================
	inline int read() {
	int f = 1, w = 0;
	char ch = getchar();
	for (; !isdigit(ch); ch = getchar())
	if (ch == '-') f = -1;
	for (; isdigit(ch); ch = getchar()) {
	w = (w << 3) + (w << 1) + (ch ^ '0');
	}
	return f * w;
	}
	void Chkmax(int &fir_, int sec_) {
	if (sec_ > fir_) fir_ = sec_;
	}
	void Chkmin(int &fir_, int sec_) {
	if (sec_ < fir_) fir_ = sec_;
	}
	void Prepare() {
	n = read();
	for (int i = 1; i <= n; ++ i) a[i] = read();
	m = read();
	for (int i = 1; i <= m; ++ i) {
	t[i] = read();
	if (t[i] == 1) {
	pos[i] = read(), val[i] = read();
	} else if (t[i] == 2) {
	val[i] = read();
	} else if (t[i] == 3) {
	c[i] = read();
	for (int j = 1; j <= c[i]; ++ j) { //
	int v_ = read();
	v[i].push_back(v_);
	into[v_] ++;
	}
	}
	}
	}
	LL Dfs(int u_) {
	if (mul[u_] != -1) return mul[u_];
	if (t[u_] != 3) {
	mul[u_] = (t[u_] == 1) ? 1 : val[u_];
	return mul[u_];
	}
	mul[u_] = 1;
	for (int i = c[u_] - 1; i >= 0; -- i) {
	int v_ = v[u_][i];
	mul[u_] = mul[u_] * Dfs(v_) % mod;
	}
	return mul[u_];
	}
	void Topsort() {
	std::queue <int> q;
	for (int i = 1; i <= m; ++ i) {
	if (! into[i]) {
	q.push(i);
	}
	}
	while (! q.empty()) {
	int u_ = q.front();
	q.pop();
	LL prod = 1;
	for (int i = c[u_] - 1; i >= 0; -- i) {
	int v_ = v[u_][i];
	cnt[v_] = (cnt[v_] + prod * cnt[u_] % mod) % mod;
	into[v_] --;
	if (! into[v_]) {
	q.push(v_);
	}
	prod = prod * mul[v_] % mod;
	}
	}
	for (int i = 1; i <= m; ++ i) {
	if (t[i] == 1) {
	a[pos[i]] = (a[pos[i]] + val[i] * cnt[i] % mod) % mod;
	}
	}
	}
	//=============================================================
	int main() {
	Prepare();
	memset(mul, -1, sizeof (mul));
	for (int i = 1; i <= m; ++ i) {
	if (! into[i]) {
	mul[i] = Dfs(i);
	}
	}

	q_num = read();
	for (int i = 1; i <= q_num; ++ i) q[i] = read();
	LL prod = 1;
	for (int i = q_num; i; i --) {
	cnt[q[i]] = (prod + cnt[q[i]]) % mod;
	prod = prod * mul[q[i]] % mod;
	}
	for (int i = 1; i <= n; ++ i) {
	a[i] = a[i] * prod % mod;
	}
	Topsort();
	for (int i = 1; i <= n; ++ i) printf("%lld ", a[i]);
	return 0;
	}

	//知识点：贪心，单调性
	/*
	By:Luckyblock
	70pts
	*/
	#include <algorithm>
	#include <cstdio>
	#include <cctype>
	#include <cstring>
	#include <set>
	#define LL long long
	const int N = 1e6 + 10;
	//==================================================
	int n, o_num, a[N], opt[N]; //opt：删除顺序
	bool suc[N], del[N];
	//sucess：第 i 次是否成功，del：第 i 个是否已被删除

	struct Snake { //蛇蛇兄弟
	int val, id;
	bool operator < (const Snake &sec_) const {
	if (val != sec_.val) return sec_.val > val;
	return sec_.id > id;
	}
	};
	std::multiset <Snake> s[11];
	//==================================================
	int read() {
	int f = 1, w = 0; char ch = getchar();
	for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -1;
	for (; isdigit(ch); ch = getchar()) w = 10 * w + ch - '0';
	return f * w;
	}
	void Init(int nowt_) {
	o_num = 0;
	memset(suc, 0, sizeof (suc));
	memset(del, 0, sizeof (del));

	if (nowt_ == 1) {
	n = read();
	for (int i = 1; i <= n; ++ i) a[i] = read();
	} else {
	int k = read();
	for (int i = 1; i <= k; ++ i) {
	int p = read();
	a[p] = read();
	}
	}
	}
	void Solve(int now_, int lth_) {
	Snake fir = s[now_].begin(), las = s[now_].rbegin();
	if (s[now_].size() == 3) { //n = 3 特殊情况
	std::multiset <Snake>::iterator it = s[now_].begin();
	++ it;
	if (las.val - fir.val < (*it).val \|\|
	(las.val - fir.val == (it).val && las.id < (it).id)) {
	suc[lth_] = false;
	} else {
	suc[lth_] = suc[lth_ + 1] = true;
	opt[++ o_num] = fir.id;
	opt[++ o_num] = (*it).id;
	del[fir.id] = del[(*it).id] = true;
	}
	return ;
	}

	s[now_].erase(s[now_].find(las));
	s[now_].erase(s[now_].begin());
	s[now_].insert((Snake) {las.val - fir.val, las.id});
	Solve(now_, lth_ + 1);

	if (!del[las.id]) { //本次最大值在之后不会被删除。
	suc[lth_] = true;
	opt[++ o_num] = fir.id; //
	del[fir.id] = true;
	} else { //本次删除不成功，清除记录的之后的删除操作。
	for (int i = 1; i <= o_num; ++ i) del[opt[i]] = false;
	o_num = 0;
	}
	}
	//==================================================
	int main() {
	int T = read();
	for (int nowt = 1; nowt <= T; ++ nowt) {
	Init(nowt);
	for (int i = 1; i <= n; ++ i) {
	s[nowt].insert((Snake) {a[i], i});
	}
	Solve(nowt, 0);
	for (int i = 0; i < n; ++ i) {
	if (! suc[i]) { //找到第一个不成功的位置
	printf("%d\n", n - i);
	break ;
	}
	}
	}
	return 0;
	}