2016-2017 CT S03E07: Codeforces Trainings Season 3 Episode 7

A. Yet Another Problem with Strings

题意：

给出$n$个字符串$S_i$，要求支持两种操作：

• 在第$i$个字符串后增加一个字符$c$
• 给出一个字符串$T$，询问是否有一个串$S_i$是$T$的子串。

强制在线，保证$sum S_i, sum T leq 2 cdot 10^5$

思路：

考虑暴力做法即枚举每个$S_i$然后询问$T$中的每个等长的子串是否等于$S_i$。

但是一个小优化是可以把所有长度相同的$S_i$放在一起做，用std::map记录哈希值。

并且注意到$sum S_i leq 2 cdot 10^5$，所以所有的$S_i$只有$sqrt{2 cdot 10^5}$种长度。

暴力即可。

B. Pen Pineapple Apple Pen

Solved.

题意：将一个序列合并成一个数。

思路：分类讨论一下， 水。

#include<bits/stdc++.h>

using namespace std;

const int maxn = 1e5 + 10;

char str[maxn];

bool solve()
{
    int len = strlen(str + 1);
    if(len == 1) return true;
    while(len % 2 == 0) len = len >> 1;
    if(len != 1) return false;
    len = strlen(str + 1);
    for(int i = 1; i <= len; i += 2) if(str[i] != 'P' && str[i + 1] != 'P') return false;
    return true;
}

int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%s", str + 1);
        puts(solve() ? "YES" : "NO");
    }
    return 0;
}

C. Stickmen

Solved.

题意：找有几个小人

思路：枚举$i, j$两个点作为中间那条线的端点， 再枚举公共点计算贡献。

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const ll MOD = 1e9 + 7;
const int maxn = 1e3;

int n, m;
ll fac[maxn];
ll inv[maxn];
ll invfac[maxn];
int du[maxn];
int mp[maxn][maxn];

void Init()
{
    fac[1] = inv[1] = invfac[1] = 1;
    fac[0] = inv[0] = invfac[0] = 1;
    for(int i = 2; i < maxn; ++i)
    {
        fac[i] = fac[i - 1] * i % MOD;
        inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
        invfac[i] = invfac[i - 1] * inv[i] % MOD;
    }
}

ll C(int n, int m)
{
    if(n < 0 || m < 0) return 0;
    if(m > n) return 0;
    return fac[n] * invfac[m] % MOD * invfac[n - m] % MOD;
}

int merge(int x, int y)
{
    int res = 0;
    for(int i = 1; i <= n; ++i) if(mp[x][i] == 1 && mp[y][i] == 1) res++;
    return res;
}

int main()
{
    Init();
    while(~scanf("%d %d", &n, &m))
    {
        memset(mp, 0, sizeof mp);
        memset(du, 0, sizeof du);
        for(int i = 1, x, y; i <= m; ++i)
        {
            scanf("%d %d", &x, &y);
            du[x]++, du[y]++;
            mp[x][y] = mp[y][x] = 1;
        }
        ll ans = 0;
        for(int i = 1; i <= n; ++i) for(int j = 1; j <= n; ++j) if(mp[i][j] && i != j)
        {
            int x = du[i] - 1, y = du[j] - 1;
            int same = merge(i, j);
            ans = (ans  + C(x, 3) * C(y, 2) % MOD)% MOD;
            
            ans = (ans - C(x - 1, 2) * C(y - 1, 1) % MOD * same % MOD) % MOD;
            ans = (ans + C(x - 2, 1) * C(same, 2) % MOD) % MOD;
        }
        printf("%lld
", ans);
    }
    return 0;
}

D. Strange Queries

Solved.

题意：询问$i in [L_1, R_1],j in [L_2, R_2]  有多少对(i, j) 使得 a_i = a_j$

思路：$f[i][j]表示第i个块对前j个块的贡献，f2[i][j]表示a_i对前j个块的贡献$

$整块整块处理，边边角角处理$

#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define N 50010
#define S 150
#define unit 450
int n, a[N], q;
int pos[N], posl[unit], posr[unit];
ll f[unit][unit], f2[N][unit];
int cnt[N];

int main()
{
    while (scanf("%d", &n) != EOF)
    {
        for (int i = 1; i <= n; ++i) pos[i] = (i - 1) / S + 1;
        for (int i = 1; i <= n; ++i)
        {
            if (i == 1 || pos[i] != pos[i - 1]) 
                posl[pos[i]] = i;
//            cout << i << " " << pos[i] << endl;
            posr[pos[i]] = i;  
//            printf("%d %d
", posl[pos[i]], posr[pos[i]]);
        }
//        for (int i = 1; i <= n; ++i) cout << i << " " << pos[i] << endl;
//        for (int i = 1; i <= n; ++i)
//            printf("%d %d
", posl[pos[i]], posr[pos[i]]);
        memset(f, 0, sizeof f);
        memset(f2, 0, sizeof f2); 
        memset(cnt, 0, sizeof cnt);
        for (int i = 1; i <= n; ++i) scanf("%d", a + i);
        for (int i = 1; i <= pos[n]; ++i)   
        {  
            for (int j = posl[i]; j <= posr[i]; ++j)
                ++cnt[a[j]];
            for (int j = 1; j <= n; ++j) 
            {
                f[i][pos[j]] += cnt[a[j]];
                f2[j][i] += cnt[a[j]];
            }
            for (int j = posl[i]; j <= posr[i]; ++j)
                --cnt[a[j]];
        } 
        for (int i = 1; i <= pos[n]; ++i)
            for (int j = 1; j <= pos[n]; ++j)
                f[i][j] += f[i][j - 1];
        for (int i = 1; i <= n; ++i)
            for (int j = 1; j <= pos[n]; ++j)
                f2[i][j] += f2[i][j - 1]; 
        scanf("%d", &q);
        int l[2], r[2];
        while (q--)
        {
            for (int i = 0; i < 2; ++i)
                scanf("%d%d", l + i, r + i);
            if (pos[l[1]] == pos[r[1]])
            {
                swap(l[0], l[1]);
                swap(r[0], r[1]);
            }
            ll res = 0; 
            if (pos[l[0]] == pos[r[0]])
            {
                if (pos[l[1]] == pos[r[1]])
                {
                    for (int i = l[0]; i <= r[0]; ++i) 
                        ++cnt[a[i]];
                    for (int i = l[1]; i <= r[1]; ++i) 
                        res += cnt[a[i]];
                    for (int i = l[0]; i <= r[0]; ++i)
                        --cnt[a[i]];
                }
                else
                {
                    int L = pos[l[1]] + 1;
                    int R = pos[r[1]] - 1;
                    for (int i = l[0]; i <= r[0]; ++i)
                    {
                        res += f2[i][R] - f2[i][L - 1];
                        ++cnt[a[i]];
                    }
                    for (int i = l[1]; i <= posr[pos[l[1]]]; ++i)
                        res += cnt[a[i]];
                    for (int i = posl[pos[r[1]]]; i <= r[1]; ++i)
                        res += cnt[a[i]];
                    for (int i = l[0]; i <= r[0]; ++i)
                        --cnt[a[i]];
                }
            }
            else
            {
                int L[2] = {pos[l[0]] + 1, pos[l[1]] + 1};
                int R[2] = {pos[r[0]] - 1, pos[r[1]] - 1};
                for (int i = L[0]; i <= R[0]; ++i)
                    res += f[i][R[1]] - f[i][L[1] - 1]; 
                for (int i = l[0]; i <= posr[pos[l[0]]]; ++i) 
                {
                    res += f2[i][R[1]] - f2[i][L[1] - 1];
                    ++cnt[a[i]];
                }
                for (int i = posl[pos[r[0]]]; i <= r[0]; ++i)
                {
                    res += f2[i][R[1]] - f2[i][L[1] - 1];
                    ++cnt[a[i]];
                }
                for (int i = l[1]; i <= posr[pos[l[1]]]; ++i) 
                {
                    res += f2[i][R[0]] - f2[i][L[0] - 1];
                    res += cnt[a[i]];
                }
                for (int i = posl[pos[r[1]]]; i <= r[1]; ++i)
                {
                    res += f2[i][R[0]] - f2[i][L[0] - 1];
                    res += cnt[a[i]];
                }
                for (int i = l[0]; i <= posr[pos[l[0]]]; ++i) 
                    --cnt[a[i]];
                for (int i = posl[pos[r[0]]]; i <= r[0]; ++i)
                    --cnt[a[i]];
            }
            printf("%lld
", res);
        }
    }
    return 0;
}

E. Bravebeart

Solved.

题意：给出n个人和n匹马， 每个人和每匹马都有自己的能力值， 每个人选择一匹马， 那么每个人的权值就是个人能力值乘上马的权值， 求是否存在一种方案， 使得第一个人的权值最大。

思路：排序， 水

#include<bits/stdc++.h>

using namespace std;

const int INF = 0x3f3f3f3f;
const int maxn = 1e5 + 10;

int n;
int w[maxn], h[maxn];

bool solve(int tmp)
{
    for(int i = n - 1; i >= 1; --i)
    {
        if(w[i] * h[n - 1 - i + 1] >= tmp) return false; 
    }
    return true;
}

int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d", &n);
        for(int i = 1; i <= n; ++i) scanf("%d", w + i);
        for(int i = 1; i <= n; ++i) scanf("%d", h + i);
        int tmp = w[1];
        w[1] = INF;
        sort(w + 1, w + 1 + n);
        sort(h + 1, h + 1 + n);
        tmp *= h[n];
        puts(solve(tmp) ? "YES" : "NO");
    }
    return 0;
}

F. GukiZ Height

Solved.

题意：$f_i = f_{i - 1} + a_{(i - 1) \% n +1}, g_i = h - frac{i cdot (i + 1)}{2}, 求最小的i 使得 f_i >= g_i$

思路：枚举每个余数， 那么分为周期为0和周期>=1， 对于后面一种情况， 二分周期。

#include <bits/stdc++.h>
using namespace std;

#define ll long long 
#define N 100010
int n;
ll h, a[N];
ll sum[N];

bool check(ll x, int remind)
{
    ll day = x * n + remind;
    return h - (day * (day + 1)) / 2 <= sum[n] * x + sum[remind];
}

int main()
{
    while (scanf("%d%lld", &n, &h) != EOF)
    {
        sum[0] = 0;
        for (int i = 1; i <= n; ++i) scanf("%lld", a + i);
        for (int i = 1; i <= n; ++i) sum[i] = sum[i - 1] + a[i];
        ll ans = (ll)1e18; 
        for (int i = 1; i <= n; ++i) if(sum[i] >= h - (i * (i + 1) / 2)) ans = min(ans, 1ll * i);
        for (int i = 1; i <= n; ++i)
        {
            ll l = 0, r = (2e9 + 10) / n, res = -1;
            while (r - l >= 0)
            {
                ll mid = (l + r) >> 1;
//                cout << i << " " << mid << endl;
                if (check(mid, i))
                {
                    r = mid - 1;
                    res = mid;
                }
                else
                    l = mid + 1;
            }
//            cout << i << " " << res << endl;
            if (res != -1) 
                ans = min(ans, res * n + i); 
        }
        printf("%lld
", ans);
    }
    return 0;
}

I. Prime Moving

Solved.

题意：将素数$a$通过某系列变化得到素数$b$, 每次变化可以加上或减去一个素数， 同时结果要求是素数。

思路：将2作为中间点， 各种分类

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const int S = 10;

ll mult_mod(ll a, ll b, ll c)
{
    a %= c;
    b %= c;
    ll ret = 0;
    ll tmp = a;
    while(b)
    {
        if(b & 1)
        {
            ret += tmp;
            if(ret > c) ret -= c;
        }
        tmp <<= 1;
        if(tmp > c) tmp -= c;
        b >>= 1;
    }
    return ret;
}

ll pow_mod(ll a, ll n, ll mod)
{
    ll ret = 1;
    ll tmp = a % mod;
    while(n)
    {
        if(n & 1) ret = mult_mod(ret, tmp, mod);
        tmp = mult_mod(tmp, tmp, mod);
        n >>= 1;
    }
    return ret;
}

bool check(ll a, ll n, ll x, ll t)
{
    ll ret = pow_mod(a, x, n);
    ll last = ret;
    for(int i = 1; i <= t; ++i)
    {
        ret = mult_mod(ret, ret, n);
        if(ret == 1 && last != 1 && last != n - 1) return true;
        last = ret;
    }
    if(ret != 1) return true;
    else return false;
}

bool is_Prime(ll n)
{
    if(n < 2) return false;
    if(n == 2) return true;
    if((n & 1) == 0) return false;
    ll x = n - 1;
    ll t = 0;
    while((x & 1) == 0) { x >>= 1; ++t; }
    srand(time(NULL));
    for(int i = 0; i < S; ++i)
    {
        ll a = rand() % (n - 1) + 1;
        if(check(a, n, x, t)) return false;
    }
    return true;
}

ll a, b;

void solve()
{
    if(a == 2)
    {
        if(is_Prime(b - 2))
        {
            printf("%lld->%lld
", a, b);
            return ;
        }
        if(is_Prime(b + 2)) 
        {
            printf("%lld->%lld->%lld
", a, b + 2, b);
            return ;
        }
    }
    else
    {
        if(b == a + 2)
        {
            printf("%lld->%lld
", a, b);
            return ;
        }
        if(b == a + 4 && is_Prime(a + 2))
        {
            if(is_Prime(a - 2) && is_Prime(b - 2))
            {
                puts("Poor Benny");
                return ;
            }
            else
            {
                printf("%lld->%lld->%lld
", a, a + 2, b);
                return ;
            }
        }
        if(is_Prime(a - 2))
        {
            if(is_Prime(b - 2))
            {
                printf("%lld->%lld->%lld
", a, 2ll, b);
                return ;
            }
            if(is_Prime(b + 2))
            {
                if(is_Prime(a + 2) && is_Prime(b - 2))
                {
                    puts("Poor Benny");
                    return ;    
                }
                else
                {
                    printf("%lld->%lld->%lld->%lld
", a, 2ll, b + 2, b);
                    return ;
                }
            }
        }
        if(is_Prime(a + 2))
        {
            if(is_Prime(b - 2))
            {
                printf("%lld->%lld->%lld->%lld
", a, a + 2, 2ll, b);
                return ;
            }
            if(is_Prime(b + 2))
            {
                printf("%lld->%lld->%lld->%lld->%lld
", a, a + 2, 2ll, b + 2, b);
                return ;
            }
        }
    }
    puts("Unlucky Benny");
}

int main()
{
    while(~scanf("%lld %lld", &a, &b))
    {
        solve();
    }
    return 0;
}

J. Valentina and the Gift Tree

Upsolved

题意：给出一棵树，询问$a -> b的简单路径上组成的序列的最大子段和$

思路：把一条简单路径拆成两条链，单独处理，一条链上用树链剖分处理，合并的时候注意左右端点怎么接

#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define N 100010
#define D 20
#define INF 0x3f3f3f3f3f3f3f3f
int n, q, g[N];
vector <int> G[N];

int sze[N], top[N], fa[D][N], son[N], p[N], fp[N], deep[N], cnt; 
void DFS(int u)
{
    sze[u] = 1; 
    for (int i = 1; i < D; ++i)
        fa[i][u] = fa[i - 1][fa[i - 1][u]]; 
    for (auto v : G[u]) if (v != fa[0][u])
    {
        fa[0][v] = u;  
        deep[v] = deep[u] + 1; 
        DFS(v);
        sze[u] += sze[v];
        if (!son[u] || sze[v] > sze[son[u]]) son[u] = v; 
    }
}

void gettop(int u, int sp)
{
    top[u] = sp;
    p[u] = ++cnt;
    fp[cnt] = u;
    if (!son[u]) return;
    gettop(son[u], sp);
    for (auto v : G[u]) if (v != fa[0][u] && v != son[u])
        gettop(v, v);
} 

namespace SEG
{
    struct node
    {
        ll lmax, rmax, Max, sum;
        node () {}
        void init()
        {
            lmax = rmax = Max = sum = -INF; 
        }
        node operator + (const node &other) const
        {
            node res; res.init();
            if (lmax == -INF || rmax == -INF)
                return other; 
            if (other.lmax == -INF || other.rmax == -INF) 
                return *this; 
            res.sum = sum + other.sum;
            res.lmax = max(lmax, sum + other.lmax);
            res.rmax = max(other.rmax, other.sum + rmax);
            res.Max = max(Max, other.Max);  
            res.Max = max(res.Max, rmax + other.lmax); 
            return res;
        }
    }a[N << 2], ans[2], tmp; 
    void build(int id, int l, int r)
    {
        a[id].init();
        if (l == r)
        {
            a[id].lmax = a[id].rmax = a[id].sum = a[id].Max = g[fp[l]];   
            return;
        }
        int mid = (l + r) >> 1;
        build(id << 1, l, mid);
        build(id << 1 | 1, mid + 1, r);
        a[id] = a[id << 1] + a[id << 1 | 1];
    }
    void query(int id, int l, int r, int ql, int qr)
    {
        if (qr < ql || ql <= 0 || qr <= 0) return; 
        if (l >= ql && r <= qr) 
        {
            tmp = tmp + a[id];
            return; 
        }
        int mid = (l + r) >> 1;
        if (ql <= mid) query(id << 1, l, mid, ql, qr);
        if (qr > mid) query(id << 1 | 1, mid + 1, r, ql, qr); 
    }
}

int lca(int u, int v)
{
    while (top[u] != top[v])
    {
        if (deep[top[u]] < deep[top[v]]) swap(u, v);
        u = fa[0][top[u]];
    }
    if (deep[u] > deep[v]) swap(u, v);
    return u;
}

int kth(int u, int k)
{
    for (int i = 0; i < D; ++i) 
        if ((k >> i) & 1)
            u = fa[i][u]; 
    return u; 
}

void query(int u, int v, int vis)
{
    SEG::ans[vis].init();
    while (top[u] != top[v])
    {
        if (deep[top[u]] < deep[top[v]]) swap(u, v);
        SEG::tmp.init();  
        SEG::query(1, 1, n, p[top[u]], p[u]);
        SEG::ans[vis] = SEG::tmp + SEG::ans[vis];
        u = fa[0][top[u]];
    }
    if (deep[u] > deep[v]) swap(u, v); 
    SEG::tmp.init();
    SEG::query(1, 1, n, p[u], p[v]);
    SEG::ans[vis] = SEG::tmp + SEG::ans[vis];
}

int main()
{
    while (scanf("%d", &n) != EOF)  
    {
        for (int i = 1; i <= n; ++i) G[i].clear();
        memset(son, 0, sizeof son); cnt = 0; deep[1] = 0;
        for (int i = 1, u, v; i < n; ++i)
        {
            scanf("%d%d", &u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        for (int i = 1; i <= n; ++i) scanf("%d", g + i);
        deep[1] = 0; fa[0][1] = 0;
        DFS(1); gettop(1, 1); SEG::build(1, 1, n);
        //if (n == 10) return 0;
        scanf("%d", &q); 
        int a, b;
        while (q--)
        {
            scanf("%d%d", &a, &b);
            if (deep[a] > deep[b]) swap(a, b);
            int Lca = lca(a, b);
            if (a == Lca) 
                query(a, b, 0); 
            else
            {
                query(Lca, a, 0);
                query(kth(b, deep[b] - deep[Lca] - 1), b, 1);
                swap(SEG::ans[0].lmax, SEG::ans[0].rmax);
                SEG::ans[0] = SEG::ans[0] + SEG::ans[1];
            }
            printf("%lld
", SEG::ans[0].Max); 
        }
    }
    return 0;
}

LCA

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const ll MOD = 1e9 + 7;
const ll INFLL = 0x3f3f3f3f3f3f3f3f;
const int maxn = 1e5 + 10;

const int DEG = 20;

struct Edge {
    int to, nxt;
    Edge() {}
    Edge(int to, int nxt) :to(to), nxt(nxt) {}
}edge[maxn << 1];

struct node {
    ll lmax, rmax, ans, sum;
    node() 
    {
        sum = 0;
        lmax = rmax = ans = -INFLL;
    }
    node(ll tmp)
    {
        lmax = rmax = ans = sum = tmp;
    }
    node operator + (const node &other) const
    {
        node res;
        res.sum = sum + other.sum;
        res.lmax = max(lmax, sum + other.lmax);
        res.rmax = max(other.rmax, other.sum + rmax);
        res.ans = max(max(ans, other.ans), rmax + other.lmax);
        return res;
    }
};

int n, m;
ll arr[maxn];
int head[maxn], tot;
node res[maxn][DEG];
int fa[maxn][DEG];
int deg[maxn];

void Init()
{
    tot = 0;
    memset(fa, -1, sizeof fa);
    memset(head, -1, sizeof head);
}

void addedge(int u, int v)
{
    edge[tot] = Edge(v, head[u]); head[u] = tot++;
    edge[tot] = Edge(u, head[v]); head[v] = tot++;
    
}

void BFS(int root)
{
    queue<int>q;
    deg[root] = 0;
    res[root][0] = node(arr[root]);
    fa[root][0] = root;
    q.push(root);
    while (!q.empty())
    {
        int tmp = q.front();
        q.pop();
        for (int i = 1; i < DEG; ++i)
        {
            fa[tmp][i] = fa[fa[tmp][i - 1]][i - 1];
            res[tmp][i] = res[tmp][i - 1] + res[fa[tmp][i - 1]][i - 1];
        }
        for (int i = head[tmp]; ~i; i = edge[i].nxt)
        {
            int v = edge[i].to;
            if (v == fa[tmp][0]) continue;
            deg[v] = deg[tmp] + 1;
            fa[v][0] = tmp;
            res[v][0] = node(arr[v]);
            q.push(v);
        }
    }
}

node LCA(int u, int v)
{
    if (deg[u] > deg[v]) swap(u, v);
    int hu = deg[u], hv = deg[v];
    int tu = u, tv = v;
    node ansu, ansv;
    for (int det = hv - hu, i = 0; det; det >>= 1, ++i)
    {
        if (det & 1)
        {
            ansv = ansv + res[tv][i];
            tv = fa[tv][i];
        }
    }
    for (int i = DEG - 1; i >= 0; --i)
    {
        if (fa[tu][i] == fa[tv][i]) continue;
        ansu = ansu + res[tu][i];
        ansv = ansv + res[tv][i];
        tu = fa[tu][i];
        tv = fa[tv][i];
    }
    while (tu != tv)
    {
        ansu = ansu + res[tu][0];
        ansv = ansv + res[tv][0];
        tu = fa[tu][0];
        tv = fa[tv][0];
    }
    swap(ansv.lmax, ansv.rmax);
    return ansu + res[tu][0] + ansv;
}

void RUN()
{
    while (~scanf("%d", &n))
    {
        Init();
        for (int i = 1, u, v; i < n; ++i)
        {
            scanf("%d %d", &u, &v);
            addedge(u, v);
        }
        for (int i = 1; i <= n; ++i) scanf("%lld", arr + i);
        BFS(1); 
        int q;
        scanf("%d", &q);
        for (int qq = 1, u, v; qq <= q; ++qq)
        {
            scanf("%d %d", &u, &v);
            printf("%lld
", LCA(u, v).ans);
        }
    }
}

int main()
{
#ifdef LOCAL_JUDGE
    freopen("Text.txt", "r", stdin);
#endif // LOCAL_JUDGE

    RUN();

#ifdef LOCAL_JUDGE
    fclose(stdin);
#endif // LOCAL_JUDGE
    return 0;
}