Codeforces Round 395 div1

Posted 2020-11-28 badcw

Codeforces Round 395 div1

contest链接

tags

同余方程、费马小定理、树hash、换根、线段树、并查集

码量细节：E>C>D>A>B

难度：C>E>D>B>A

A. Timofey and a tree

题意：给一棵点染色树，求一个根节点，使得除了原树以外所有的子树节点颜色都一样。

题解：首先考虑直接维护颜色相同的联通块，处理出所有颜色一样的块后如果块形成的树直径不超过3就有机会找到答案，但是由于3个块中间的宽度可能不是1,导致找不到一个根节点好像很不好处理。考虑直接维护颜色分界的边。如果有解，那么分界边一定会共享同一个节点，问题变成n个pair，求是否存在一个x在这n个pair中都出现过，就可以线性求解了。如果不存在分界边则任意选一个节点都满足条件。

代码：

/*================================================================
*
*   创 建 者： badcw
*   创建日期： 2020/5/11
*
================================================================*/
#include <bits/stdc++.h>

#define ll long long
using namespace std;

const int maxn = 1e5+50;
int main(int argc, char* argv[]) {
    int n;
    scanf("%d", &n);
    vector<pair<int, int> > a(n - 1);
    for (int i = 0; i < n - 1; ++i) scanf("%d%d", &a[i].first, &a[i].second);
    vector<int> c(n + 1);
    for (int i = 1; i <= n; ++i) scanf("%d", &c[i]);
    vector<pair<int, int> > x;
    for (auto i : a) {
        if (c[i.first] != c[i.second]) {
            x.emplace_back(i);
        }
    }
    if (x.empty()) printf("YES
1
");
    else {
        int flag = 1;
        for (auto i : x) {
            if (i.first == x[0].first || i.second == x[0].first) {
                continue;
            }
            flag = 0;
            break;
        }
        if (flag) printf("YES
%d
", x[0].first);
        else {
            flag = 1;
            for (auto i : x) {
                if (i.first == x[0].second || i.second == x[0].second) continue;
                flag = 0;
                break;
            }
            if (flag) printf("YES
%d
", x[0].second);
            else printf("NO
");
        }
    }
    return 0;
}

B. Timofey and rectangles

题意：给一些矩形的位置，求是否能用四种颜色染色使得没有紧靠的矩形同色，求方案。额外条件：没有矩形相交或相包含，所有矩形的边长都为奇数。

题解：边长为奇数可以得出四种情况，分别是行和列上的：1、下奇上偶，2、下偶上奇，3、左奇右偶，4、左偶右奇，其中(1,2)，(3,4)可以两两相邻，所以直接对某个边界点encoding即可，一定存在合法解。

代码：

/*================================================================
*
*   创 建 者： badcw
*   创建日期： 2020/5/11
*
================================================================*/
#include <bits/stdc++.h>

#define ll long long
using namespace std;

const int maxn = 5e5+50;
int main(int argc, char* argv[]) {
    int n;
    scanf("%d", &n);
    printf("YES
");
    for (int i = 0; i < n; ++i) {
        int xl, yl, xr, yr;
        scanf("%d%d%d%d", &xl, &yl, &xr, &yr);
        int t1 = (yl % 2 + 2) % 2;
        int t2 = (xl % 2 + 2) % 2;
        printf("%d
", t2 * 2 + t1 + 1);
    }
    return 0;
}

C. Timofey and remoduling

题意：在模m（素数）意义下，求长度为n的序列(a_i=a_{i-1}+d)，等于题目给出的n个数字的一种排列。

题解：首先(a_i=a_{i-1}+d)在模m是素数意义下的循环节为m，也就是说在1~n中，(a_i)都是distinct的，然后考虑一个问题(a_i+d*k=a_j)这个式子什么时候会有j的唯一解，显然是一个循环节内的情况。考虑当n*2<m时，对于(a_i+n*d)，有(i+n<m)，那么也就是说对于任意的(a_j-a_i=(j-i)d)，(j-i)是不超过(n)的，也就是说(a_j+d*k=a_j)有唯一解(j)，当然反之若n*2>=m时，就可能出现溢出一个循环节的情况。那么对于n*2<m我们可以枚举任意一组((i,j))，对于他们找出所有可能的(a_x+(j-i)*d=a_y)个数，那么可以说一共有(n-(j-i)+1)组，枚举解出组数之后也就知道了((i,j))之间的距离，同时也知道(a_j)和(a_i)，所以就可以求出(d)，那么对于任意的(a_i)，求出(a_0)也就只需要不断的(-d)即可，解出(a_0)和(d)就可以(O(nlogn))的check是否满足题意。对于n*2>=m则需要求出补集，也就是后半段循环，这个循环与题目要求的循环的差别只在于(a_0)的不同，也就是存在一个(n*d)的偏移量，就可以很方便的解出答案。

代码：

/*================================================================
*
*   创 建 者： badcw
*   创建日期： 2020/5/11
*
================================================================*/
#include <bits/stdc++.h>

#define ll long long
using namespace std;

const int maxn = 1e5+50;
const int mod = 1e9+7;
ll qp(ll a, ll n, ll mod = ::mod) {
    ll res = 1;
    while (n > 0) {
        if (n & 1) res = res * a % mod;
        a = a * a % mod;
        n >>= 1;
    }
    return res;
}

int n, m;
int x, d;


// 1 2 3 4 5
// k = 3
// 1 4, 2 5 tmp = 2

void solve(const vector<int>& a) {
    if (a.size() == 1) {
        x = a[0], d = 1;
        return;
    }
    set<int> mp;
    for (auto i : a) mp.insert(i);
    int t = a[1] - a[0];
    int tmp = 0;
    for (auto i : a) {
        if (mp.count((i + t) % m)) tmp ++;
    }
    int k = a.size() - tmp;
    x = a[0];
    d = 1ll * t * qp(k, m - 2, m) % m;
    while (mp.count((x - d + m) % m)) x = (x - d + m) % m;
    for (int i = 0; i < a.size(); ++i) {
        if (!mp.count((x + 1ll * i * d) % m)) {
            x = -1;
            return;
        }
    }
}

int main(int argc, char* argv[]) {
    scanf("%d%d", &m, &n);
    vector<int> a(n);
    for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
    sort(a.begin(), a.end());
    if (n == 1) {
        printf("%d %d
", a[0], 0);
        return 0;
    } else if (n == m) {
        for (int i = 0; i < n; ++i) {
            if (a[i] != i) {
                printf("-1
");
                return 0;
            }
        }
        printf("0 1");
        return 0;
    }
    if (n * 2 < m) {
        solve(a);
    } else {
        vector<int> inva;
        int pos = 0;
        for (int i = 0; i < m; ++i) {
            if (pos < a.size() && a[pos] == i) pos ++;
            else inva.push_back(i);
        }
        solve(inva);
        if (x != -1) x = ((x - 1ll * n * d % m) % m + m) % m;
    }
    if (x == -1) printf("-1
");
    else printf("%d %d
", x, d);
    return 0;
}

D. Timofey and a flat tree

题意：对于一棵树，求一个根，使得本质不同子树个数最大。

题解：摆明了是树hash换根，如果在hash策略上做一些调整就可以很方便的做换跟。考虑对子树进行加法hash，也就是说(hs[u]=1+sum pow(p,hs[v]))，这样做的好处是对于减掉一个子树，只需要在模意义下做减法。考虑在(u o v)这条边上做换根，显然对于(hs[u]-=hs[v])，(hs[v]+=hs[u])就ok了，回溯的时候再逆向加回去。

代码：

/*================================================================
*
*   创 建 者： badcw
*   创建日期： 2020/5/10
*
================================================================*/
#include <bits/stdc++.h>

#define ll long long
using namespace std;

const int maxn = 1e5+50;
const int mod = 998244353;
ll qp(ll a, ll n, ll mod = ::mod) {
    ll res = 1;
    while (n > 0) {
        if (n & 1) res = res * a % mod;
        a = a * a % mod;
        n >>= 1;
    }
    return res;
}

int n;
int hs = 79;
vector<int> edge[maxn];
int dp[maxn];
map<int, int> mp;
int now;
int res, respos;

void add(int x) { if (mp[x] ++ == 0) now ++; }

void del(int x) { if (--mp[x] == 0) now --; }

void dfs(int u, int pre) {
    for (auto v : edge[u]) {
        if (v == pre) continue;
        dfs(v, u);
        dp[u] = (dp[u] + qp(hs, dp[v])) % mod;
    }
    dp[u] ++;
    add(dp[u]);
}

void dfs2(int u, int pre) {
    if (now > res) {
        res = now;
        respos = u;
    }
    for (auto v : edge[u]) {
        if (v == pre) continue;
        del(dp[u]);
        del(dp[v]);

        dp[u] = (dp[u] - qp(hs, dp[v])) % mod;
        if (dp[u] < 0) dp[u] += mod;

        dp[v] = (dp[v] + qp(hs, dp[u])) % mod;

        add(dp[u]);
        add(dp[v]);

        dfs2(v, u);

        del(dp[u]);
        del(dp[v]);

        dp[v] = (dp[v] - qp(hs, dp[u])) % mod;
        if (dp[v] < 0) dp[v] += mod;
        dp[u] = (dp[u] + qp(hs, dp[v])) % mod;

        add(dp[u]);
        add(dp[v]);
    }
}

int main(int argc, char* argv[]) {
    scanf("%d", &n);
    for (int i = 1; i < n; ++i) {
        int u, v;
        scanf("%d%d", &u, &v);
        edge[u].push_back(v);
        edge[v].push_back(u);
    }
    dfs(1, 0);
    res = now;
    respos = 1;
    dfs2(1, 0);
    printf("%d
", respos);
    return 0;
}

E. Timofey and our friends animals

题意：给一张图，每条边的节点编号差不超过5，m次询问(l o r)这些节点构成多少个联通块。

题解：首先最直观的想法当然是线段树维护左右两端5个数字的联通性，光是想想代码量就上天。当然我也只会这样写，复杂度(O(nlognk^2))。另外有一个做法是：对于(l o r)，联通块个数是其中包含的全局联通块个数+不超过10个块，这不超过10个块是([l-5,l))和((r,r+5])决定的，具体来说还会有一些细节需要考虑，复杂度会降到(O(nk^2))。还有LCT的做法，可以叉掉出题人，因为不需要编号不超过5这个条件，可以做任意图的联通块个数，总之这是个假题。

代码：

/*================================================================
*
*   创 建 者： badcw
*   创建日期： 2020/5/8
*
================================================================*/
#include <bits/stdc++.h>

#define ll long long
using namespace std;

const int maxn = 1e5 + 50;
const int mod = 1e9 + 7;


int n, m, K;
int edge[maxn][5];

struct node {
    int lpos, rpos;
    int val, len;
    int lval[5], rval[5];

    node() {
        lpos = rpos = 0;
        val = len = 0;
//        for (int i = 0; i < 5; ++i) pos[i].clear();
    }
} p[maxn << 2];

int le, re;
int pre[maxn];

int f(int x) { return x == pre[x] ? x : pre[x] = f(pre[x]); }

inline node comb(node a, node b) {
    if (a.len == 0) return b;
    node res;
    res.lpos = a.lpos, res.rpos = b.rpos;
    res.len = a.len + b.len;
    res.val = a.val + b.val;
    int llt = min(K, a.len);
    int rrt = min(K, b.len);
    int rt = min(K, res.len);
    for (int i = 0; i < llt; ++i) pre[a.rval[i]] = a.rval[i], pre[a.lval[i]] = a.lval[i];
    for (int i = 0; i < rrt; ++i) pre[b.lval[i]] = b.lval[i], pre[b.rval[i]] = b.rval[i];
    for (int i = a.rpos - llt + 1; i <= a.rpos; ++i) {
        for (int j = max(0, b.lpos - i - 1); j < K && j + i + 1 < b.lpos + rrt; ++j) {
            if (edge[i][j] == 0) continue;
            int now = i + j + 1;
            if (now > b.rpos || now < b.lpos) continue;
            int u = f(b.lval[now - b.lpos]), v = f(a.rval[a.rpos - i]);
            if (u != v) {
                res.val--;
                pre[u] = v;
            }
        }
    }
    for (int i = 0; i < llt; ++i) res.lval[i] = f(a.lval[i]);
    for (int i = 0; i < rt - llt; ++i) res.lval[i + llt] = f(b.lval[i]);
    for (int i = 0; i < rrt; ++i) res.rval[i] = f(b.rval[i]);
    for (int i = 0; i < rt - rrt; ++i) res.rval[i + rrt] = f(a.rval[i]);
    return res;
}

inline void build(int rt, int l, int r) {
    if (l == r) {
        p[rt].len = p[rt].val = 1;
        p[rt].lpos = p[rt].rpos = l;
        p[rt].lval[0] = l;
        p[rt].rval[0] = l;
        return;
    }
    int mid = l + r >> 1;
    build(rt << 1, l, mid);
    build(rt << 1 | 1, mid + 1, r);
    p[rt] = comb(p[rt << 1], p[rt << 1 | 1]);
}

inline node query(int rt, int l, int r) {
    if (le <= l && r <= re) return p[rt];
    int mid = l + r >> 1;
    node res;
    if (le <= mid) res = comb(res, query(rt << 1, l, mid));
    if (re > mid) res = comb(res, query(rt << 1 | 1, mid + 1, r));
    return res;
}

int main(int argc, char *argv[]) {
//    freopen("data.in","r",stdin);
//    freopen("data.out", "w", stdout);
//    clock_t ST = clock();
    scanf("%d%d", &n, &K);
    scanf("%d", &m);
    for (int i = 0; i < m; ++i) {
        int u, v;
        scanf("%d%d", &u, &v);
        if (u > v) swap(u, v);
        edge[u][v - u - 1] = 1;
    }
    build(1, 1, n);
//    cerr << "time: " << ((clock() - ST) * 1000.0 / CLOCKS_PER_SEC) << "ms" << endl;
    int q;
    scanf("%d", &q);
    for (int i = 1; i <= q; ++i) {
        scanf("%d%d", &le, &re);
        printf("%d
", query(1, 1, n).val);
    }
//    cerr << "time: " << ((clock() - ST) * 1000.0 / CLOCKS_PER_SEC) << "ms" << endl;
    return 0;
}