20180417小测

今天又是考试，然而早晨7:30考到中午12:30，没时间吃饭了。
然而并不会做题啊啊啊。

T1:

系数显然是组合数啊......
然后，模数不是质数？这不是拓展lucas裸题吗？
等等，拓展lucas，我只写过一遍诶......
看我大力出奇迹:
就是把模数先分解成p1^k1*p2^k2...的形式，然后我们在mod px^kx的情况下进行计算，最后再用互质的CRT合并即可。
mod px^kx的情况下怎么算？我们能把与px互质的阶乘计算出来，再单独计算阶乘中有px的多少次方。
然后互质的直接在mod px^kx下求逆元即可，非互质的直接次数加减。
然而考场上被卡常只有90......
代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define debug cout
typedef long long int lli;
using namespace std;
const int maxn=4e5+1e2;

lli in[maxn],ans;
lli c[maxn],modc[maxn];
lli fac[maxn],tim[maxn];
lli dvs[maxn],tms[maxn],pows[maxn];
int n,mod,now,psnow,cnt;

inline lli fastpow(lli base,lli tim,lli mod) {
    lli ret = 1;
    while(tim) {
        if( tim & 1 ) ret = ret * base % mod;
        if( tim >>= 1 ) base = base * base % mod;
    }
    return ret;
}
inline lli exgcd(lli a,lli b,lli& x,lli& y) {
    if( !b ) return x = 1 , y = 0 , a;
    lli ret = exgcd(b,a%b,y,x);
    y -= a / b * x;
    return ret;
}
inline lli inv(lli t,lli mod) {
    static lli x,y;
    exgcd(t,mod,x,y);
    return ( x % mod + mod ) % mod;
}
inline void getcoprime(int x,int& retc,int& rett) {
    retc = x , rett = 0;
    while( ! ( retc % now ) ) retc /= now , ++rett;
}
inline void preseq() {
    fac[0] = 1 , tim[0] = 0;
    for(int i=1,c,t;i<=n;i++) {
        getcoprime(i,c,t);
        fac[i] = fac[i-1] * c % psnow , tim[i] = tim[i-1] + t;
    }
}
inline void getdvs(int x) {
    for(int i=2;(lli)i*i<=x;i++)
        if( ! ( x % i ) ) {
            dvs[++cnt] = i , pows[cnt] = 1;
            while( ! ( x % i ) ) ++tms[cnt] , pows[cnt] *= i , x /= i;
        }
    if( x != 1 ) dvs[++cnt] = x , pows[cnt] = x , tms[cnt] = 1;
}
inline void cnow(int x,int& retc,int& rett) {
    retc = fac[n-1] * inv(fac[x],psnow) % psnow * inv(fac[n-1-x],psnow) % psnow;
    rett = tim[n-1] - tim[x] - tim[n-1-x];
}
inline void merge(int x,int fac,int tim) {
    lli cur = (lli) fac * fastpow(now,tim,mod) % mod;
    c[x] = ( c[x] + cur * ( mod / psnow ) % mod * inv( mod / psnow , psnow ) % mod ) % mod;
}


int main() {
    scanf("%d%d",&n,&mod);
    for(int i=1;i<=n;i++) scanf("%lld",in+i);
    getdvs(mod);
    for(int i=1;i<=cnt;i++) {
        now = dvs[i] , psnow = pows[i] , preseq();
        for(int j=0,c,t;j<n;j++) cnow(j,c,t) , merge(j,c,t);
    }
    for(int i=1;i<=n;i++) ( ans += in[i] * c[i-1] % mod ) %= mod;
    printf("%lld
",ans);
    return 0;
}

T2:

考虑暴力怎么写，我们能两遍dfs求出每个人到达每个点的时间。
然后我们可以求两个人在多少个点上相遇。
如果再且仅在一个点上相遇，显然不可能在边上相遇了。
如果相遇的点大于一个，则这两个人显然一起走了一条边。
这样就把在点上相遇的情况解决了。
考虑两个人经过每一条边的时间区间，如果两个人的时间区间在这条边上有交集，在可能在这条边上相遇。
然后考虑两个人的方向，如果行走方向相反的话，一定相遇；如果方向相同的话，当且仅当两个人之间的距离小于边长才会在这条边上相遇。
于是你成功get到了40分。
考虑怎么优化暴力。
我们钦定一个根，然后处理出每个点到根的距离dis。
因为树上路径唯一，所以我们可以把两个人到达每个点的时间化为一个关于dis的函数：timei=k*disi+b。
我们用树链剖分+线段树维护这个函数。
考虑树上每一条链，我们可以O(log)地求出两个人在这条链上停留的时间区间。
然后我们可以通过这条链的两个函数计算出两个人是否在点上相遇，是否在边上同向相遇，是否在边上逆向相遇。
想想就细节很多啊......
我的写法是先求出两个人在多少个点上相遇，判定是否有解。
然后计算两个人能否在边上相遇，显然这时候两个人不可能在点上相遇了，会多一些条件。
提醒几点细节:
虚边可能更新答案(在虚边上相遇)，LCA的函数斜率不要设置为+-1，要设置为0，否则判定相遇方向时存在问题。
线段树上需要另外维护一下区间最长边来解决同方向相遇的情况，查询区间lr相同是没有边的，不可能在这种区间相遇。
考场上写挂了只有30，不如暴力......
改了不知道多久后改对了(这10kb代码是什么鬼)。
代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<set>
#include<cstdlib>
#define debug cout
typedef long long int lli;
using namespace std;
const int maxn=1e5+1e2;

int s[maxn],t[maxn<<1],nxt[maxn<<1];
lli dis[maxn],l[maxn<<1];
int dep[maxn],fa[maxn],siz[maxn],top[maxn],son[maxn],id[maxn],rec[maxn],usl[maxn],usr[maxn];
set<int> cs[maxn];

struct SegmentTree {
    struct Equation { // k * dep + b == tme .
        lli k,b;
        inline lli calc(const lli &x) const {
            return k * x + b;
        }
    }es[maxn<<2];
    int l[maxn<<2],r[maxn<<2],lson[maxn<<2],rson[maxn<<2],used[maxn<<2],dat[maxn<<2],cnt;
    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 fill(int pos,const Equation &e) {
        used[pos] = 1 , es[pos] = e;
    }
    inline void reset(int pos) {
        used[pos] = 0;
    }
    inline void update(int pos,int ll,int rr,const Equation &e) {
        if( rr < l[pos] || r[pos] < ll ) return;
        if( ll <= l[pos] && r[pos] <= rr ) return fill(pos,e);
        update(lson[pos],ll,rr,e) , update(rson[pos],ll,rr,e);
    }
    inline void reset(int pos,int ll,int rr) {
        if( rr < l[pos] || r[pos] < ll ) return;
        if( ll <= l[pos] && r[pos] <= rr ) return reset(pos);
        reset(lson[pos],ll,rr) , reset(rson[pos],ll,rr);
    }
    inline Equation query(int pos,int tar) {
        if( used[pos] ) return es[pos];
        // may cause infinity rec-call .
        const int mid = ( l[pos] + r[pos] ) >> 1;
        if( tar <= mid ) return query(lson[pos],tar);
        else return query(rson[pos],tar);
    }
    inline void update_mx(int pos,const int &tar,const int &x) {
        if( l[pos] == r[pos] ) return void(dat[pos]=x);
        const int mid = ( l[pos] + r[pos] ) >> 1;
        if( tar <= mid ) update_mx(lson[pos],tar,x);
        else update_mx(rson[pos],tar,x);
        dat[pos] = max( dat[lson[pos]] , dat[rson[pos]] );
    }
    inline int query_mx(int pos,int ll,int rr) {
        if( rr < l[pos] || r[pos] < ll ) return -1;
        if( ll <= l[pos] && r[pos] <= rr ) return dat[pos];
        return max( query_mx(lson[pos],ll,rr) , query_mx(rson[pos],ll,rr) );
    }
}sgt;
typedef SegmentTree::Equation Equation;

inline void addedge(int from,int to,int len) {
    static int cnt = 0;
    t[++cnt] = to , l[cnt] = len , nxt[cnt] = s[from] , s[from] = cnt;
}
inline void pre(int pos) {
    siz[pos] = 1;
    for(int at=s[pos];at;at=nxt[at])
        if( t[at] != fa[pos] ) {
            fa[t[at]] = pos , dep[t[at]] = dep[pos] + 1 , dis[t[at]] = dis[pos] + l[at] ,
            pre(t[at]) , siz[pos] += siz[t[at]];
            if( siz[t[at]] > siz[son[pos]] ) son[pos] = t[at];
        }
}
inline void dfs(int pos) {
    static int iid;
    top[pos] = pos == son[fa[pos]] ? top[fa[pos]] : pos , rec[id[pos]=++iid] = pos , cs[top[pos]].insert(dis[pos]);
    sgt.update_mx(1,id[pos],dis[pos]-dis[fa[pos]]);
    if( son[pos] ) dfs(son[pos]);
    for(int at=s[pos];at;at=nxt[at]) if( t[at] != fa[pos] && t[at] != son[pos] ) dfs(t[at]);
}
inline int lca(int x,int y) {
    while( top[x] != top[y] ) {
        if( dep[top[x]] < dep[top[y]] ) swap(x,y);
        x = fa[top[x]];
    }
    return dep[x] < dep[y] ? x : y;
}
inline void chain(int x,int lc,const Equation &e) {
    while( top[x] != top[lc] ) {
        sgt.update(1,id[top[x]],id[x],e) ,
        usl[top[x]] = id[top[x]] , usr[top[x]] = max(usr[top[x]],id[x]) , x = fa[top[x]];
    }
    sgt.update(1,id[lc],id[x],e) , usl[top[x]] = id[lc] , usr[top[x]] = max(usr[top[x]],id[x]);
}
inline void reschain(int x,int lc) {
    while( top[x] != top[lc] ) {
        sgt.reset(1,id[top[x]],id[x]) ,
        usl[top[x]] = usr[top[x]] = 0 , x = fa[top[x]];
    }
    sgt.reset(1,id[lc],id[x]) , usl[top[x]] = usr[top[x]] = 0;
}
inline void filla(int u,int v,lli t) { // from u , to v , start time is t .
    int l = lca(u,v);
    if( l == u ) { // fully down .
        Equation e = (Equation){1,t-dis[u]};
        chain(v,u,e);
    } else if( l == v ) {
        Equation e = (Equation){-1,t+dis[u]};
        chain(u,v,e);
    } else {
        const lli tlca = t + dis[u] - dis[l];
        Equation eu = (Equation){-1,t+dis[u]} , ev = (Equation){1,tlca-dis[l]};
        chain(u,l,eu) , chain(v,l,ev) , sgt.update(1,id[l],id[l],(Equation){0,tlca});
    }
}
inline void reseta(int u,int v) { // from u , to v , start time is t .
    int l = lca(u,v);
    if( l == u ) reschain(v,u);
    else if( l == v ) reschain(u,v);
    else reschain(u,l) , reschain(v,l);
}
inline bool cross(lli x,lli y,lli xx,lli yy) {
    return x <= yy && xx <= y;
}
inline int coresme(int t,int l,int r,const Equation &e) {
    if( l <= r ) { // have same points .
        lli al = sgt.query(1,l).calc(dis[rec[l]]) , ar = sgt.query(1,r).calc(dis[rec[r]]);
        lli bl = e.calc(dis[rec[l]]) , br = e.calc(dis[rec[r]]);
        if( al == bl && ar == br ) { // sameway .
            return r - l + 1;
        } else if( l != r && cross(min(al,ar),max(al,ar),min(bl,br),max(bl,br)) ) {
            Equation ea = sgt.query(1,l) , eaa = sgt.query(1,r);
            if( !ea.k ) ea = eaa; // ea is lca .
            if( ea.k != e.k ) { // may have solution .
                lli lft = ea.k - e.k , rit = e.b - ea.b;
                if( ! ( rit % lft ) ) {
                    lli sol = rit / lft;
                    if( cs[t].find(sol) != cs[t].end() ) return 1;
                }
            }
        }
    }
    return 0;
}
inline int getsme(int x,int lc,const Equation &e,bool qlca) {
    int ret = 0;
    while( top[x] != top[lc] ) {
        const int t = top[x];
        if( usl[t] && usr[t] ) { // same chain visited .
            int l = max( usl[t] , id[top[x]] ) , r = min( usr[t] , id[x] );
            ret += coresme(t,l,r,e);
        }
        x = fa[top[x]];
    }
    const int t = top[x];
    if( usl[t] && usr[t] ) { // same chain visited .
        int l = max( usl[t] , id[lc] + qlca ) , r = min( usr[t] , id[x] );
        ret += coresme(t,l,r,e);
    }
    return ret;
}
inline bool corevis(int t,int l,int r,const Equation &e) {
    if( l < r ) { // have same points .
        lli al = sgt.query(1,l).calc(dis[rec[l]]) , ar = sgt.query(1,r).calc(dis[rec[r]]);
        lli bl = e.calc(dis[rec[l]]) , br = e.calc(dis[rec[r]]);
        if( cross(min(al,ar),max(al,ar),min(bl,br),max(bl,br)) ) {
            Equation ea = sgt.query(1,l) , eaa = sgt.query(1,r);
            if( !ea.k ) ea = eaa;
            if( ea.k == e.k ) {
                if( l == r ) return 0;
                const lli deltab = abs(ea.b-e.b) , mxlen = sgt.query_mx(1,l+1,r);
                return deltab < mxlen;
            } else return 1;
        }
    }
    return 0;
}
inline bool used(int x) {
    int t = top[x];
    return usl[t] && usr[t] && usl[t] <= id[x] && id[x] <= usr[t];
}
inline int vevis(int x,const Equation &e) {
    if( used(x) && used(fa[x]) ) {
        Equation ea = sgt.query(1,id[x]);
        lli al = ea.calc(dis[fa[x]]) , ar = ea.calc(dis[x]);
        lli bl = e.calc(dis[fa[x]]) , br = e.calc(dis[x]);
        if( cross(min(al,ar),max(al,ar),min(bl,br),max(bl,br)) ) {
            if( ea.k == e.k ) {
                const lli deltab = abs(ea.b-e.b) , mxlen = dis[x] - dis[fa[x]];
                return deltab < mxlen;
            } else return 1;
        }
    }
    return 0;
}
inline bool getvis(int x,int lc,const Equation &e) {
    while( top[x] != top[lc] ) {
        const int t = top[x];
        if( usl[t] && usr[t] ) { // same chain visited .
            int l = max( usl[t] , id[top[x]] ) , r = min( usr[t] , id[x] );
            if( corevis(t,l,r,e) ) return 1;
        }
        if( vevis(top[x],e) ) return 1;
        x = fa[top[x]]; // how to deal with this edge ? 
    }
    const int t = top[x];
    if( usl[t] && usr[t] ) { // same chain visited .
        int l = max( usl[t] , id[lc] ) , r = min( usr[t] , id[x] );
        if( corevis(t,l,r,e) ) return 1;
    }
    return 0;
}
inline bool queryb(int u,int v,lli t) {
    int l = lca(u,v) , sme = 0;
    if( l == u ) { // fully down .
        Equation e = (Equation){1,t-dis[u]};
        sme = getsme(v,u,e,0);
        if( sme ) return sme > 1;
        return getvis(v,u,e);
    } else if( l == v ) {
        Equation e = (Equation){-1,t+dis[u]};
        sme = getsme(u,v,e,0);
        if( sme ) return sme > 1;
        return getvis(u,v,e);
    } else {
        const lli tlca = t + dis[u] - dis[l];
        Equation eu = (Equation){-1,t+dis[u]} , ev = (Equation){1,tlca-dis[l]};
        sme = getsme(u,l,eu,0) + getsme(v,l,ev,1);
        if( sme ) return sme > 1;
        return getvis(u,l,eu) || getvis(v,l,ev);
    }
}

int main() {
    static int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1,a,b,l;i<n;i++) scanf("%d%d%d",&a,&b,&l) , addedge(a,b,l) , addedge(b,a,l);
    sgt.build(sgt.cnt=1,1,n) , pre(1) , dfs(1);
    for(int i=1,u,v,t,uu,vv,tt;i<=m;i++) {
        scanf("%d%d%d%d%d%d",&u,&v,&t,&uu,&vv,&tt) , filla(u,v,t);
        puts(queryb(uu,vv,tt)?"YES":"NO") , reseta(u,v);
    }
    return 0;
}

T3:

题答题弃坑啦!

わたしがここにいる
我就在这里
証(あかし)を見(み)せて
见证了看到的一切
閉(と)ざされた仄(くら)き孤洞(こどう)の世界(せかい)で
被封闭了的孤寂的世界
冥闇(やみ)の何処(どこ)かに希望(きぼう)はあるの?
冥冥之中可曾还有希望？
背中合(せなかあ)わせの幻(ゆめ)でもいいから
所以即使是背后的幻想
ふれたいよ…
触手可及