Tinkoff Internship Warmup Round 2018 and Codeforces Round #475 (Div. 1)

A. Alternating Sum

就是个等比数列，特判公比为 $1$ 的情况即可。

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

const int MOD = 1e9 + ;
const int N = 1e5 + ;

int qp(int a, int b = MOD - ) {
    int ans = ;
    while (b) {
        if (b & ) ans = 1LL * ans * a % MOD;
        a = 1LL * a * a % MOD;
        b >>= ;
    }
    return ans;
}

int M(int a) {
    if (a < ) a += MOD;
    if (a >= MOD) a -= MOD;
    return a;
}

char s[N];

int main() {
    int n, a, b, k;
    scanf("%d%d%d%d", &n, &a, &b, &k);
    int q = 1LL * qp(qp(a, k)) * qp(b, k) % MOD;
    scanf("%s", s);
    int a1 = ;
    for (int i = ; i < k; i++) {
        int x = ((s[i] == '+') ?  : -);
        a1 = M(a1 + 1LL * x * qp(a, n - i) % MOD * qp(b, i) % MOD);
    }
    if (q == ) {
        int ans = 1LL * a1 * (n + ) / k % MOD;
        printf("%d\n", ans);
        return ;
    }
    int inv = qp(q - );
    int ans = 1LL * a1 * (qp(q, (n + ) / k) - ) % MOD * inv % MOD;
    printf("%d\n", ans);
    return ;
}

B. Destruction of a Tree

优先删除靠近叶子节点的偶数度数的节点，因为假如删了这个节点的父节点，就剩下两个点一条边了。
那这样肯定是不能删完的。
就搞出dfs序，倒着删，如果有偶数度数的就往下删，不往父节点方向走即可。

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

const int N = 2e5 + ;
vector<int> G[N];
int degree[N], fa[N], dfn[N], tol;
bool vis[N];
int ans[N], cnt;

void dfs(int u, int pre) {
    fa[u] = pre;
    dfn[++tol] = u;
    for (auto v: G[u])
        if (v != pre)
            dfs(v, u);
}

void dfs2(int u) {
    vis[u] = ;
    ans[++cnt] = u;
    for (auto v: G[u]) {
        degree[v]--;
        if (v == fa[u] || vis[v]) continue;
        if (degree[v] %  == ) dfs2(v);
    }
}

int main() {
    int n;
    scanf("%d", &n);
    for (int i = ; i <= n; i++) {
        int x;
        scanf("%d", &x);
        if (!x) continue;
        degree[i]++;
        degree[x]++;
        G[i].push_back(x);
        G[x].push_back(i);
    }
    dfs(, );
    for (int i = tol; i >= ; i--) {
        if (degree[dfn[i]] %  == )
            dfs2(dfn[i]);
    }
    if (cnt == n) {
        puts("YES");
        for (int i = ; i <= n; i++)
            printf("%d\n", ans[i]);
    } else {
        puts("NO");
    }
    return ;
}

C. Cutting Rectangle

画图发现，对于不一样长度的矩形，它所具有的宽度集合必须一样，并且对应的 $c$ 个数必须成比例。
排个序排除一下这两种情况。
具体排列方式就与比例的约数有关了，比如对于长为 $3$ 的矩形，它具有的宽度集合为 $2$，$3$，$4$，个数分别为 $2$，$4$，$6$
那么基底就为 $1$ $2$ $3$，把它们拼在一起，就有两个这样的大矩形，那么排列方式就是两种，横着拼一起或者竖着拼一起。
也就是 gcd 的约数个数，但这只是一组的排列方式，因为要满足和其它组能拼成最后的大矩形，那么就是所有数的 gcd 的约数个数了。

#include <bits/stdc++.h>
#define ll long long
#define pii pair<ll, ll>
#define fi first
#define se second
using namespace std;

const int N = 2e5 + ;

struct P {
    ll w, h, c;
    void read() {
        scanf("%lld%lld%lld", &w, &h, &c);
    }
    bool operator < (const P &rhs) const {
        return w < rhs.w || (w == rhs.w && h < rhs.h);
    }
} p[N];

vector<pii> vec[N];
ll base[N];

template<class T>
T gcd(T a, T b) {
    while (b) {
        a %= b;
        swap(a, b);
    }
    return a;
}

int main() {
    //freopen("in.txt", "r", stdin);
    int n;
    scanf("%d", &n);
    for (int i = ; i <= n; i++)
        p[i].read();
    sort(p + , p +  + n);
    int cnt = ;
    for (int i = ; i <= n; i++) {
        if (p[i].w != p[i - ].w) cnt++;
        vec[cnt].push_back(pii(p[i].h, p[i].c));
    }
    ll g = ;
    for (auto p: vec[])
        g = gcd(g, p.se);
    for (int i = ; i < vec[].size(); i++)
        base[i] = vec[][i].se / g;
    bool flag = ;
    for (int i = ; i <=cnt && !flag; i++) {
        if (vec[i].size() != vec[i - ].size()) {
            flag = ;
            break;
        }
        for (int j = ; j < vec[i].size(); j++) {
            if (vec[i][j].fi != vec[i - ][j].fi) {
                flag = ;
                break;
            }
        }
        if (flag) break;
        if (vec[i][].se % base[]) {
            flag = ;
            break;
        }
        ll temp = vec[i][].se / base[];
        for (int j = ; j < vec[i].size(); j++) {
            if (vec[i][j].se / base[j] != temp) {
                flag = ;
                break;
            }
        }
    }
    if (flag) {
        puts("");
        return ;
    }
    g = ;
    for (int i = ; i <= cnt; i++) {
        g = gcd(g, vec[i][].se / base[]);
    }
    ll ans = ;
    for (ll i = ; i * i <= g; i++) {
        if (g % i) continue;
        ans++;
        if (g / i != i) ans++;
    }
    printf("%lld\n", ans);
    return ;
}

D. Frequency of String

AC自动机直接做。或者哈希。
对长度相同的串同时查询，长度不同的串不超过 $\sqrt n$ 种。这样查询的复杂度是 $O(n \sqrt n)$ 的。

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

const int N = 1e5 + ;
const int sz = ;

vector<int> vec[N];

struct Aho {
    int trie[N][sz], tol, fail[N], pos[N], last[N];
    void init() {
        tol = ;
        newnode();
    }
    int newnode() {
        for (int i = ; i < sz; i++) trie[tol][i] = ;
        fail[tol] = pos[tol] = ;
        return tol++;
    }
    void ins(char *s, int index) {
        int len = strlen(s);
        int u = ;
        for (int i = ; i < len; i++) {
            int id = s[i] - 'a';
            if (!trie[u][id]) trie[u][id] = newnode();
            u = trie[u][id];
        }
        pos[u] = index;
    }
    void build() {
        queue<int> que;
        for (int i = ; i < sz; i++)
            if (trie[][i]) que.push(trie[][i]);
        while (!que.empty()) {
            int u = que.front(); que.pop();
            for (int i = ; i < sz; i++) {
                int &v = trie[u][i];
                if (v) {
                    fail[v] = trie[fail[u]][i];
                    que.push(v);
                    last[v] = pos[fail[v]] ? fail[v] : last[fail[v]];
                } else {
                    v = trie[fail[u]][i];
                }
            }
        }
    }
    void search(char *s) {
        int u = ;
        for (int i = ; s[i]; i++) {
            int id = s[i] - 'a';
            int temp = trie[u][id];
            u = temp;
            while (temp) {
                if (pos[temp]) vec[pos[temp]].push_back(i);
                temp = last[temp];
            }
        }
    }
} ac; 

char s[N], t[N];
int k[N], len[N];

int main() {
//    freopen("in.txt", "r", stdin);
    int n;
    scanf("%s%d", s, &n);
    ac.init();
    for (int i = ; i <= n; i++) {
        scanf("%d", k + i);
        scanf("%s", t);
        ac.ins(t, i);
        len[i] = strlen(t);
    }
    ac.build();
    ac.search(s);
    for (int i = ; i <= n; i++) {
        if (vec[i].size() < k[i]) {
            puts("-1");
            continue;
        }
        int ans = 1e9;
        for (int l = , r = k[i] - ; r < vec[i].size(); l++, r++) {
            ans = min(ans, vec[i][r] + len[i] -  - vec[i][l] + );
        }
        printf("%d\n", ans);
    }
    return ;
}

#include <bits/stdc++.h>
#define ull unsigned long long
using namespace std;

const int N = 1e5 + ;
const ull BASE = ;
ull bit[N], Hash[N];
unordered_map<ull, int> id[N];
int vec[N], cnt;
vector<int> pos[N];

ull get(int l, int r) {
    return Hash[r] - Hash[l - ] * bit[r - l + ];
}

char s[N], t[N];
int k[N], l[N];

int main() {
    scanf("%s", s + );
    int len = strlen(s + );
    for (int i = bit[] = ; i <= len; i++)
        bit[i] = bit[i - ] * BASE, Hash[i] = Hash[i - ] * BASE + s[i];
    int q;
    scanf("%d", &q);
    for (int i = ; i <= q; i++) {
        scanf("%d%s", k + i, t + );
        l[i] = strlen(t + );
        ull temp = ;
        for (int j = ; j <= l[i]; j++)
            temp = temp * BASE + t[j];
        id[l[i]][temp] = i;
        vec[++cnt] = l[i];
    }
    sort(vec + , vec +  + cnt);
    cnt = unique(vec + , vec +  + cnt) - vec - ;
    for (int i = ; i <= cnt; i++) {
        int n = vec[i];
        for (int ll = , rr = n; rr <= len; ll++, rr++) {
            ull temp = get(ll, rr);
            if (id[n].count(temp))
                pos[id[n][temp]].push_back(ll);
        }
    }
    for (int i = ; i <= q; i++) {
        int ans = 1e9;
        for (int ll = , rr = k[i] - ; rr < pos[i].size(); ll++, rr++)
            ans = min(ans, pos[i][rr] + l[i] -  - pos[i][ll] + );
        printf("%d\n", (ans == 1e9) ? - : ans);
    }
    return ;
}

E. Circles of Waiting

有转移方程 $$ f(x, y) = p_1 * f(x - 1, y) + p_2 * f(x, y - 1) + p_3 * f(x + 1, y) + p_4 * f(x, y + 1) + 1$$
有 $R ^ 2$ 个未知数，直接高斯消元解复杂度为 $O(R ^ 6)$
因为跟自己有关的项达不到 $R^2$ 的级别。所以只要对相邻这些消元即可。

#include <bits/stdc++.h>
#define pii pair<int, int>
#define fi first
#define se second
using namespace std;

const int N = ;
const int M = ;
const int MOD = 1e9 + ;
int n, p[], ans[M], a[M][M];
const int dx[] = {-, , , }, dy[] = {, -, , };
vector<pii> all;

int qp(int a, int b = MOD - ) {
    int ans = ;
    while (b) {
        if (b & ) ans = 1LL * ans * a % MOD;
        a = 1LL * a * a % MOD;
        b >>= ;
    }
    return ans;
}

int main() {
    int R;
    scanf("%d", &R);
    int sum = ;
    for (int i = ; i < ; i++)
        scanf("%d", p + i), sum += p[i];
    sum = qp(sum);
    for (int i = ; i < ; i++)
        p[i] = 1LL * p[i] * sum % MOD;
    for (int i = -R; i <= R; i++)
        for (int j = -R; j <= R; j++)
            if (i * i + j * j <= R * R)
                all.push_back(pii(i, j));
    n = all.size();
    for (int i = ; i < n; i++) {
        int x = all[i].fi, y = all[i].se;
        a[i][i] = a[i][n] = ;
        for (int j = ; j < ; j++) {
            int u = x + dx[j], v = y + dy[j];
            if (u * u + v * v <= R * R)
                a[i][lower_bound(all.begin(), all.end(), pii(u, v)) - all.begin()] = MOD - p[j];
        }
    }
    for (int i = ; i < n; i++) {
        vector<int> t = {n};
        int u = min(i + R *  + , n);
        for (int j = i; j < u; j++) {
            if (a[i][j]) {
                t.push_back(j);
            }
        }
        int inv = qp(a[i][i]);
        for (int j = i + ; j < u; j++) {
            if (a[j][i]) {
                int mul = 1LL * a[j][i] * inv % MOD;
                for (auto k: t) {
                    a[j][k] = (a[j][k] - 1LL * mul * a[i][k] % MOD + MOD) % MOD;
                }
            }
        }
    }
    for (int i = n - ; ~i; i--) {
        int val = a[i][n];
        for (int j = i + ; j < n; j++) {
            val = (val - 1LL * ans[j] * a[i][j] % MOD + MOD) % MOD;
        }
        ans[i] = 1LL * val * qp(a[i][i]) % MOD;
    }
    printf("%d\n", ans[lower_bound(all.begin(), all.end(), pii(, )) - all.begin()]);
    return ;
}