北京集训:20180311

于是今天又是一场愉悦的考试。

笨蒟蒻今天终于不爆零啦!好开心!

T1:

说白了就是要在区间内选出一个子集使之xor和为0。
直觉告诉我这东西线段树。
然而三种标记没法合并啊，怎么办啊......
莫队吧，区间修改不可做。
看80分的值域那么小，要不然，我们来倍增沃尔什变换吧。
不不不，这是什么鬼畜的东西......
算了，40分值域才15，n^2暴力+bitset可过。
好像能线性基?然而40分不需要线性基的，算了不管了暴力了。
然后下来发现大力线性基有80分......
说下正解:
显然当r-l+1>30的时候一定输出Yes(这不显然啊，我怎么没想出来)。
为什么?考虑线性基的插入过程，我们逐个插入，当某个数不能被插入时说明xor出0，符合要求。
而值域10^9代表线性基最多插30个，根据鸽巢原理，当你插入第31个数的时候要么无法插入，要么前面已经插入出0了。
然后我们当r-l+1<=30的时候大力计算即可。
所以我们有了完美的n^2暴力，能过80分。
剩下的20分怎么办呢?考虑用线段树维护修改。
还是老问题，这个标记没法合并。
你可以线段树强行push，显然这样是O(n^2)的，而且是大常数。
其实暴力推倒(不是这个字吧)一下是可以合并的，然而我比较蒻，不愿意推(H是不行的)。
于是我选择按位考虑，or变成数字为1的位强制是1，and变成数字为0位强制是0，xor变成区间01互换。
好的，我们可以每个节点开31个char去维护这个东西是吧......
然后就有了一个常数巨大的伪正解。
考场40分代码:

#include<bits/stdc++.h>
#define debug cout
using namespace std;
const int maxn=1e3+1e2,maxe=64,maxl=32;
typedef bitset<maxe> BitSet;

int in[maxn],n;
BitSet prv[maxn];

inline BitSet trans(const BitSet &sou,const int &x) {
    BitSet ret = sou;
    for(int i=0;i<maxl;i++) if( sou[i] ) ret[i^x] = 1;
    return ret;
}

inline void getprv(int l,int r) {
    prv[l] &= 0; prv[l][in[l]] = 1;
    for(int i=l+1;i<=r;i++) prv[i] = trans(prv[i-1],in[i]) , prv[i][in[i]] = 1;
}
inline bool getans(int l,int r) {
    if( !in[l] ) return 1;
    for(int i=l+1;i<=r;i++) if( !in[i] || prv[i-1][in[i]] ) return 1;
    return 0;
}

inline void modify(int l,int r,int x,int o) {
    if( o == 1 ) for(int i=l;i<=r;i++) in[i] &= x;
    if( o == 2 ) for(int i=l;i<=r;i++) in[i] |= x;
    if( o == 3 ) for(int i=l;i<=r;i++) in[i] ^= x;
}

int main() {
    static int q;
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",in+i);
    scanf("%d",&q);
    for(int i=1,o,l,r,x;i<=q;i++) {
        scanf("%d%d%d",&o,&l,&r);
        if( !o ) {
            getprv(l,r);
            puts(getans(l,r)?"Yes":"No");
        } else {
            scanf("%d",&x);
            modify(l,r,x,o);
        }
    }
    return 0;
}

暴力线段树80分代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cctype>
#define debug cerr
using namespace std;
const int maxn=1e5+1e2,maxl=32;

int in[maxn],n;
struct SegmentTree {
    int l[maxn<<2],r[maxn<<2],lson[maxn<<2],rson[maxn<<2],cnt;
    int lazy[maxn<<2][3]; // 0 xor , 1 and , 2 or .
    
    inline void getpe(int tpe,int &reta,int &retb) {
        if( tpe == 0 ) reta = 1 , retb = 2;
        else if( tpe == 1 ) reta = 0 , retb = 2;
        else if( tpe == 2 ) reta = 0 , retb = 1;
    }
    inline void apply(int pos,int val,int tpe) {
        if( l[pos] == r[pos] ) {
            if( tpe == 0 ) in[l[pos]] ^= val;
            if( tpe == 1 ) in[l[pos]] &= val;
            if( tpe == 2 ) in[l[pos]] |= val;
        }
        int ta,tb; getpe(tpe,ta,tb);
        if( ~lazy[pos][ta] || ~lazy[pos][tb] ) push(pos);
        if( !~lazy[pos][tpe] ) lazy[pos][tpe] = val;
        else {
            if( tpe == 0 ) lazy[pos][tpe] ^= val;
            if( tpe == 1 ) lazy[pos][tpe] &= val;
            if( tpe == 2 ) lazy[pos][tpe] |= val;
        }
    }
    inline void push(int pos) {
        if( l[pos] == r[pos] ) return;
        for(int i=0;i<3;i++)
            if( ~lazy[pos][i] ) {
                apply(lson[pos],lazy[pos][i],i) ,
                apply(rson[pos],lazy[pos][i],i) ;
                lazy[pos][i] = -1;
            }
    }
    inline void build(int pos,int ll,int rr) {
        l[pos] = ll , r[pos] = rr;
        if( ll == rr ) return;
        const int mid = ( ll + rr ) >> 1;
        build(lson[pos]=++cnt,ll,mid) ,
        build(rson[pos]=++cnt,mid+1,rr) ;
    }
    inline void update(int pos,int ll,int rr,int val,int tpe) {
        if( ll <= l[pos] && r[pos] <= rr ) return apply(pos,val,tpe);
        const int mid = ( l[pos] + r[pos] ) >> 1;
        push(pos);
        if( rr <= mid ) return update(lson[pos],ll,rr,val,tpe);
        if( ll > mid ) return update(rson[pos],ll,rr,val,tpe);
        update(lson[pos],ll,rr,val,tpe) , update(rson[pos],ll,rr,val,tpe);
    }
    inline int query(int pos,int tar) {
        if( l[pos] == r[pos] ) return in[l[pos]];
        const int mid = ( l[pos] + r[pos] ) >> 1;
        push(pos);
        if( tar <= mid ) return query(lson[pos],tar);
        else return query(rson[pos],tar);
    }
    SegmentTree() {
        memset(lazy,-1,sizeof(lazy));
    }
}segt;

struct LinerBase {
    int dat[maxl];
    inline bool insert(int x) {
        for(int i=31;~i;i--)
            if( x & ( 1 << i ) ) {
                if( dat[i] ) x ^= dat[i];
                else {
                    dat[i] = x;
                    return 1;
                }
            }
        return 0;
    }
    inline void reset() {
        memset(dat,0,sizeof(dat));
    }
}lb;

inline bool query(int l,int r) {
    if( r - l + 1 > 30 ) return 1;
    lb.reset();
    for(int i=l,q;i<=r;i++) {
        q = segt.query(1,i);
        if( !lb.insert(q) ) return 1;
    }
    return 0;
}

__inline char nxtchar() {
    return getchar();
    static const int BS = 1 << 21;
    static char buf[BS],*st=buf+BS,*ed=buf+BS;
    if( st == ed ) ed = buf + fread(st=buf,1,BS,stdin);
    return st == ed ? -1 : *st++;
}
__inline int getint() {
    int ret = 0 , ch;
    while( !isdigit(ch=nxtchar()) );
    do ret=ret*10+ch-'0'; while( isdigit(ch=nxtchar()) );
    return ret;
}


int main() {
    static int m;
    n = getint();
    for(int i=1;i<=n;i++) in[i] = getint();
    segt.build(segt.cnt=1,1,n);
    m = getint();
    for(int i=1,o,l,r,x;i<=m;i++) {
        o = getint() , l = getint() , r = getint();
        if( !o ) puts(query(l,r)?"Yes":"No");
        else {
            x = getint() , o %= 3;
            segt.update(1,l,r,x,o);
        }
    }
    return 0;
}

正解代码:

#pragma GCC optimize(3)
#include<cstdio>
#include<cstring>
#include<cctype>
const int maxn=1e5+1e2,maxl=32;

unsigned in[maxn];
int n;
struct SegmentTree {
    int l[maxn<<2],r[maxn<<2],lson[maxn<<2],rson[maxn<<2],cnt;
    struct Node {
        char dat[maxl];
        char& operator [] (const int &x) {
            return dat[x];
        }
        inline bool empty() {
            for(int i=0;i<maxl;i++) if( ~dat[i] ) return 0;
            return 1;
        }
        inline void reset() {
            memset(dat,-1,sizeof(dat));
        }
        inline unsigned build() {
            unsigned ret = 0;
            for(int i=0;i<maxl;i++) {
                //if( !~dat[i] ) throw "You shouldn't build this ."; ???
                ret |= ( (unsigned) dat[i] << i );
            }
            return ret;
        }
        inline void fill(unsigned x) {
            for(int i=0;i<maxl;i++) dat[i] = ( x >> i ) & 1;
        }
        Node() {
            memset(dat,-1,sizeof(dat));
        }
    }ns[maxn<<2],lazy[maxn<<2]; // lazy = 1 means fill 1 , lazy = 0 means fill 0 , lazy = 2 means neg , lazy = -1 means nothing to do .
    inline void apply(int pos,Node &sou) {
        for(int i=0;i<maxl;i++) if( ~sou[i] ) {
            if( sou[i] != 2 ) ns[pos][i] = lazy[pos][i] = sou[i];
            else {
                ns[pos][i] ^= 1;
                if( !~lazy[pos][i] ) lazy[pos][i] = 2;
                else if( lazy[pos][i] == 2 ) lazy[pos][i] = -1;
                else lazy[pos][i] ^= 1;
            }
        }
    }
    inline void push(int pos) {
        if( l[pos] == r[pos] || lazy[pos].empty() ) return;
        apply(lson[pos],lazy[pos]) ,
        apply(rson[pos],lazy[pos]) ;
        lazy[pos].reset();
    }
    inline void build(int pos,int ll,int rr) {
        l[pos] = ll , r[pos] = rr;
        if( ll == rr ) return ns[pos].fill(in[ll]);
        const int mid = ( ll + rr ) >> 1;
        build(lson[pos]=++cnt,ll,mid) ,
        build(rson[pos]=++cnt,mid+1,rr) ;
    }
    inline void update(int pos,int ll,int rr,Node &o) {
        if( ll <= l[pos] && r[pos] <= rr ) return apply(pos,o);
        const int mid = ( l[pos] + r[pos] ) >> 1;
        push(pos);
        if( rr <= mid ) return update(lson[pos],ll,rr,o);
        if( ll > mid ) return update(rson[pos],ll,rr,o);
        update(lson[pos],ll,rr,o) , update(rson[pos],ll,rr,o);
    }
    inline unsigned query(int pos,int tar) {
        if( l[pos] == r[pos] ) return ns[pos].build();
        const int mid = ( l[pos] + r[pos] ) >> 1;
        push(pos);
        if( tar <= mid ) return query(lson[pos],tar);
        else return query(rson[pos],tar);
    }
    SegmentTree() {
        memset(lazy,-1,sizeof(lazy));
    }
}segt;

struct LinerBase {
    unsigned dat[maxl];
    inline bool insert(unsigned x) {
        for(int i=31;~i;i--)
            if( x & ( 1 << i ) ) {
                if( dat[i] ) x ^= dat[i];
                else {
                    dat[i] = x;
                    return 1;
                }
            }
        return 0;
    }
    inline void reset() {
        memset(dat,0,sizeof(dat));
    }
}lb;

inline bool query(int l,int r) {
    if( r - l + 1 > 30 ) return 1;
    lb.reset();
    for(int i=l,q;i<=r;i++) {
        q = segt.query(1,i);
        if( !lb.insert(q) ) return 1;
    }
    return 0;
}

inline SegmentTree::Node getnode(const unsigned &x,const int o) {
    SegmentTree::Node ret;
    if( !o ) {
        for(int i=0;i<maxl;i++) if( ( x >> i ) & 1 ) ret[i] = 2;
    } else if( o == 1 ) {
        for(int i=0;i<maxl;i++) if( ! ( ( x >> i ) & 1 ) ) ret[i] = 0;
    } else if( o == 2 ) {
        for(int i=0;i<maxl;i++) if( ( x >> i ) & 1u ) ret[i] = 1;
    }
    return ret;
}

inline char nxtchar() {
    static const int BS = 1 << 21;
    static char buf[BS],*st=buf+BS,*ed=buf+BS;
    if( st == ed ) ed = buf + fread(st=buf,1,BS,stdin);
    return st == ed ? -1 : *st++;
}
inline int getint() {
    int ret = 0 , ch;
    while( !isdigit(ch=nxtchar()) );
    do ret=ret*10+ch-'0'; while( isdigit(ch=nxtchar()) );
    return ret;
}


int main() {
    static int m;
    static unsigned x;
    static SegmentTree::Node ONode;
    n = getint();
    for(int i=1;i<=n;i++) in[i] = getint();
    segt.build(segt.cnt=1,1,n);
    m = getint();
    for(int i=1,o,l,r;i<=m;i++) {
        o = getint() , l = getint() , r = getint();
        if( !o ) puts(query(l,r)?"Yes":"No");
        else {
            x = getint() , o %= 3;
            ONode = getnode(x,o);
            segt.update(1,l,r,ONode);
        }
    }
    return 0;
}

 

T2:

首先不要被这题面吓到......
他说出现位置完全相同，好像似曾相识的样子啊，等等，这不就是后缀自动机的节点的right集合的性质吗?
所以第一个条件就是说我们不能在根节点到其他点的一条链上选出两个人。
第二个条件就是我们需要找一些链覆盖所有节点。
好的，建立广义SAM然后跑最小链覆盖不就好了。
无解什么鬼啊?怕不是炸胡，样例没有我也构造不出来，不管他了QAQ。
于是这样你就get到了30分......
为什么?显然一个人认识的人并不是在一般的一条链上，而是在从根节点到这个点的一条链。
也就是说，我们最小链覆盖的所有链都必须从根节点的后继节点开始。
这东西最小链覆盖没法做了，我们需要拆点然后跑有上下界的最小流。
最小流怎么办?首先先随便找出一条可行流，拆掉超级源超级汇和inf边，再由汇点向源点退流，减去退掉的流量就好了。
考场30分代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#define debug cout
using namespace std;
const int maxn=5e3+1e2;
const int inf=0x3f3f3f3f;

int in[maxn],n,ans;

namespace NetworkFlow {
    int s[maxn<<2],t[maxn<<6],nxt[maxn<<6],f[maxn<<6],dep[maxn<<2];
    int st,ed;
    inline void coredge(int from,int to,int flow) {
        static int cnt = 1;
        t[++cnt] = to , f[cnt] = flow ,
        nxt[cnt] = s[from] , s[from] = cnt;
    }
    inline void singledge(int from,int to,int flow) {
        coredge(from,to,flow) , coredge(to,from,0);
    }
    inline bool bfs() {
        memset(dep,-1,sizeof(dep)) , dep[st] = 0;
        queue<int> q; q.push(st);
        while( q.size() ) {
            const int pos = q.front(); q.pop();
            for(int at=s[pos];at;at=nxt[at])
                if( f[at] && !~dep[t[at]] )
                    dep[t[at]] = dep[pos] + 1 , q.push(t[at]);
        }
        return ~dep[ed];
    }
    inline int dfs(int pos,int flow) {
        if( pos == ed ) return flow;
        int ret = 0 , now = 0;
        for(int at=s[pos];at;at=nxt[at])
            if( f[at] && dep[t[at]] > dep[pos] ) {
                now = dfs(t[at],min(flow,f[at])) ,
                ret += now , flow -= now ,
                f[at] -= now , f[at^1] += now;
                if( !flow ) return ret;
            }
        if( !ret ) dep[pos] = -1;
        return ret;
    }
    inline int dinic() {
        int ret = 0 , now = 0;
        while( bfs() ) {
            while( ( now = dfs(st,inf) ) )
                ret += now;
        }
        return ret;
    }
}

namespace SAM {
    map<int,int> ch[maxn<<1];
    int fa[maxn<<1],len[maxn<<1],root,last,cnt;
    
    inline int NewNode(int ll) {
        len[++cnt] = ll;
        return cnt;
    }
    inline void extend(int x) {
        int p = last;
        int np = NewNode(len[p]+1);
        while( p && ch[p].find(x) == ch[p].end() ) ch[p][x] = np , p = fa[p];
        if( !p ) fa[np] = root;
        else {
            int q = ch[p][x];
            if( len[q] == len[p] + 1 ) fa[np] = q;
            else {
                int nq = NewNode(len[p]+1);
                ch[nq] = ch[q] , fa[nq] = fa[q];
                fa[np] = fa[q] = nq;
                while( p && ch[p][x] == q ) ch[p][x] = nq , p = fa[p];
            }
        }
        last = np;
    }
    inline void Ex_extend(int* sou,int li) {
        last = root;
        for(int i=1;i<=li;i++) {
            if( ch[last].find(sou[i]) != ch[last].end() ) last = ch[last][sou[i]];
            else extend(sou[i]);
        }
    }
}

inline void build() {
    using SAM::ch;using SAM::cnt;
    using NetworkFlow::singledge; using NetworkFlow::st; using NetworkFlow::ed;
    st = cnt * 2 + 1 , ed = st + 1;
    #define cov(x) (x+cnt)
    for(int i=1;i<=cnt;i++) {
        singledge(st,i,1) , singledge(cov(i),ed,1);
        for(map<int,int>::iterator it=ch[i].begin();it!=ch[i].end();++it)
            singledge(i,cov(it->second),1);
    }
    ans = cnt;
}

int main() {
    static int k,m;
    SAM::root = SAM::NewNode(0);
    scanf("%d%d",&k,&m);
    if( k == 1 ) return puts("1"),0;
    while(m--) {
        scanf("%d",&n);
        for(int i=1;i<=n;i++) scanf("%d",in+i);
        SAM::Ex_extend(in,n);
    }
    build();
    ans -= NetworkFlow::dinic();
    printf("%d\n",ans);
    return 0;
}

正解代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#define debug cout
using namespace std;
const int maxn=5e3+1e2;
const int inf=0x3f3f3f3f;
 
int in[maxn],n,ans,sum;
 
namespace NetworkFlow {
    int s[maxn<<2],t[maxn<<6],nxt[maxn<<6],f[maxn<<6],dep[maxn<<2],deg[maxn<<2],cnt=1;
    int bak[maxn<<2],bcnt;
    int st,ed,_s,_t;
    inline void coredge(int from,int to,int flow) {
        t[++cnt] = to , f[cnt] = flow ,
        nxt[cnt] = s[from] , s[from] = cnt;
    }
    inline void singledge(int from,int to,int flow) {
        coredge(from,to,flow) , coredge(to,from,0);
    }
    inline bool bfs() {
        memset(dep,-1,sizeof(dep)) , dep[st] = 0;
        queue<int> q; q.push(st);
        while( q.size() ) {
            const int pos = q.front(); q.pop();
            for(int at=s[pos];at;at=nxt[at])
                if( f[at] && !~dep[t[at]] ) {
                    dep[t[at]] = dep[pos] + 1 , q.push(t[at]);
                }
        }
        return ~dep[ed];
    }
    inline int dfs(int pos,int flow) {
        if( pos == ed ) return flow;
        int ret = 0 , now = 0;
        for(int at=s[pos];at;at=nxt[at])
            if( f[at] && dep[t[at]] > dep[pos] ) {
                now = dfs(t[at],min(flow,f[at])) ,
                ret += now , flow -= now ,
                f[at] -= now , f[at^1] += now;
                if( !flow ) return ret;
            }
        if( !ret ) dep[pos] = -1;
        return ret;
    }
    inline int dinic() {
        int ret = 0 , now = 0;
        while( bfs() ) {
            while( ( now = dfs(st,inf) ) )
                ret += now;
        }
        return ret;
    }
    inline int findflow() {
        for(int at=s[_t];at;at=nxt[at])
            if( t[at] = _s ) return f[at^1];
        throw "It shouldn't be here";
    }
    inline void backup() {
        memcpy(bak,s,sizeof(s)) , bcnt = cnt;
    }
    inline void restore() {
        memcpy(s,bak,sizeof(bak)) , cnt = bcnt;
    }
}
 
namespace SAM {
    map<int,int> ch[maxn<<1];
    int fa[maxn<<1],len[maxn<<1],root,last,cnt;
     
    inline int NewNode(int ll) {
        len[++cnt] = ll;
        return cnt;
    }
    inline void extend(int x) {
        int p = last;
        int np = NewNode(len[p]+1);
        while( p && ch[p].find(x) == ch[p].end() ) ch[p][x] = np , p = fa[p];
        if( !p ) fa[np] = root;
        else {
            int q = ch[p][x];
            if( len[q] == len[p] + 1 ) fa[np] = q;
            else {
                int nq = NewNode(len[p]+1);
                ch[nq] = ch[q] , fa[nq] = fa[q];
                fa[np] = fa[q] = nq;
                while( p && ch[p][x] == q ) ch[p][x] = nq , p = fa[p];
            }
        }
        last = np;
    }
    inline void Ex_extend(int* sou,int li) {
        last = root;
        for(int i=1;i<=li;i++) {
            if( ch[last].find(sou[i]) != ch[last].end() ) last = ch[last][sou[i]];
            else extend(sou[i]);
        }
    }
}
 
inline void build() {
    using SAM::ch;using SAM::cnt;
    using namespace NetworkFlow;
    _s = cnt * 2 + 1 , _t = _s + 1 , st = _t + 1 , ed = st + 1;
    #define cov(x) (x+cnt)
    for(int i=1;i<=cnt;i++) {
        if( i != 1 ) ++deg[i] , --deg[cov(i)];
        for(map<int,int>::iterator it=ch[i].begin();it!=ch[i].end();it++) {
            const int tar = it->second;
            if( i == 1 ) singledge(_s,tar,1);
            else singledge(cov(i),tar,1);
        }
        if( i != 1 ) singledge(cov(i),_t,1);
    }
    backup();
    for(int i=1;i<=_t;i++) {
        if( !deg[i] ) continue;
        if( deg[i] > 0 ) singledge(i,ed,deg[i]) , sum += deg[i];
        else singledge(st,i,-deg[i]);
    }
    singledge(_t,_s,inf);
}
inline int getans() {
    using namespace NetworkFlow;
    int d = dinic();
    if( d != sum ) return 0; // No solution .
    int ret = findflow();
    restore();
    st = _t , ed = _s;
    int dd = dinic();
    return ret - dd;
}

int main() {
    static int k,m;
    SAM::root = SAM::NewNode(0);
    scanf("%d%d",&k,&m);
    if( k == 1 ) return puts("1"),0;
    while(m--) {
        scanf("%d",&n);
        for(int i=1;i<=n;i++) scanf("%d",in+i);
        SAM::Ex_extend(in,n);
    }
    build();
    ans = getans();
    printf("%d\n",ans);
    return 0;
}

 

T3:

人生第一道交互题啊......
一看又是神仙题，好的，既然算出一个多项式有40%的分，那我钦定m为0，扔掉b，让他帮我插值，我直接NTT求解A好了。
什么?他没告诉我原根?好吧，我自己求。
求原根这种东西，反正就是把p-1先分解质因数，然后保证x^(p/div[i])在mod p意义下不为1就行了。
原根不能很大，暴力一个一个找就可以通过的说。
(一下为吐槽时间)
然后写了，调了，WA样例了......检查NTT，没错......输出插值用的x，没错......
自行插值他给的多项式，等等，怎么我计算出的值和他算出的不一样啊?
怕不是交互库WA了，去看通知，10:54有一个修正......
赶紧下载下来看看，woc怎么还是WA的?
改用单点插值看看，好，对了。
交互库WA了什么的，这是天不让我做题啊。
好的，单点插值交吧，反正大家都没法做就是了。
11:04,再次修正，这次交互库终于对了......
(吐槽时间结束)
官方题解放上来吧，真·神仙打架(蒟蒻只能瑟瑟发抖):

考场31分代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include"poly.h"
//#define fixed
typedef long long int lli;
using namespace std;
const int maxn=65539;

int mod,g,len,n;
lli ans[maxn],tp[maxn];
int oty[maxn];

inline lli fastpow(lli base,int tim) {
    lli ret = 1;
    while( tim ) {
        if( tim & 1 ) ret = ret * base % mod;
        if( tim >>= 1 ) base = base * base % mod;
    }
    return ret % mod;
}
inline void NTT(lli* dst,int n,int ope) {
    for(int i=0,j=0;i<n;i++) {
        if( i < j ) swap( dst[i] , dst[j] );
        for(int t=n>>1;(j^=t)<t;t>>=1) ;
    }
    for(int len=2;len<=n;len<<=1) {
        const int h = len >> 1;
        lli per = fastpow(g,mod/(len));
        if( !~ope ) per = fastpow(per,mod-2);
        for(int st=0;st<n;st+=len) {
            lli w = 1;
            for(int pos=0;pos<h;pos++) {
                const lli u = dst[st+pos] , v = dst[st+pos+h] * w % mod;
                dst[st+pos] = ( u + v ) % mod ,
                dst[st+pos+h] = ( u - v + mod ) % mod ,
                w = w * per % mod;
            }
        }
    }
    if( !~ope ) {
        const lli mul = fastpow(n,mod-2);
        for(int i=0;i<n;i++) dst[i] = dst[i] * mul % mod;
    }
}

namespace FindRoot {
    int divs[maxn],cnt;
    inline void cut(int x) {
        for(int i=2;(lli)i*i<=x;i++)
            if( ! ( x % i ) ) {
                divs[++cnt] = i;
                while( ! ( x % i ) ) x /= i;
            }
    }
    inline bool judge(int x) {
        for(int i=1;i<=cnt;i++)
            if( fastpow(x,mod/divs[i]) == 1 ) return 0;
        return 1;
    }
    inline int findrt() {
        cut(mod-1);
        for(int i=2;i<mod;i++) if( judge(i) ) return i;
        throw "There is no primary root ! ";
    }
}

int init(int l,int r,int _n,int P) {
    ++_n;
    for(len=1;len<=_n;len<<=1) ;
    mod = P , n = _n , g = FindRoot::findrt();
    return 0;
}
void solve(int *A,int *B) {
    for(int i=0;i<len;i++) tp[i] = fastpow(g,(mod/len)*i);
    //#ifdef fixed
        for(int i=len;i;i--) tp[i] = tp[i-1];
        get(len,tp,oty);
        for(int i=0;i<len;i++) ans[i] = oty[i+1];
    /*#else
        for(int i=0;i<len;i++) ans[i] = get(tp[i]);
    #endif*/
    NTT(ans,len,-1);
    for(int i=0;i<n;i++) A[i] = B[i] = ans[i];
}

某不科学的超(时)std(卡评测8分钟的说):

#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for (int i = a, _ = b; i <= _; i ++)
#define per(i,a,b) for (int i = a, _ = b; i >= _; i --)
#define For(i,a,b) for (int i = a, _ = b; i <  _; i ++)
 
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/hash_policy.hpp>
 
#include "poly.h"
 
typedef long long ll;
 
int mod, g;
 
namespace Interpolation {
 
#define iter(i, n) for (int i = 1; i <= n; ++i)
#define iter0(i, n) for (int i = 0; i < n; ++i)
#define forw(i, a, b) for (int i = a; i <= b; ++i)
#define down(i, a, b) for (int i = b; i >= a; --i)
 
#define reset(a, l, r) forw(i, l, r) a[i] = 0;
#define NR 401000
 
  typedef vector<int> Poly;
 
  inline int pr(int a, int z) {
    int s = 1;
    while (z > 0) {
      if (z % 2 == 1) s = 1ll * s * a % mod;
      a = 1ll * a * a % mod;
      z /= 2;
    }
    return s;
  }
 
  inline int mod_inv(int a) { return pr(a, mod - 2); }
 
  void fft(int *a, int n, int ty) {
    for (int i = n >> 1, j = 1, k; j < n - 1; ++j) {
      if (i > j) swap(a[i], a[j]);
      for (k = n >> 1; k <= i; k >>= 1) i ^= k;
      i ^= k;
    }
 
    for (int m = 2; m <= n; m <<= 1) {
      int h = m >> 1, wm = pr(g, (mod - 1) / m * (ty == +1 ? 1 : (m - 1)));
 
      for (register int i = 0; i < n; i += m) {
    register int w = 1;
    for (int j = i; j < i + h; ++j) {
      register int u = a[j], v = 1ll * w * a[j + h] % mod;
                     
      a[j] = (u + v) % mod;
      a[j + h] = (u - v + mod) % mod;
      w = 1ll * w * wm % mod;
    }
      }
    }
 
    if (ty == -1) {
      int iv = mod_inv(n);
      iter0(i, n) a[i] = 1ll * a[i] * iv % mod;
    }
  }
 
  ostream& operator<<(ostream &output, const Poly &a){  
    output << "[";
    int la = a.size();
    iter0(i, la)
      output << a[i] << (i + 1 == la ? ']' : ',');
    return output;
  }
 
  void upd(Poly &a) { while (!a.empty() && a.back() == 0) a.pop_back(); }
 
  inline Poly operator+(const Poly &a, const Poly &b) {
    int la = a.size(), lb = b.size();
    int lc = max(la, lb);
    Poly c(lc);
    iter0(i, lc) c[i] = ((i < la ? a[i] : 0) + (i < lb ? b[i] : 0)) % mod;
    return upd(c), c;
  }
  inline void poly_multo(int a[], int b[], int N) {
    fft(a, N, +1), fft(b, N, +1);
    iter0(i, N) a[i] = 1ll * a[i] * b[i] % mod;
    fft(a, N, -1);
  }
 
  int ta[NR], tb[NR];
 
  Poly operator*(const Poly &a, const Poly &b) {
    int la = a.size(), lb = b.size();
         
    Poly c(la + lb - 1);
         
    if (la + lb <= 100) {
      iter0(i, la) iter0(j, lb) c[i + j] = (c[i + j] + 1ll * a[i] * b[j]) % mod;
    } else {
      int N;
      for (N = 1; N < la + lb; N <<= 1);
      iter0(i, N) {
    ta[i] = (i < la ? a[i] : 0);
    tb[i] = (i < lb ? b[i] : 0);
      }
      poly_multo(ta, tb, N);
      iter0(i, la + lb - 1) c[i] = ta[i];
    }
    return upd(c), c;
  }
  int ccc = 0;
  int ti[NR];
 
  void poly_inv(int *f, int *inv, int n) {
    if (n == 0) {
      inv[0] = mod_inv(f[0]);
      return;
    }
    poly_inv(f, inv, n / 2);
    static int t[140000];
    int N = 1;
    for (; N <= n * 2; N <<= 1);
    iter0(i, N) t[i] = i <= n ? f[i] : 0; reset(inv, n / 2 + 1, N);
    fft(inv, N, +1); fft(t, N, +1);
    iter0(i, N) inv[i] = (2 + mod - 1ll * inv[i] * t[i] % mod) * inv[i] % mod;
    fft(inv, N, -1);
  }
 
  void poly_mod(int *a, int *b, int *c, int n, int m) {
    if (n < m) {
      iter0(i, m) c[i] = i <= n ? a[i] : 0;
      return;
    }
    static int f[140000], g[140000];
    if (n < 100) {
      int invb = mod_inv(b[m]);
      memcpy(f, a, sizeof(int) * (n + 1));
      down(i, n, m) {
    int t = 1ll * f[i] * invb % mod;
    forw(j, 0, m) (f[i - j] += mod - 1ll * t * b[m - j] % mod) %= mod;
      }
      memcpy(c, f, sizeof(int) * m);
      return;
    }
         
    int N;
    for (N = 1; N <= max(n, 2 * (n - m)) + 10; N <<= 1);
    reset(g, 0, N);
         
    forw(i, 0, n - m) f[i] = i <= m ? b[m - i] : 0; reset(f, n - m + 1, N);
    poly_inv(f, g, n - m); reset(g, n - m + 1, N);
    forw(i, 0, n - m) f[i] = a[n - i];
    poly_multo(g, f, N);
    reset(g, n - m + 1, N);
    reverse(g, g + n - m + 1);
    forw(i, 0, m) f[i] = b[i]; reset(f, m + 1, N);
    poly_multo(f, g, N);
    iter0(i, m) c[i] = (a[i] + mod - f[i]) % mod;
  }
  int tr[NR];
 
  Poly operator%(const Poly &a, const Poly &b) {
         
    int la = a.size(), lb = b.size(), N;
    Poly c(lb);
    for (N = 1; N < la + lb; N <<= 1);
    iter0(i, N) {
      ta[i] = (i < la ? a[i] : 0);
      tb[i] = (i < lb ? b[i] : 0);
    }
    poly_mod(ta, tb, tr, la - 1, lb - 1);
         
    iter0(i, lb) c[i] = tr[i];
    iter0(i, N) tr[i] = 0;
    upd(c);
         
    return c;
  }
  Poly t[NR], tt[NR];
  int tsz, lc[NR], rc[NR];
 
 
  void init(int &x, int l, int r, int *a) {
    x = ++tsz;
    if (l == r) {
      t[x] = { (mod - a[l]) % mod, 1 };
      return;
    }
    int mid = (l + r) / 2;
    init(lc[x], l, mid, a);
    init(rc[x], mid + 1, r, a);
    t[x] = t[lc[x]] * t[rc[x]];
  }
 
  int eval(const Poly &A, int x) {
    int p = 1, res = 0;
    for (auto it = A.begin(); it != A.end(); ++it) {
      res = (res + 1ll * p * *it) % mod;
      p = 1ll * p * x % mod;
    }
    return res;
  }
 
  int pp[NR];
 
  Poly D(const Poly &a) {
    int la = a.size();
    Poly c(la - 1);
    iter(i, la - 1) c[i - 1] = 1ll * i * a[i] % mod;
    return c;
  }
 
  void s2(int x, int l, int r, const Poly &f, int qX[], int ans[]) {
    if (f.size() < 1000 || r - l + 1 <= 200) {
      forw(i, l, r) pp[i] = 1;
      for (auto it = f.begin(); it != f.end(); ++it) {
    forw(i, l, r) {
      ans[i] = (ans[i] + 1ll * pp[i] * *it) % mod;
      pp[i] = 1ll * pp[i] * qX[i] % mod;
    }
      }
      return;
    }
 
    int mid = (l + r) / 2;
    s2(lc[x], l, mid, f % t[lc[x]], qX, ans);
    s2(rc[x], mid + 1, r, f % t[rc[x]], qX, ans);
  }
  int root;
 
 
 
  void evaluation(const Poly &f, bool inited, int qX[], int ans[], int m) {
    if (!inited) {
      tsz = 0;
      init(root, 1, m, qX);
    }
    s2(root, 1, m, f, qX, ans);
         
  }
 
  int px[NR], py[NR], qx[NR], qy[NR], Q[NR], n, m;
 
  Poly s1(int x, int l, int r) {
    if (l == r) {
      Poly tmp = { (int) (1ll * py[l] * mod_inv(Q[l]) % mod) };
      return tmp;
    }
    int mid = (l + r) / 2;
    Poly L = s1(lc[x], l, mid), R = s1(rc[x], mid + 1, r);
    return L * t[rc[x]] + R * t[lc[x]];
  }
 
  Poly interpolation(int m, long long *x, int *y) {
    n = m;
    for (int i = 1; i <= n; i ++)
      px[i] = x[i] % mod, py[i] = y[i];
    init(root, 1, n, px);
    evaluation(D(t[1]), true, px, Q, n);
    return s1(root, 1, n);
  }
 
}
 
inline int rnd() {
  if (RAND_MAX < mod)
    return rand() << 15 | rand();
  else
    return rand();
}
 
inline int Pow(ll a, ll b, int p = mod) {
  int t = 1;
  //b %= p - 1;
  a %= p;
  while (b) {
    if (b & 1) t = 1ll * t * a % p;
    a = 1ll * a * a % p, b >>= 1;
  }
  return t;
}
   
inline bool check(int x, int k) {
  return (mod - 1) % k == 0 && k != mod - 1 && Pow(x, k) == 1;
}
 
inline int get_root() {
  for (int r = 2;; r ++) {
    int flag = 1;
    for (int k = 1; 1ll * k * k <= mod; k ++) {
      if (check(r, k) || check(r, (mod - 1) / k)) {
    flag = 0;
    break;
      }
    }
    if (flag) return r;
  }
}
 
inline int get_log(int a, int x) {
  static __gnu_pbds::gp_hash_table<int, int> ms;
  ms.clear();
  int m = int(sqrt(mod) + 0.5);
  int t = 1, xx = Pow(a, m);
  rep (i , 0 , mod / m + 1) {
    if (ms.find(t) == ms.end()) ms[t] = i;
    t = 1ll * t * xx % mod;
  }
  //cerr << ms.size() << endl;
  t = Pow(a, mod - 2);
  //assert(1ll * a * t % mod == 1);
  rep (i , 0 , m) {
    if (ms.find(x) != ms.end())
      return ms[x] * m + i;
    x = 1ll * x * t % mod;
  }
  assert(0);
  return -1;
}
 
const int maxn = 100007;
 
int n, m;
ll x[maxn];
int y[maxn];
 
int init(int l, int r, int _n, int P) {
  //auto st = clock();
  srand(time(0));
  n = _n;
  mod = P;
  g = get_root();
  for (;;) {
    m = rnd() % (r - l + 1) + l;
    int z = get_log(g, m);
    if (z & 1) {
      //cerr << "init time: " << (clock() - st) / 1000.0 << endl;
      return m;
    }
  }
}
 
void solve(int *A, int *B) {
  //auto st = clock();
 
  int k2 = 1, k1 = mod - 1;
  while (k1 % 2 == 0) k1 >>= 1, k2 <<= 1;
  int N = n + 1 + (((n + 1) & 1) ^ 1);
  int a = get_log(g, m), c = N % (mod - 1);
  assert(Pow(g, a) == m);
  int _a = Pow(a % k2, k2 / 2 - 1, k2);
  assert(1ll * _a * a % k2 == 1);
  for (int d = 1, i = 1; i <= n + N + 1; d += 2, i ++) {
    int b = 1ll * c * d % k2 * _a % k2;
    //int _d = Pow(g, 1ll * d * k1);
    ll _d = 1ll * d * k1;
    ll _b = 1ll * b * k1 % mod;
    assert(1ll * a * _b % (k1 * k2) == 1ll * c * _d % (k1 * k2));
    _d = Pow(g, _d);
    x[i] = 1ll * _b * mod - 1ll * _d * (mod - 1);
    if (x[i] < 0) x[i] += 1ll * mod * (mod - 1);
    assert(x[i] % mod == _d);
    assert(x[i] % (mod - 1) == _b);
    assert(Pow(x[i], N) == Pow(m, x[i]));
  }
   
  //cerr << "get x time: " << (clock() - st) / 1000.0 << endl;
 
  //st = clock();
  get(n + N + 1, x, y);
  //get(n, x, y);
  //get(N + 1, x + n, y + n);
  //cerr << "get y time: " << (clock() - st) / 1000.0 << endl;
 
  //st = clock();
  auto F = Interpolation::interpolation(n + N + 1, x, y);
  //cerr << "get F time: " << (clock() - st) / 1000.0 << endl;
 
  rep (i , 0 , n) A[i] = F[i];
  rep (i , N , N + n) B[i - N] = F[i];
}

交互库:

#include <bits/stdc++.h>

#include "poly.h"

using namespace std;

#define ER_TOKEN "WA"
#define WA_TOKEN "WA"
#define HF_TOKEN "HF"
#define AC_TOKEN "AC"
#define ED_TOKEN "ED"

inline static void halt(int value = 0)
{
    printf(ED_TOKEN);
    exit(value);
}

namespace Variants {

    const char fin [] = "poly.in";
    const char fout[] = "poly.out";

    const int maxN = 100000 + 7;

    static int mod = 998244353, g = 3;

    static int n, L, R, m;
    static int A[maxN], B[maxN], resA[maxN], resB[maxN];

    inline static int Pow(int a, long long b)
    {
        int t = 1;
        for (/*b %= mod - 1*/; b; b >>= 1, a = 1ll * a * a % mod)
            if (b & 1)
                t = 1ll * t * a % mod;
        return t;
    }

    inline static bool check(int x, int k)
    {
        return (mod - 1) % k == 0 && k != mod - 1 && Pow(x, k) == 1;
    }

    inline static void get_root()
    {
        for (g = 2;; g ++)
        {
            int flag = 1;
            for (int k = 1; 1ll * k * k <= mod; k ++)
                if (check(g, k) || check(g, (mod - 1) / k))
                {
                    flag = 0;
                    break;
                }
            if (flag)
                return;
        }
    }

    inline static void check(long long x)
    {
        static map<int, int> ms1, ms2;

        if (ms1[x % mod])
        {
            puts(ER_TOKEN);
            printf("%d mod P exists twice.\n", int(x % mod));
            halt(1);
        }
        ms1[x % mod] = 1;
        if (ms2[x % (mod - 1)])
        {
            puts(ER_TOKEN);
            printf("%d mod P-1 exists twice.\n", int(x % (mod-1)));
            halt(1);
        }
        ms2[x % (mod - 1)] = 1;
    }

}

using namespace Variants;

namespace Interpol {

    #define iter(i, n) for (int i = 1; i <= n; ++i)
    #define iter0(i, n) for (int i = 0; i < n; ++i)
    #define forw(i, a, b) for (int i = a; i <= b; ++i)
    #define down(i, a, b) for (int i = b; i >= a; --i)

    #define reset(a, l, r) forw(i, l, r) a[i] = 0;
    #define NR 401000

    typedef vector<int> Poly;

    inline int pr(int a, int z) {
        int s = 1;
        while (z > 0) {
            if (z % 2 == 1) s = 1ll * s * a % mod;
            a = 1ll * a * a % mod;
            z /= 2;
        }
        return s;
    }

    inline int mod_inv(int a) { return pr(a, mod - 2); }

    void fft(int *a, int n, int ty) {
        for (int i = n >> 1, j = 1, k; j < n - 1; ++j) {
            if (i > j) swap(a[i], a[j]);
            for (k = n >> 1; k <= i; k >>= 1) i ^= k;
            i ^= k;
        }

        for (int m = 2; m <= n; m <<= 1) {
            int h = m >> 1, wm = pr(g, (mod - 1) / m * (ty == +1 ? 1 : (m - 1)));

            for (register int i = 0; i < n; i += m) {
                register int w = 1;
                for (int j = i; j < i + h; ++j) {
                    register int u = a[j], v = 1ll * w * a[j + h] % mod;
                    
                    a[j] = (u + v) % mod;
                    a[j + h] = (u - v + mod) % mod;
                    w = 1ll * w * wm % mod;
                }
            }
        }

        if (ty == -1) {
            int iv = mod_inv(n);
            iter0(i, n) a[i] = 1ll * a[i] * iv % mod;
        }
    }

    ostream& operator<<(ostream &output, const Poly &a){  
        output << "[";
        int la = a.size();
        iter0(i, la)
            output << a[i] << (i + 1 == la ? ']' : ',');
        return output;
    }

    void upd(Poly &a) { while (!a.empty() && a.back() == 0) a.pop_back(); }

    inline Poly operator+(const Poly &a, const Poly &b) {
        int la = a.size(), lb = b.size();
        int lc = max(la, lb);
        Poly c(lc);
        iter0(i, lc) c[i] = ((i < la ? a[i] : 0) + (i < lb ? b[i] : 0)) % mod;
        return upd(c), c;
    }
    inline void poly_multo(int a[], int b[], int N) {
        fft(a, N, +1), fft(b, N, +1);
        iter0(i, N) a[i] = 1ll * a[i] * b[i] % mod;
        fft(a, N, -1);
    }

    int ta[NR], tb[NR];

    Poly operator*(const Poly &a, const Poly &b) {
        int la = a.size(), lb = b.size();
        
        Poly c(la + lb - 1);
        
        if (la + lb <= 100) {
            iter0(i, la) iter0(j, lb) c[i + j] = (c[i + j] + 1ll * a[i] * b[j]) % mod;
        } else {
            int N;
            for (N = 1; N < la + lb; N <<= 1);
            iter0(i, N) {
                ta[i] = (i < la ? a[i] : 0);
                tb[i] = (i < lb ? b[i] : 0);
            }
            poly_multo(ta, tb, N);
            iter0(i, la + lb - 1) c[i] = ta[i];
        }
        return upd(c), c;
    }
    int ccc = 0;
    int ti[NR];

    void poly_inv(int *f, int *inv, int n) {
        if (n == 0) {
            inv[0] = mod_inv(f[0]);
            return;
        }
        poly_inv(f, inv, n / 2);
        static int t[140000];
        int N = 1;
        for (; N <= n * 2; N <<= 1);
        iter0(i, N) t[i] = i <= n ? f[i] : 0; reset(inv, n / 2 + 1, N);
        fft(inv, N, +1); fft(t, N, +1);
        iter0(i, N) inv[i] = (2 + mod - 1ll * inv[i] * t[i] % mod) * inv[i] % mod;
        fft(inv, N, -1);
    }

    void poly_mod(int *a, int *b, int *c, int n, int m) {
        if (n < m) {
            iter0(i, m) c[i] = i <= n ? a[i] : 0;
            return;
        }
        static int f[140000], g[140000];
        if (n < 100) {
            int invb = mod_inv(b[m]);
            memcpy(f, a, sizeof(int) * (n + 1));
            down(i, n, m) {
                int t = 1ll * f[i] * invb % mod;
                forw(j, 0, m) (f[i - j] += mod - 1ll * t * b[m - j] % mod) %= mod;
            }
            memcpy(c, f, sizeof(int) * m);
            return;
        }
        
        int N;
        for (N = 1; N <= max(n, 2 * (n - m)) + 10; N <<= 1);
        reset(g, 0, N);
        
        forw(i, 0, n - m) f[i] = i <= m ? b[m - i] : 0; reset(f, n - m + 1, N);
        poly_inv(f, g, n - m); reset(g, n - m + 1, N);
        forw(i, 0, n - m) f[i] = a[n - i];
        poly_multo(g, f, N);
        reset(g, n - m + 1, N);
        reverse(g, g + n - m + 1);
        forw(i, 0, m) f[i] = b[i]; reset(f, m + 1, N);
        poly_multo(f, g, N);
        iter0(i, m) c[i] = (a[i] + mod - f[i]) % mod;
    }
    int tr[NR];

    Poly operator%(const Poly &a, const Poly &b) {
        
        int la = a.size(), lb = b.size(), N;
        Poly c(lb);
        for (N = 1; N < la + lb; N <<= 1);
        iter0(i, N) {
            ta[i] = (i < la ? a[i] : 0);
            tb[i] = (i < lb ? b[i] : 0);
        }
        poly_mod(ta, tb, tr, la - 1, lb - 1);
        
        iter0(i, lb) c[i] = tr[i];
        iter0(i, N) tr[i] = 0;
        upd(c);
        
        return c;
    }
    Poly t[NR], tt[NR];
    int tsz, lc[NR], rc[NR];


    void init(int &x, int l, int r, int *a) {
        x = ++tsz;
        if (l == r) {
            t[x] = { (mod - a[l]) % mod, 1 };
            return;
        }
        int mid = (l + r) / 2;
        init(lc[x], l, mid, a);
        init(rc[x], mid + 1, r, a);
        t[x] = t[lc[x]] * t[rc[x]];
    }

    int eval(const Poly &A, int x) {
        int p = 1, res = 0;
        for (auto it = A.begin(); it != A.end(); ++it) {
            res = (res + 1ll * p * *it) % mod;
            p = 1ll * p * x % mod;
        }
        return res;
    }

    int pp[NR];

    Poly D(const Poly &a) {
        int la = a.size();
        Poly c(la - 1);
        iter(i, la - 1) c[i - 1] = 1ll * i * a[i] % mod;
        return c;
    }

    void s2(int x, int l, int r, const Poly &f, int qX[], int ans[]) {
        if (f.size() < 1000 || r - l + 1 <= 200) {
            forw(i, l, r) pp[i] = 1;
            for (auto it = f.begin(); it != f.end(); ++it) {
                forw(i, l, r) {
                    ans[i] = (ans[i] + 1ll * pp[i] * *it) % mod;
                    pp[i] = 1ll * pp[i] * qX[i] % mod;
                }
            }
            return;
        }

        int mid = (l + r) / 2;
        s2(lc[x], l, mid, f % t[lc[x]], qX, ans);
        s2(rc[x], mid + 1, r, f % t[rc[x]], qX, ans);
    }
    int root;

    void evaluation(const Poly &f, bool inited, int qX[], int ans[], int m) {
        if (!inited) {
            tsz = 0;
            init(root, 1, m, qX);
        }
        s2(root, 1, m, f, qX, ans);
        
    }

    int px[NR], py[NR], qx[NR], qy[NR], Q[NR], n, m;

    Poly s1(int x, int l, int r) {
        if (l == r) {
            Poly tmp = { (int) (1ll * py[l] * mod_inv(Q[l]) % mod) };
            return tmp;
        }
        int mid = (l + r) / 2;
        Poly L = s1(lc[x], l, mid), R = s1(rc[x], mid + 1, r);
        return L * t[rc[x]] + R * t[lc[x]];
    }

}

int get(long long x)
{
    check(x);
    int res = 0, t = 1, m = Pow(Variants::m, x);
    x %= mod;
    for (int i = 0; i <= n; i ++)
        {
            (res += (1ll * m * B[i] % mod + A[i]) * t % mod) %= mod;
            t = 1ll * t * x % mod;
        }
    return res;
}

void get(int m, long long *X, int *Y)
{
    static int x[maxN], ya[maxN], yb[maxN];

    //auto st = clock();

    for (int i = 1; i <= m; i ++)
    {
        check(X[i]);
        x[i] = X[i] % mod;
    }

    Interpol::Poly a;
    a.resize(n + 1);

    for (int i = 0; i <= n; i ++)
        a[i] = A[i];
    Interpol::evaluation(a, false, x, ya, m);

    for (int i = 0; i <= n; i ++)
        a[i] = B[i];
    Interpol::evaluation(a, false, x, yb, m);

    //cerr << "evaluate time: " << (clock() - st) / 1000.0 << endl;

    //st = clock();
    for (int i = 1; i <= m; i ++)
        Y[i] = (1ll * Pow(Variants::m, X[i]) * yb[i] % mod + ya[i]) % mod;
    //cerr << "get Y[] time: " << (clock() - st) / 1000.0 << endl;
}

int main()
{
    using namespace Variants;
    freopen(fin , "r", stdin);
    freopen(fout, "w", stdout);
    
    scanf("%d%d%d%d", &n, &L, &R, &mod);
    for (int i = 0; i <= n; i ++)
        scanf("%d", &A[i]);
    for (int i = 0; i <= n; i ++)
        scanf("%d", &B[i]);
    get_root();

    m = init(L, R, n, mod);
    if (!(L <= m && m <= R))
    {
        puts(WA_TOKEN);
        printf("m=%d is not in [%d,%d]\n", m, L, R);
        return 1;
    }
    solve(resA, resB);

    int cntA = 0, cntB = 0;
    for (int i = 0; i <= n; i ++)
    {
        cntA += (A[i] != resA[i] % mod);
        cntB += (B[i] != resB[i] % mod);
    }

/*
    for (int i = 0; i <= n; i ++)
        cerr << resA[i] << " "; cerr << endl;
    for (int i = 0; i <= n; i ++)
        cerr << resB[i] << " "; cerr << endl;
*/

    if (cntA == 0 && cntB == 0)
        puts(AC_TOKEN);
    else if (cntA == 0 || cntB == 0)
    {
        puts(HF_TOKEN);
        char c = cntA ? 'B' : 'A';
        printf("You answer polynomial %c correctly, the other one has %d different coefficients.\n", c, cntA + cntB);
        halt(1);
    }
    else
    {
        puts(WA_TOKEN);
        printf("Your polynomial A and B has %d and %d different coefficients.\n", cntA, cntB);
        halt(1);
    }

    halt();
    return 0;
}

 

在大佬们看来的水题我才考这么几分，果然还是我太菜了呀。