2020牛客多校训练赛第二场合集

• All with Pairs
• Boundary
• Cover the Tree
• Duration
• Exclusive OR
• Fake Maxpooling
• Greater and Greater
• Happy Triangle
• Interval
• Just Shuffle
• Keyboard Free

---

A、All with Pairs

题意：

给出$n$个串，定义$f(s,t)$是$s$的前缀和$t$的后缀的最长相同的长度，求$\sum \limits _{1\leq i\leq j\leq n}f(s_i,s_j)$。

题解：

看到前缀长度等于后缀长度，想到什么？对，就是$kmp$的$next$数组，但是这里只要最长的，所以对于比较短的相同前缀，就需要去重。但是我们暂时还不知道怎么去重，然后我们需要快速地找这些前缀后缀，使用哈希就很棒，为了防卡，使用双哈希就很棒。然后先把所有的字符串的后缀插到哈希表，然后对每一个串进行前缀查询，找到和这个串的前缀相同的哈希值的后缀的数量，然后考虑去重，比如，需要去重的是$"aba"$中的$"a"$子串，因为字符串枚举前缀的时候，是从大到小枚举，所以就考虑碰到一个前缀$j$，就减去这个串已经统计的部分。

AC代码：

#include <bits/stdc++.h>
#include <unordered_map>
using namespace std;
const int N = 1e5 + 5;
const int M = 1e6 + 5;
typedef long long ll;
string str[N];
int nxt[M];
ll hmod[2] = {998244353, 1000000007}, base[2] = {131, 37};
ll hs[2][M], f[2][M];
ll vis[M];
struct p_hash
{
    template <class T1, class T2>
    size_t operator()(const pair<T1, T2> &p) const
    {
        return hash<T1>{}(p.first) ^ hash<T2>{}(p.second);
    }
};
unordered_map<pair<ll, ll>, ll, p_hash> mp;
void init()
{
    f[0][0] = f[1][0] = 1;
    for (int i = 0; i <= 1; ++i)
        for (int j = 1; j < M; ++j)
            f[i][j] = f[i][j - 1] * base[i] % hmod[i];
}
ll get_hash(int l, int r, int j)
{
    return (hs[j][r] - hs[j][l - 1] * f[j][r - l + 1] % hmod[j] + hmod[j]) % hmod[j];
}
void get_next(const string &str)
{
    nxt[0] = -1;
    int j = -1, k = 0;
    while (k < str.size())
    {
        if (j == -1 || str[j] == str[k])
            nxt[++k] = ++j;
        else
            j = nxt[j];
    }
}
const ll mod = 998244353;
int main()
{
    init();
    ios::sync_with_stdio(0);
    cin.tie(0);
    int n;
    cin >> n;
    for (int i = 1; i <= n; ++i)
        cin >> str[i];
    for (int i = 1; i <= n; ++i)
    {
        pair<ll, ll> tmp;
        int len = str[i].size();
        for (int j = 0; j <= 1; ++j)
            for (int k = 0; k < len; ++k)
                hs[j][k + 1] = (hs[j][k] * base[j] % hmod[j] + str[i][k] - 'a' + 1) % hmod[j];
        for (int j = 1; j <= len; ++j)
        {
            tmp.first = get_hash(j, len, 0);
            tmp.second = get_hash(j, len, 1);
            ++mp[tmp];
        }
    }
    ll ans = 0;
    for (int i = 1; i <= n; ++i)
    {
        get_next(str[i]);
        int len = str[i].size();
        memset(vis, 0, sizeof(vis[0]) * (str[i].size() + 1));
        for (int j = 0; j <= 1; ++j)
            for (int k = 0; k < len; ++k)
                hs[j][k + 1] = (hs[j][k] * base[j] % hmod[j] + str[i][k] - 'a' + 1) % hmod[j];
        pair<ll, ll> tmp;
        for (int j = len; j; --j)
        {
            tmp.first = get_hash(1, j, 0);
            tmp.second = get_hash(1, j, 1);
            ans = (ans + (mp[tmp] - vis[j] + mod) % mod * j % mod * j % mod) % mod;
            int tnxt = nxt[j];
            vis[tnxt] = (vis[tnxt] + mp[tmp]) % mod;
        }
    }
    cout << ans << endl;
    return 0;
}

B、Boundary

题意：

给出一些点，问最多有几个点和$(0,0)$共一个圆？$n\leq 2e3$。

题解：

显然不能$O(n^3)$暴力枚举点对。所以我们就只能枚举一个点，然后因为$(0,0)$也在圆上，然后对于第三个点，它们在一个圆上，圆周角就要一样。然后直接根据向量规则求夹角的余弦值就行，但是这个题余弦值的精度差很小，所以需要对这些数乘$1e14$变成整数再存进$map$里面。如果直接算出圆心的位置，对精度的要求就会小一些。

AC代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 5;
unordered_map<long long, int> mp;
pair<int, int> p[N];
pair<int, int> operator-(const pair<int, int> &a, const pair<int, int> &b)
{
    return make_pair(a.first - b.first, a.second - b.second);
}
double dist(const pair<int, int> &vec)
{
    return sqrt(vec.first * vec.first + vec.second * vec.second);
}
double dotcos(const pair<int, int> &a, const pair<int, int> &b)
{
    return (a.first * b.first + a.second * b.second) / (dist(a) * dist(b));
}
int cross(const pair<int, int> &a, const pair<int, int> &b)
{
    return a.first * b.second - b.first * a.second;
}
int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i)
        scanf("%d%d", &p[i].first, &p[i].second);
    int maxn = 0;
    for (int i = 1; i <= n; ++i)
    {
        mp.clear();
        for (int j = 1; j <= n; ++j)
            if (cross(p[i], p[j]) < 0)
                ++mp[dotcos(p[j] - make_pair(0, 0), p[j] - p[i]) * 1e14];
        for (auto &j : mp)
            maxn = max(maxn, j.second);
    }
    printf("%d\n", maxn + 1);
    return 0;
}

C、Cover the Tree

题意：

给出一棵树，每次找两个点连路径，求最小需要连多少路径使得树上每条边都覆盖。

题解：

显然都连叶子最优。自己写的时候考虑了类似于树的重心，找到了叶节点的重心，但是实现太垃圾，一直不是$wa$就是$tle$。

看了正解才发现真的简单。直接看代码就行，正确性：设$s$是叶子节点个数，所有前$s/2$和后$s/2$个叶子结点往上的所有边都会被覆盖，这样子不可能找到一棵树，还有未被覆盖的边。

AC代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
typedef long long ll;
vector<int> G[N], lef;
void dfs(int u, int fa)
{
    if (G[u].size() == 1)
    {
        lef.push_back(u);
        return;
    }
    for (auto i : G[u])
        if (i != fa)
            dfs(i, u);
}
void solve()
{
    int n;
    scanf("%d", &n);
    for (int i = 1; i < n; ++i)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        G[u].push_back(v);
        G[v].push_back(u);
    }
    if (n == 1)
    {
        printf("0\n");
        return;
    }
    if (n == 2)
    {
        printf("1\n1 2\n");
        return;
    }
    int rt = 0;
    for (int i = 1; i <= n; ++i)
        if (G[i].size() != 1)
        {
            rt = i;
            break;
        }
    dfs(rt, 0);
    printf("%d\n", (lef.size() + 1) / 2);
    for (int i = 0; i < lef.size() / 2; ++i)
        printf("%d %d\n", lef[i], lef[i + (lef.size() + 1) / 2]);
    if (lef.size() % 2)
        printf("%d %d\n", lef[lef.size() / 2], rt);
}
int main()
{
    int T = 1;
    //scanf("%d", &T);
    while (T--)
        solve();
    return 0;
}

D、Duration

题意：

太简单了不说了。

题解：

随便减一下取个绝对值就行。

AC代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
typedef long long ll;
char s[10];
void solve()
{
    scanf("%s", s);
    int hh = s[0] * 10 + s[1];
    int mm = s[3] * 10 + s[4];
    int ss = s[6] * 10 + s[7];
    int tot = hh * 3600 + mm * 60 + ss;
    scanf("%s", s);
    hh = s[0] * 10 + s[1];
    mm = s[3] * 10 + s[4];
    ss = s[6] * 10 + s[7];
    tot = hh * 3600 + mm * 60 + ss - tot;
    printf("%d\n", abs(tot));
}
int main()
{
    int T = 1;
    //scanf("%d", &T);
    while (T--)
        solve();
    return 0;
}

E、Exclusive OR

队友补。

F、Fake Maxpooling

题意：

设矩阵中$a_{ij} = lcm(i,j)$，求边长为$k$的子方阵最大值的和。$n\leq 5e3,m\leq 5e3$。

题解：

构造矩阵的时候需要利用线性筛的思路优化，虽然暴力求解卡常也能过。然后就套路题了，单调队列套单调队列。

坑点：不能$a[i][j]=a[j][i]=lcm(i,j)$，因为不保证一定是方阵，如果非要这样子，就要求完长度是$max(n,m)$的方阵。

AC代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 5100;
int aa[maxn][maxn], mp[maxn][maxn], q[maxn];
inline int gcd(int a, int b)
{
    return !b ? a : gcd(b, a % b);
}
inline int lcm(int a, int b)
{
    return a * b / gcd(a, b);
}
int main()
{
    int n, m, a, b, k;
    scanf("%d%d%d", &n, &m, &k);
    a = k, b = k;
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= m; ++j)
            aa[i][j] = lcm(i, j);
    for (int i = 1; i <= n; i++)
    {
        int l = 1, r = 0;
        for (int j = 1; j <= b; j++)
        {
            while (r && aa[i][q[r]] < aa[i][j])
                r--;
            q[++r] = j;
        }
        mp[i][1] = aa[i][q[l]];
        for (int j = 2; j + b - 1 <= m; j++)
        {
            if (q[l] == j - 1)
                l++;
            while (l <= r && aa[i][q[r]] < aa[i][j + b - 1])
                r--;
            q[++r] = j + b - 1;
            mp[i][j] = aa[i][q[l]];
        }
    }
    ll ans = 0;
    for (int j = 1; j <= m; j++)
    {
        int l = 1, r = 0;
        for (int i = 1; i <= a; i++)
        {
            while (r && mp[q[r]][j] < mp[i][j])
                r--;
            q[++r] = i;
        }
        (ans += mp[q[l]][j]);
        for (int i = 2; i + a - 1 <= n; i++)
        {
            if (q[l] == i - 1)
                l++;
            while (l <= r && mp[q[r]][j] < mp[i + a - 1][j])
                r--;
            q[++r] = i + a - 1;
            (ans += mp[q[l]][j]);
        }
    }
    printf("%lld\n", ans);
    return 0;
}

G、Greater and Greater

题意：

给出$a$和$b$序列，问$a$当中有多少个子数组，对应位置的数大小都大于$b$。

题解：

看数据范围暴力可以卡常过，所以考虑怎么卡常，$bitset$是卡常利器。所以我们就想一下怎么用$bitset$卡常，然后把$bitset$的$a_i$大于$b_j$的$i$位设成$1$，最后右移$j$位，得到合法的数的数量。然后对于每个$b$序列都这么处理，最后取与即可。实现的时候，先降序排序然后用一个$bitset$记录就行了，因为前面枚举到的数一定大于后面枚举到的。

AC代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 1.5e5 + 5;
bitset<N> f, g;
struct node
{
    int val, id;
};
node a[N], b[N];
int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i)
        scanf("%d", &a[i].val), a[i].id = i;
    for (int i = 1; i <= m; ++i)
        scanf("%d", &b[i].val), b[i].id = i;
    sort(a + 1, a + n + 1, [](const node &a, const node &b) -> bool { return a.val > b.val; });
    sort(b + 1, b + m + 1, [](const node &a, const node &b) -> bool { return a.val > b.val; });
    f.set();
    g.reset();
    for (int i = 1, j = 1; i <= m; ++i)
    {
        while (j <= n && a[j].val >= b[i].val)
            g.set(a[j++].id);
        //cout << "g=" << g << endl;
        f &= g >> b[i].id;
        //cout << "f=" << f << endl;
    }
    printf("%d\n", f.count());
    return 0;
}

H、Happy Triangle

题意：

维护一个集合$s$，给出以下指令：

$1$、添加一个数

$2$、删除一个数

$3$、给出一个数，询问里面有没有两个数和这个数组成非退化三角形。

题解：

操作$1$和$2$都是小意思，康康第三个怎么整。如果$x$是最大边，这样子找两个前驱就行了，如果不是，就找两个$a$，$b$，且$a$要大于等于$x$和$b$，$a-b$小于$x$。关键是维护这个有序序列的相邻差值和求区间最小值，使用权值线段树。线段树维护三个值，区间最小值，区间最大值和区间最小的差值。对于长度是$1$的区间，如果有几个数，则差值是$0$，如果只有一个数，视为无穷大，差值的维护就是，对于一段区间，最小差值来自子区间和跨区间取得（就是右区间最小减左区间最大），取最小上推。查询同理。

AC代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5;
const int inf = 0x7fffffff;
int mp[N];
int b[N], top;
struct segtree
{
#define ls (k << 1)
#define rs ((k << 1) + 1)
    struct node
    {
        int l, r, maxn, minn, gap;
    };
    node tr[N << 1];
    inline void pushup(int k)
    {
        tr[k].maxn = max(tr[ls].maxn, tr[rs].maxn);
        tr[k].minn = min(tr[ls].minn, tr[rs].minn);
        tr[k].gap = min(tr[ls].gap, tr[rs].gap);
        tr[k].gap = min(tr[k].gap, tr[rs].minn - tr[ls].maxn);
    }
    void build(int l, int r, int k)
    {
        tr[k].l = l;
        tr[k].r = r;
        if (l == r)
        {
            tr[k].maxn = 0;
            tr[k].minn = inf;
            tr[k].gap = inf;
            return;
        }
        int m = (l + r) >> 1;
        build(l, m, ls);
        build(m + 1, r, rs);
        pushup(k);
    }
    void update(int k, int pos, int val)
    {
        if (tr[k].l == tr[k].r)
        {
            mp[pos] += val;
            tr[k].gap = inf;
            if (mp[pos] == 0)
            {
                tr[k].maxn = 0;
                tr[k].minn = inf;
            }
            else
            {
                tr[k].maxn = tr[k].minn = b[pos];
                if (mp[pos] >= 2)
                    tr[k].gap = 0;
            }
            return;
        }
        int m = (tr[k].l + tr[k].r) >> 1;
        if (pos <= m)
            update(ls, pos, val);
        else
            update(rs, pos, val);
        pushup(k);
    }
    int querym(int l, int r, int k, int op)
    {
        if (l > r)
            return op ? 0 : inf;
        if (l <= tr[k].l && tr[k].r <= r)
            return op ? tr[k].maxn : tr[k].minn;
        int m = (tr[k].l + tr[k].r) >> 1;
        int ans1 = 0, ans2 = inf, tmp;
        if (l <= m)
        {
            tmp = querym(l, r, ls, op);
            ans1 = max(ans1, tmp);
            ans2 = min(ans2, tmp);
        }
        if (r > m)
        {
            tmp = querym(l, r, rs, op);
            ans1 = max(ans1, tmp);
            ans2 = min(ans2, tmp);
        }
        return op ? ans1 : ans2;
    }
    int queryg(int l, int r, int k)
    {
        if (l > r)
            return inf;
        if (l <= tr[k].l && tr[k].r <= r)
            return tr[k].gap;
        int m = (tr[k].l + tr[k].r) >> 1;
        int ans = inf;
        int f = 0;
        if (l <= m)
            ans = min(ans, queryg(l, r, ls)), ++f;
        if (r > m)
            ans = min(ans, queryg(l, r, rs)), ++f;
        if (f == 2)
            ans = min(ans, tr[rs].minn - tr[ls].maxn);
        return ans;
    }
#undef ls
#undef rs
};
pair<int, int> q[N];
#define x first
#define y second
segtree tr;
bool check(int op, int pos, int val)
{
    if (mp[pos] >= 2)
        return 1;
    else if (mp[pos] == 1)
    {
        int maxn = tr.querym(1, pos - 1, 1, 1);
        if (maxn != 0)
            return 1;
        int ming = tr.queryg(pos, top, 1);
        if (ming < val)
            return 1;
        return 0;
    }
    int maxn = tr.querym(1, pos, 1, 1);
    int minn = tr.querym(pos, top, 1, 0);
    if (maxn != 0 && minn != inf && maxn + val > minn)
        return 1;
    int mpos = lower_bound(b + 1, b + top + 1, maxn) - b;
    if (maxn)
    {
        tr.update(1, mpos, -1);
        int smaxn = tr.querym(1, pos, 1, 1);
        tr.update(1, mpos, 1);
        if (smaxn && smaxn + maxn > val)
            return 1;
    }
    int ming = tr.queryg(pos, top, 1);
    if (ming < val)
        return 1;
    return 0;
}
int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i)
    {
        scanf("%d%d", &q[i].x, &q[i].y);
        b[++top] = q[i].y;
    }
    sort(b + 1, b + top + 1);
    top = unique(b + 1, b + top + 1) - b - 1;
    for (int i = 1; i <= n; ++i)
        q[i].y = lower_bound(b + 1, b + top + 1, q[i].y) - b;
    tr.build(1, top, 1);
    for (int i = 1; i <= n; ++i)
    {
        if (q[i].x == 1)
            tr.update(1, q[i].y, 1);
        else if (q[i].x == 2)
            tr.update(1, q[i].y, -1);
        else
            printf("%s", check(q[i].x, q[i].y, b[q[i].y]) ? "Yes\n" : "No\n");
    }
    return 0;
}

I、Interval

队友补。

J、Just Shuffle

队友补

AC代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int a[N], b[N];
vector<int> v;
bool vis[N];
int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i)
        scanf("%d", &a[i]);
    for (int i = 1; i <= n; ++i)
        if (!vis[i])
        {
            v.clear();
            int x = a[i];
            while (!vis[x])
            {
                vis[x] = 1;
                v.push_back(x);
                x = a[x];
            }
            int inv, r = v.size();
            for (int i = 0; i < r; ++i)
                if (1ll * m * i % r == 1)
                    inv = i;
            for (int i = 0; i < r; ++i)
                b[v[i]] = v[(i + inv) % r];
        }
    for (int i = 1; i <= n; ++i)
        printf("%d%c", b[i], " \n"[i == n]);
    return 0;
}

K、Keyboard Free

队友补。