2018 焦作站亚洲区域赛校内选拔赛题解

题目中需要找到正 $2N$ 边形中，两个顶点连线且线段互不相交的方案数。实际上就是组合数学中的卡特兰数。
但是即便不知道何为卡特兰数，结论也非常明显。
假设正 $2N$ 边形中一个点和另一个点连线，此时的多边形被分为了两个部分，此时方案数为 [左边多边形连线的方案数] * [右边多边形连线的方案数] 。而一个点连线的方案有 $N$ 种。因此我们可以得出递推式：
假设 $F[n]$ 表示 $n$ 边形连线的方案数，再加上题目的模，即
$F[n] = \sum_{i = 0}^{n-1}{F[i] *F[n-i - 1]}\ mod\ 19260817$

#include <cstdio>
const int maxn = 1010;
typedef long long LL;
const int mod = 19260817;
LL f[maxn], n;
void init() {
  f[0] = f[1] = 1;
  for (int i = 2; i < maxn; i++) {
    for (int j = 0; j < i; j++) {
      f[i] = (f[i] + f[j] * f[i - j - 1])%mod;
    }
  }
}
int main()
{
  init();
  while (scanf("%lld", &n) != EOF) {
    printf("%lld\n", f[n]);
  }

  return 0;
}

I、单身狗的寻觅 by huawei

tag：贪心

此题是结论明显的贪心题。
结论：对于每一个人，和他前面的人匹配(如果是异性的情况下)，否则不匹配。
对于某一个人而言：
1.如果他能匹配前一个异性，那么他匹配了前面的异性，匹配对数 $+1$ ，如果他不匹配，他被后面匹配，也是对数 $+1$ ，即匹配前一个人对后续匹配没有不良影响。相反，如果前一个人可以匹配但却去匹配后一个人，可能对后面匹配产生不良影响。
2.如果他前面无法匹配，但可以匹配后一个人，那会在下一轮判断中，被后一个人匹配。
3.如果他完全不能匹配，不匹配对结果完全没有影响。
但是由于题目数据较多，最大为 $10^8$ ，所以不能使用数组离线解决，但是我们发现此题结果只与前一个人有关，因此我们可以考虑在线算法。
题解的做法使用了栈，更简便的可以直接int last;来记录前一个人的性别。
此题也有更多做法可以挖掘。

#include <bits/stdc++.h>
using namespace std;
int main()
{
  int n, x, last;
  while (scanf("%d", &n) != EOF) {
    last = -1;
    int ans = 0;
    for (int i = 0; i < n; i++) {
      scanf("%d", &x);
      if (last == -1) {
        last = x;
      } else {
        if((x%2 + last%2) == 1) {
          ans++;
          last = -1;
        } else {
          last = x;
        }
      }
    }
    printf("%d\n", ans);
  }
  return 0;
}

J、共产主义接班人 by huawei

tag：线段树，模拟

首先我们可以简化题目要求，即对于每一天，都需要查询一个小于等于当前爱心指数的最右边的家庭，然后记录个数。
因此我们可以考虑用线段树维护区间家庭操心指数的最小值，查询函数的返回值为最右端的不大于当前爱心指数的家庭编号。即对于每一个树枝节点，我们优先比较右儿子和当前爱心指数的大小，如果右儿子小于等于爱心指数，则说明不大于当前爱心指数的最右的点位于当前区间的右子区间。如果右儿子比爱心指数大，但左儿子小，说明在左边。否则，说明不存在比当前爱心指数小的值。
而且在每一次查询后，已经帮助过的家庭的操心指数要设置为 $INF$ ，防止重复查询。
接下来就是每天的模拟操作，只需要把每天的帮助家庭户数记录下来，对于每个询问就可以 $O(1)$ 查询了。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int INF = 0x3fffffff;
const int maxn = 1e5 + 10;
LL a[maxn], segtree[maxn << 4], n, m, c, cnt, num, day;
LL b[maxn], ans[maxn];

void pushup(int now) {
  segtree[now] = min(segtree[now << 1], segtree[(now << 1)|1]);
}

void build_tree(int l, int r, int now) {
  if (l == r) {
    segtree[now] = a[l];
    return;
  }
  int mid = (l + r)/2;
  build_tree(l, mid, now << 1);
  build_tree(mid + 1, r, (now << 1)|1);
  pushup(now);
}

int query(int l, int r, int tar, int now) {
  if (l == r) {
    segtree[now] = INF;
    return l;
  }
  int mid = (l + r)/2, ans = -1;
  if (segtree[(now << 1)|1] <= tar) ans = query(mid + 1, r, tar, (now << 1)|1);
  else if (segtree[now << 1] <= tar) ans = query(l, mid, tar, now << 1);
  pushup(now);
  return ans;
}

int main()
{
  int T;
  scanf("%d", &T);
  while (T--) {
    memset(segtree, 0, sizeof segtree);
    memset(ans, 0, sizeof ans);
    memset(a, 0, sizeof a);
    memset(b, 0, sizeof b);
    cnt = num = day = 0;
    scanf("%lld %lld %lld", &n, &m, &c);
    for (int i = 1; i <= n; i++) {
      scanf("%lld", &a[i]);
    }
    build_tree(1, n, 1);
    while (num < n) {
      cnt += c; day++;
      int k = query(1, n, cnt, 1);
      while (k != -1) {
        ans[day]++;
        cnt -= a[k];
        k = query(1, n, cnt, 1);
      }
      num += ans[day];
    }
    for (int i = 0; i < m; i++) {
      scanf("%lld", &c);
      printf("%lld\n", c > day? 0 : ans[c]);
    }
  }

  return 0;
}

K、66…6 by Amon

tag：数论。欧拉函数、欧拉定理

设输入的数字为 $p$ ，即题目的要求得一个长度为 $x$ 的 $66...6$ ，使得 $66...6 = kp\ (k\in Z)$ 。
可以发现，长度为 $x$ 的 $66...6$ 可以表示为 $\frac{6(10^x - 1)}{9}$ 。
所以我们可以得到式子 $\frac{6(10^x - 1)}{9} = kp$
即 $6(10^x - 1) = 9kp$
为了可以继续化简，我们假设 $g = gcd(6,9p)$ ，两边同除 $g$ 。得
$\frac{6(10^x - 1)}{g} = \frac{9kp}{g}$
此时 $\frac{6}{g}$ 与 $\frac{9kp}{g}$ 互质，式子可简化为 $10^x - 1 = \frac{9kp}{g}$
即求解 $10^x ≡ 1\ (mod\ \frac{9kp}{g})$
根据欧拉定理可知，最小的 $x$ 存在于 $\varphi(\frac{9kp}{g})$ 的因子中，接下来的任务就是枚举所有 $\varphi(\frac{9kp}{g})$ 的因子，从而找到一个最小的 $x$ 满足 $10^x ≡ 1\ (mod\ \frac{9kp}{g})$ 。

// sustoj 1908
#include <cstdio>
#include <cmath>
#include <time.h>
#include <cstdlib>
using namespace std;
typedef long long LL;

// 求解欧拉函数
LL phi(LL x) {
    LL ans = x;
    for (LL i = 2; i * i <= x; ++i) {
        if (x % i == 0) {
            ans = ans / i * (i - 1);
            while (x % i == 0) {
                x /= i;
            }
        }
    }
    if (x > 1) {
        ans = ans / x * (x - 1);
    }
    return ans;
}

// 快速乘
LL multi(LL a, LL b, LL mod) {
    LL ret = 0;
    while (b) {
        if (b & 1) {
            ret = (ret + a) % mod;
        }
        a = (a << 1) % mod;
        b >>= 1;
    }
    return ret;
}

// 快速幂
LL fastpow(LL a, LL b, LL p) {
    LL ans = 1;
    while (b) {
        if (b & 1) {
            ans = multi(ans, a, p);
        }
        a = multi(a, a, p);
        b >>= 1;
    }
    return ans;
}

// 求解最大公约数
LL gcd(LL a, LL b) {
    return b == 0 ? a : gcd(b, a % b);
}

int main() {
    LL p;
    int ca = 1;
    while (~scanf("%lld", &p) && p) {
        printf("Case %d: ", ca++);
        p /= gcd(p, 6);
        // p 和 6 有最大公约数，先约去这个数，此时原题变为了 111...111 可以被 p 整除
        p *= 9;
        // 此时原题变为了 999...999 可以被 p 整除，即 100...000 - 1 可以被 p 整除
        // 也就是说，100...000 % p 余 1，求最少有多少个 0
        // 已知以下定理：
        // 若正整数 a, p 互质，则满足 a ^ x ≡ 1 (mod p) 的最小的正整数 x0， 是 φ(p) 的约数（因子）。
        // φ(p) 为 欧拉函数，即 10^x ≡ 1 (mod p) 的最小的正整数解是 φ(p) 的因子
        
        if (gcd(p, 10) == 1) {
            // 互质
            LL ans = phi(p); // 欧拉函数
            LL i = 0;
            int f = 0;
            LL tmp = sqrt(ans);
            
            // 下面这样求主要是将 O(n) 变为 O(根号n)
            // ans = φ(p)，求 ans 的因子
            for (i = 1; i * i <= ans; ++i) {
                // 解在 1 - sqrt(ans) 内
                if (ans % i == 0) {
                    if (fastpow(10, i, p) == 1) {
                        f = 1;
                        break;
                    }
                }
            }
            if (f) {
                printf("%lld\n", i);
            } else {
                // 解在 sqrt(ans) - ans 内
                for (i = tmp; i >= 1; --i) {
                    if (ans % (ans / i) == 0) {
                        if (fastpow(10, ans / i, p) == 1) {
                            break;
                        }
                    }
                }
                printf("%lld\n", ans / i);
            }
            
        } else {
            // 不互质，则无解
            printf("-1\n");
        }
    }
    return 0;
}