湖南省队集训 Day 2

从这里开始

• Problem A 走路
• Problem B 游戏
• Problem C 有趣的字符串题

　　暴力分又没骗满sad.....

Problem A 走路

 

　　$O(n^2)$动态规划是显然的。

　　更新方式有两种：一种是枚举它的倍数转移，一种是转移到它的约数。

　　考虑利用分块来平衡一下（像分块FWT一样）。

　　注意到若$x = ab, y = cd, (a, b) = 1, (c, d) = 1$，那么$x | y$的充分必要条件是$a | c, b | d$或者$a | d, b | c$。

　　那么我们可以把$v_1$拆成$AB, (A, B) = 1$，使得$A$和$B$的约数个数尽量相等。

　　对于每一部分，离散化后暴力处理整除关系。每次修改或查询时固定一维动另一维。

　　时间复杂度$O(nV^{0.25})$。

Code

#include <algorithm>
#include <iostream>
#include <cassert>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <ctime>
#ifndef WIN32
#define Auto "%lld"
#else
#define Auto "%I64d"
#endif
using namespace std;
typedef bool boolean;

#define ll long long
#define ull unsigned long long

template <typename T>
T add(T a, T b, T m) {
    return ((a += b) >= m) ? (a - m) : (a);
}

template <typename T>
T sub(T a, T b, T m) {
    return ((a -= b) < 0) ? (a + m) : (a);
}

template <typename T>
void pcopy(T* pst, const T* ped, T* pval) {
    for ( ; pst != ped; *(pst++) = *(pval++));
}

template <typename T>
void pfill(T* pst, const T* ped, T val) {
    for ( ; pst != ped; *(pst++) = val);
}

ll mul(ll a, ll b, ll m) {
//    return (__int128)a * b % m;
    ll rt = 0, pa = a;
    for ( ; b; b >>= 1, pa = add(pa, pa, m))
        if (b & 1)
            rt = add(rt, pa, m);
    return rt;
}

ll qpow(ll a, ll p, ll m) {
    ll rt = 1, pa = a;
    for ( ; p; p >>= 1, pa = mul(pa, pa, m))
        if (p & 1)
            rt = mul(rt, pa, m);
    return rt;
}

ll gcd(ll a, ll b) {
    return (b) ? (gcd(b, a % b)) : (a);
}

ll randLL() {
    static ull seed = 998244353, msk = (1ull << 61) - 1;
    return (signed ll) ((seed = seed * seed + seed + 233) & msk);
}

int pri[8] = {2, 3, 5, 7, 11, 13, 17, 19};

boolean miller_rabin(ll n) {
    static int T = 25;
    for (int i = 0; i < 8; i++)
        if (!(n % pri[i]))
            return n == pri[i];
    if (n < 1000) {
        for (int p = 2; p * p <= n; p++)
            if (!(n % p))
                return false;
        return true;
    }
    ll d = n - 1;
    int s = 0;
    while (!(d & 1))
        s++, d >>= 1;
    for (int t = 0; t < T; t++) {
        ll b = randLL() % n;
        if (!b)
            continue;
        ll tmp = qpow(b, d, n);
        if (tmp == 1 || tmp == n - 1)
            continue;
        for (int i = 0; i < s; i++) {
            tmp = mul(tmp, tmp, n);
            if (tmp == n - 1)
                goto nextTurn;
            if (tmp == 1 || tmp == 0)
                return false;
        }
        if (tmp != 1)
            return false;
        nextTurn:;
    }
    return true;
}

ll pollard_rho(ll x) {
    ll a, b, c, g;
    if (!(x & 1))
        return 2;
    while (true) {
        b = a = randLL() % x;
        c = randLL() % 127;
        do {
            a = add(mul(a, a, x), c, x);
            b = add(mul(b, b, x), c, x);
            b = add(mul(b, b, x), c, x);
            g = gcd(b - a, x);
            (g < 0) ? (g = -g) : (0);
            if (g == x)
                break;
            if (g > 1)
                return g;
        } while (a != b);
    }
    assert(false);
    return 0;
}

void get_primary_factors(ll x, vector<ll>& rt) {
    if (miller_rabin(x)) {
        rt.push_back(x);
        return;
    }
    ll a = pollard_rho(x);
    get_primary_factors(a, rt);
    get_primary_factors(x / a, rt);
}

vector< pair<ll, int> > get_primary_factor(vector<ll>& vec) {
    vector< pair<ll, int> > rt;
    if (vec.empty())
        return rt;
    sort(vec.begin(), vec.end());
    vector<ll>::iterator it = vec.begin();
    rt.push_back(make_pair(*it, 1));
    for (it = it + 1 ; it != vec.end(); it++)
        if (*it == rt.back().first)
            rt.back().second++;
        else
            rt.push_back(make_pair(*it, 1));
    return rt;
}

typedef vector< pair<ll, int> > factor;

/// Template ends

template <typename T>
class Matrix {
    public:
        T* p;
        int r, c;

        Matrix() : p(NULL) {    }
        Matrix(int r, int c) : r(r), c(c) {
            p = new T[r * c];
        }

        T* operator [] (int pos) {
            return p + c * pos;
        }
};

const int Mod = 1e9 + 7;

int n;
ll *v;
int *f;
Matrix<int> F;
vector<int> *g;
vector<ll> va, vb;
vector<int> *diva, *divb, *mula, *mulb;

inline void init() {
    scanf("%d", &n);
    g = new vector<int>[(n + 1)];
    for (int i = 1, u, v; i < n; i++) {
        scanf("%d%d", &u, &v);
        g[u].push_back(v);
        g[v].push_back(u);
    }
    v = new ll[(n + 2)];
    for (int i = 1; i <= n; i++)
        scanf(Auto, v + i);
}

ll A = 1, B;
int *a, *b;

inline void discrete() {
    vector<ll> _fac;
    get_primary_factors(v[1], _fac);
    factor fac = get_primary_factor(_fac);

    random_shuffle(fac.begin(), fac.end());
    
    a = new int[(n + 1)];
    b = new int[(n + 1)];
    ll da = 1, db = 1;
    for (auto p : fac)
        db *= (p.second + 1);
    for (auto p : fac) {
//        cerr << p.first << " " << p.second << '
';
        if (da * (p.second + 1) <= db / (p.second + 1)) {
            da *= (p.second + 1), db /= (p.second + 1);
            for (int j = 0; j < p.second; j++)
                A *= p.first;
        }
    }
    B = v[1] / A;
//    cerr << da << " " << db << '
';

    for (int i = 1; i <= n; i++)
        va.push_back(gcd(v[i], A));
    for (int i = 1; i <= n; i++)
        vb.push_back(gcd(v[i], B));

    sort(va.begin(), va.end());
    sort(vb.begin(), vb.end());
    va.erase(unique(va.begin(), va.end()), va.end());
    vb.erase(unique(vb.begin(), vb.end()), vb.end());

//    cerr << va.size() << ' ' << vb.size() << '
';
    F = Matrix<int>(va.size(), vb.size());
    pfill(F[0], F[va.size()], 0);
    for (int i = 1; i <= n; i++) {
        a[i] = lower_bound(va.begin(), va.end(), gcd(v[i], A)) - va.begin();
        b[i] = lower_bound(vb.begin(), vb.end(), gcd(v[i], B)) - vb.begin();
    }

    diva = new vector<int>[va.size()];
    divb = new vector<int>[vb.size()];
    mula = new vector<int>[va.size()];
    mulb = new vector<int>[vb.size()];
    for (int i = 0; i < (signed) va.size(); i++) {
        for (int j = 0; j < (signed) va.size(); j++) {
            if (!(va[i] % va[j]))
                diva[i].push_back(j);
            if (!(va[j] % va[i]))
                mula[i].push_back(j);
        }
    }
    for (int i = 0; i < (signed) vb.size(); i++) {
        for (int j = 0; j < (signed) vb.size(); j++) {
            if (!(vb[i] % vb[j]))
                divb[i].push_back(j);
            if (!(vb[j] % vb[i]))
                mulb[i].push_back(j);
        }
    }
}

void dp(int p, int fa) {
    if (p == 1) {
        f[p] = 1;
    } else {
        for (auto x : mulb[b[p]])
            f[p] = add(f[p], F[a[p]][x], Mod);
    }
    for (auto x : diva[a[p]])
        F[x][b[p]] = add(F[x][b[p]], f[p], Mod);
    for (auto e : g[p])
        if (e ^ fa)
            dp(e, p);
    for (auto x : diva[a[p]])
        F[x][b[p]] = sub(F[x][b[p]], f[p], Mod);
}

inline void solve() {
    f = new int[(n + 1)];
    pfill(f + 1, f + n + 1, 0);
    dp(1, 0);
    for (int i = 1; i <= n; i++)
        printf("%d
", f[i]);
}

int main() {
    srand((unsigned) time (NULL));
    init();
    discrete();
    solve();
    return 0;
}

Problem B 走路

　　显然，使得$(1, 1)$和$(n, n)$不连通的方案斜着放车。

　　然后随便容斥一下，得到：

$ans = n! - 2sum_{i = 1}^{n}(n - i)! + 1 + sum_{s = 2}^{n}(s - 1)(n - s)!$

　　发现需要阶乘，阶乘的前缀和以及阶乘的前缀和前缀和。

　　不会。分块大表。

　　laofu把数压成若干可见字符的方法真高级。

　　（请手动打表）

Code

#include <iostream>
#include <cstdio>
using namespace std;
typedef bool boolean;

const int n = 1e7, Mod = 1e9 + 7;

int add(int a, int b) {
    return ((a += b) >= Mod) ? (a - Mod) : (a);
}

int sub(int a, int b) {
    return ((a -= b) < 0) ? (a + Mod) : (a);
}

int mul(int a, int b) {
    return (a * 1ll * b) % Mod;
}

void exgcd(int a, int b, int& x, int& y) {
    if (!b)
        x = 1, y = 0;
    else {
        exgcd(b, a % b, y, x);
        y -= (a / b) * x;
    }
}

int inv(int a, int n) {
    int x, y;
    exgcd(a, n, x, y);
    return (x < 0) ? (x + n) : (x);
}

int fac[n + 1];
int sfac[n + 1];
int ssfac[n + 1];
int ans[n + 1];

inline void init() {
    fac[0] = 1;
    for (int i = 1; i <= n; i++)
        fac[i] = mul(fac[i - 1], i);
    sfac[0] = 1;
    for (int i = 1; i <= n; i++)
        sfac[i] = add(sfac[i - 1], fac[i]);
    ssfac[0] = 1;
    for (int i = 1; i <= n; i++)
        ssfac[i] = add(ssfac[i - 1], sfac[i]);
//    ans[1] = ans[2] = 0, ans[3] = 2;
//    int reduce = 
//    for (in ti = 4; i <= n; i++) {
//        ans[i] = add(ans[i - 1], fac[i]);
//        ans[i] = sub(ans[i], fac[i - 1]);
//        ans[i] = sub(ans[i], mul(fac[i - 1], 2));
//        ans[i] = add(ans[i], )
//    }
}

inline void solve() {
    int T, n;
//    cerr << fac[300000] << " " << sfac[300000] << " " << ssfac[300000] << '
';
    scanf("%d", &T);
    while (T--) {
        scanf("%d", &n);
//        int ans = fac[n];
//        for (int i = 1; i <= n; i++)
//            ans = sub(sub(ans, fac[n - i]), fac[n - i]);
//        ans = add(ans, 1);
//        for (int s = 2; s <= n; s++)
//            ans = add(ans, mul(s - 1, fac[n - s]));
        int ans = ((n <= 2) ? 0 : add(fac[n], 1));
        if (n > 2) {
            ans = sub(ans, mul(sfac[n - 1], 2));
            ans = add(ans, ssfac[n - 2]);
        }
        printf("%d
", ans);
    }
}

int main() {
    init();
    solve();
    return 0;
}

Problem C 有趣的字符串题

　　好像SD有道是这道题的强制在线的版本，之前有人讲过分块做法。然后就一直陷入了分块的漩涡中。sad....

　　正解是考虑右端点在$r$的时候，询问左端点在每个位置时的答案。

　　考虑移动右端点至$r + 1$时产生的贡献。显然我们只用考虑它的回文border。

　　考虑一些长度构成等差数列的border。

　　对于每一段讨论它会产生贡献的部分。注意向前移动周期个字符的情形以及前一个这中间的最长串的前一个的出现的位置$[x, y]$。

　　若$z$是这些串中最短的一个串出现的左端点。不难得到当左端点在整数区间$(x, z]$中时，会有贡献。

　　对于不同的这样的border，显然每一组可以单独计算贡献。

　　因此我们用一个树状数组维护这个贡献，用线段树维护最后的出现位置，再用回文树维护border，就完事了。

　　时间复杂度$O(nlog^2n + mlog n)$。

Code

#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <map>
using namespace std;
typedef bool boolean;

template <typename T>
void pfill(T* pst, const T* ped, T val) {
    for ( ; pst != ped; *(pst++) = val);
}

typedef class Input {
    protected:
        const static int limit = 65536;
        FILE* file; 

        int ss, st;
        char buf[limit];
    public:
        
        Input():file(NULL)    {    };
        Input(FILE* file):file(file) {    }

        void open(FILE *file) {
            this->file = file;
        }

        void open(const char* filename) {
            file = fopen(filename, "r");
        }

        char pick() {
            if (ss == st)
                st = fread(buf, 1, limit, file), ss = 0;//, cerr << "str: " << buf << "ed " << st << endl;
            return buf[ss++];
        }
}Input;

#define digit(_x) ((_x) >= '0' && (_x) <= '9')

Input& operator >> (Input& in, unsigned& u) {
    char x;
    while (~(x = in.pick()) && !digit(x));
    for (u = x - '0'; ~(x = in.pick()) && digit(x); u = u * 10 + x - '0');
    return in;
}

Input& operator >> (Input& in, unsigned long long& u) {
    char x;
    while (~(x = in.pick()) && !digit(x));
    for (u = x - '0'; ~(x = in.pick()) && digit(x); u = u * 10 + x - '0');
    return in;
}

Input& operator >> (Input& in, int& u) {
    char x;
    while (~(x = in.pick()) && !digit(x) && x != '-');
    int aflag = ((x == '-') ? (x = in.pick(), -1) : (1));
    for (u = x - '0'; ~(x = in.pick()) && digit(x); u = u * 10 + x - '0');
    u *= aflag;
    return in;
}

Input& operator >> (Input& in, long long& u) {
    char x;
    while (~(x = in.pick()) && !digit(x) && x != '-');
    int aflag = ((x == '-') ? (x = in.pick(), -1) : (1));
    for (u = x - '0'; ~(x = in.pick()) && digit(x); u = u * 10 + x - '0');
    u *= aflag;
    return in;
}

Input& operator >> (Input& in, char* str) {
    for (char x; ~(x = in.pick()) && x != '
' && x != ' '; *(str++) = x);
}

Input in (stdin);

const int alpha = 26;

typedef class TrieNode {
    public:
        int len, dif, g;
        int in, out, id;
        map<char, TrieNode*> ch;
        TrieNode *fail, *slink;
}TrieNode;

typedef class PalindromeTree {
    public:
        int len;
        TrieNode *pool;
        TrieNode *top;
        TrieNode *odd, *even;
        TrieNode *last;
        TrieNode **node;
        char *str; 

        TrieNode* newnode(int len) {
            top->id = top - pool;
            top->len = len, top->dif = -1, top->g = 0;
//            memset(top->ch, 0, sizeof(top->ch));
            top->fail = top->slink = NULL;
            return top++;
        }

        PalindromeTree() {        }
        PalindromeTree(int n) {
            node = new TrieNode*[(n + 5)];
            pool = new TrieNode[(n + 5)];
            str = new char[(n + 5)];
            top = pool, len = 0;
            odd = newnode(-1), even = newnode(0);
            odd->fail = odd, even->fail = odd;
            odd->dif = even->dif = -1, last = even, str[0] = 0;
        }

        TrieNode* extend(TrieNode* p) {
            while (str[len - p->len - 1] != str[len])    p = p->fail;
            return p;
        }

        void append(char x) {
            str[++len] = x;
            int c = x - 'a';
            last = extend(last);
            if (!last->ch[c]) {
                TrieNode* p = newnode(last->len + 2);
                p->fail = extend(last->fail)->ch[c];
                if (!p->fail)
                    p->fail = even;
                last->ch[c] = p;
                p->dif = p->len - p->fail->len; 

                if (p->dif == p->fail->dif)
                    p->slink = p->fail->slink;
                else
                    p->slink = p->fail;
            }
            last = last->ch[c];
            node[len] = last;
        }

        void build(vector<int>* g) {
            for (TrieNode* p = pool; p != top; p++) {
                if (p->fail && p->fail != p) {
                    g[p->fail->id].push_back(p->id);
                    g[p->id].push_back(p->fail->id);
                }
            }
        }

        TrieNode* operator [] (int p) {
            return node[p];
        }
}PalindromeTree;

typedef class Query {
    public:
        int l, r, id;
        
        boolean operator < (Query p) const {
            return r < p.r;
        }
}Query;

typedef class SegTreeNode {
    public:
        int val;
        SegTreeNode *l, *r;

        SegTreeNode() : val(0), l(NULL), r(NULL) {    }

        void pushUp() {
            val = max(l->val, r->val);
        }
}SegTreeNode;

const int N = 3e5 + 5;

SegTreeNode pool[N << 2];
SegTreeNode *top = pool;

SegTreeNode *newnode() {
    return top++;
}

typedef class SegTree {
    public:
        int n;
        SegTreeNode* rt;

        SegTree() : rt(NULL) {    }
        SegTree(int n) : n(n) {
            build(rt, 1, n);
        }

        void build(SegTreeNode*& p, int l, int r) {
            p = newnode();
            if (l == r)
                return ;
            int mid = (l + r) >> 1;
            build(p->l, l, mid);
            build(p->r, mid + 1, r);
        }

        void modify(SegTreeNode *p, int l, int r, int idx, int val) {
            if (l == r) {
                p->val = val;
                return ;    
            }
            int mid = (l + r) >> 1;
            if (idx <= mid)
                modify(p->l, l, mid, idx, val);
            else
                modify(p->r, mid + 1, r, idx, val);
            p->pushUp();
        }

        int query(SegTreeNode* p, int l, int r, int ql, int qr) {
            if (l == ql && r == qr)
                return p->val;
            int mid = (l + r) >> 1;
            if (qr <= mid)
                return query(p->l, l, mid, ql, qr);
            if (ql > mid)
                return query(p->r, mid + 1, r, ql, qr);
            int a = query(p->l, l, mid, ql, mid);
            int b = query(p->r, mid + 1, r, mid + 1, qr);
            return (a > b) ? (a) : (b);
        }

        void modify(int idx, int val) {
            modify(rt, 1, n, idx, val);
        }

        int query(int ql, int qr) {
            return query(rt, 1, n, ql, qr);
        }
}SegTree;

typedef class IndexedTree {
    public:
        int s;
        int *a;

        IndexedTree() {    }
        IndexedTree(int n) : s(n) {
            a = new int[(n + 1)];
            pfill(a, a + n + 1, 0);
        }

        void add(int idx, int val) {
            for ( ; idx <= s; idx += (idx & (-idx)))
                a[idx] += val;
        }

        void add(int l, int r, int val) {
            add(l, val), add(r + 1, -val);
        }

        int query(int idx) {
            int rt = 0;
            for ( ; idx; idx -= (idx & (-idx)))
                rt += a[idx];
            return rt;
        }
}IndexedTree;

const int Mod = 1e9 + 7;

int add(int a, int b) {
    return ((a += b) >= Mod) ? (a - Mod) : (a);
}

int sub(int a, int b) {
    return ((a -= b) < 0) ? (a + Mod) : (a);
}

int mul(int a, int b) {
    return a * 1ll * b % Mod;
}

int n, m;
char *s;
Query* qs;
SegTree st;
vector<int> *g;
IndexedTree it;
PalindromeTree pt;

inline void init() {
    in >> n >> m;
    s = new char[(n + 5)];
    qs = new Query[(m + 1)];
    pt = PalindromeTree(n + 5);
    g = new vector<int>[(n + 5)];
    in >> s;
    for (int i = 0; i < n; i++)
        pt.append(s[i]);
    delete[] s;
    pt.build(g);
    for (int i = 1; i <= m; i++)
        in >> qs[i].l >> qs[i].r, qs[i].id = i;
}

int dfs_clock;
void dfs(int p, int fa) {
    pt.pool[p].in = ++dfs_clock;
//    cerr << p << " " << fa << '
';
    for (auto e : g[p])
        if (e ^ fa)
            dfs(e, p);
    pt.pool[p].out = dfs_clock;
}

int res = 0;
inline void solve() {
    st = SegTree(n + 3);
    it = IndexedTree(n);
    dfs(0, -1);
    sort(qs + 1, qs + m + 1);
    
    Query* q = qs + 1, *qed = qs + m + 1;
    for (int i = 1; i <= n; i++) {
        for (TrieNode *p = pt[i]; p && p->len; p = p->slink) {
            int left = max(st.query(p->in, p->out) - p->len + 1, 0) + 1;
            int right = i - p->dif - ((p->slink) ? (p->slink->len) : (0)) + 1;            
//            cerr << i << " " << left << " " << right << '
';
            it.add(left, right, 1);
        }
        st.modify(pt[i]->in, i);
        while (q != qed && q->r == i) {
            res = add(res, mul(it.query(q->l), q->id));
//            cerr << "Q: " << it.query(q->l) << " " << q->id << '
';
            q++;
        }
    }
    printf("%d
", res);
}

int main() {
    init();
    solve();
    return 0;
}