AtCoder Beginner Contest 179

导读：
简单的题目，只说明题意，或者直接说明结论
下面的难题，会做详细的解释和证明
立个flag，在座的大佬们做个见证：一个月刷60场ABC，现在2021/7/9，第二十四天，已打卡二十场。

A - Plural Form

void work()
{
  string s; cin >> s;
  int n = s.size();
  if (s[n - 1] == 's') s += "es";
  else s += "s";
  cout << s << endl;
}

B - Go to Jail

void work()
{
  int n; cin >> n;
  int cnt = 0;
  for (int i = 0; i < n; i ++ )
  {
    int x, y; cin >> x >> y;
    if (x == y) cnt ++;
    else cnt = 0;
    if (cnt == 3)
    {
      cout << "Yes" << endl;
      return;
    }
  }
  cout << "No" << endl;
}

C - A x B + C

N = a * b + c 其中a，b，c都是正数，问有多少个a，b，c满足方案。
因为c为正数，所以ab最多为n-1，那么我们知道要考虑满足ab<=n-1的方案数有多少就可以了，剩下的n-a*b直接用c来补就可以了。

void work()
{
  int n; cin >> n;
  int ans = 0;
  for (int i = 1; i <= n - 1; i ++ )
  {
    ans += (n - 1) / i;
  }
  > 
  cout << ans << endl;
  return;
}

D - Leaping Tak

有点像完全背包的货币系统那一题，不过现在的货币变成了一个区间的数都是货币
递归DP

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 200010, mod = 998244353;
int n, k;
int l[20], r[20];
ll dp[N], s[N];
int main(void)
{
  cin >> n >> k;
  for (int i = 1; i <= k; i ++ )
    cin >> l[i] >> r[i];
  dp[1] = 1;
  s[1] = 1;
  for (int i = 2; i <= n; i ++ )
  {
    for (int j = 1; j <= k; j ++ )
      dp[i] = (dp[i] + s[max(0, i - l[j])] - s[max(0, i - r[j] - 1)] + mod) % mod;
    s[i] = (s[i - 1] + dp[i]) % mod;
  }
  cout << dp[n] << endl;
  return 0;
}

E - Sequence Sum

如果不看题目，看到特别大的是数字会想到什么呢，第一、找规律，抽象出来公式。第二、化为字符串处理，第三、离散化、映射
我们结合题目看，虽然n很大，暴力的话我们要操作1e10次，但是，我们每次都要对m取模，取模的时候吧，m是1e5的数字，那我们不久将数据映射到了1e5的区间了吗，那么，如果有重复出现的x，在前面一定对应一个x，又因为公式是不变的，那么下面的数也是确定的，那么这就是一个周期喽。
好吧，直接前缀和处理下，然后如果x出现第二次就可以停止循环了，而这个出现的循环一定会在m次之内。搞定！！！

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 100005;
ll n, x, m;
ll s[N];
unordered_map<ll, int> mp;
int main()
{
  cin >> n >> x >> m;
  s[1] = x;
  int id = 1;
  for (int i = 2; i <= n; i ++ )
  {
    x = x * x % m;
    if (mp.count(x)) {id = i; break;}
    mp[x] = i;
    // if (x == 0) break;
    s[i] = s[i - 1] + x;
  }
  if (id == 1)
  {
    cout << s[n] << endl;
    return 0;
  }
  ll len = id - mp[x];
  ll r = (n - mp[x]) % len;
  ll cnt = (n - mp[x]) / len;
  ll sum = s[mp[x] - 1] + (s[id - 1] - s[mp[x] - 1]) * cnt + (s[mp[x] + r] - s[mp[x] - 1]);
  cout << sum << endl;
  return 0;
}

F - Simplified Reversi

看别人题解是线段树写的
大佬的题解连接
那我就粘下代码了，马上有场比赛，先打了在来写这个题

#include <bits/stdc++.h>
using ll = long long;
using namespace std;
#define MAXN 200005
#define lson (idx << 1)
#define rson (idx << 1 | 1)

struct Node {
    int l, r, hi, lazy = 0;
};

struct SegTree {
    Node s[MAXN << 2];
    void calc(int idx)
    {
      s[idx].hi = max(s[lson].hi, s[rson].hi);
    }

    void pushdown(int idx) {
        if (s[idx].lazy) {
            for (int i = lson; i <= rson; ++i) {
                if (s[i].hi > s[idx].lazy) {
                    s[i].hi   = s[idx].lazy;
                    s[i].lazy = s[idx].lazy;
                }
            }
        }
        s[idx].lazy = 0;
    }

    void build(int idx, int l, int r, vector<int> &a) {
        s[idx].l = l, s[idx].r = r;
        if (l == r) {
            s[idx].hi = a[l];
            return;
        }
        int mid = (l + r) >> 1;
        build(lson, l, mid, a);
        build(rson, mid + 1, r, a);
        calc(idx);
    }

    void update(int idx, int l, int r, int x) {
        if (s[idx].hi <= x)
            return;
        if (s[idx].l >= l && s[idx].r <= r) {
            s[idx].hi   = x;
            s[idx].lazy = x;
            return;
        }
        pushdown(idx);
        int mid = (s[idx].l + s[idx].r) >> 1;
        if (l <= mid)
            update(lson, l, r, x);
        if (mid + 1 <= r)
            update(rson, l, r, x);
        calc(idx);
    }

    int query(int idx, int l, int r) {
        if (s[idx].l >= l && s[idx].r <= r)
            return s[idx].hi;
        pushdown(idx);
        int ans = 0;
        int mid = (s[idx].l + s[idx].r) >> 1;
        if (l <= mid)
            ans = max(ans, query(lson, l, r));
        if (mid + 1 <= r)
            ans = max(ans, query(rson, l, r));
        return ans;
    }
};

int main() {
    int n, q;
    cin >> n >> q;
    vector<int> col(n + 1, n), row(n + 1, n);
    col[n] = 1, row[n] = 1;
    SegTree C, R;
    C.build(1, 1, n, col);
    R.build(1, 1, n, row);
    ll ans = (ll)(n - 2) * (n - 2);
    for (int i = 0; i < q; ++i) {
        int t, x;
        cin >> t >> x;
        if (t == 1) {
            int hi = C.query(1, x, x);
            ans -= hi - 2;
            R.update(1, 1, hi, x);
            C.update(1, x, x, 1);
        } else {
            int hi = R.query(1, x, x);
            ans -= hi - 2;
            C.update(1, 1, hi, x);
            R.update(1, x, x, 1);
        }
    }
    cout << ans;
}