20180615小测

我居然学会WA题了！？

T1:

首先我们能打表观察或者数学推导得到在x为质数时f(x)=x，否则f(x)=2。
之后就是一个裸的k次剩余，也就是Bzoj1319了。
这个东西怎么做？假设我们要求解x^k=a(mod p)，我们能求出p的原根g，并用BSGS求出a=g^n(mod p)。
假设x=g^t，那么我们有:t*k=n(mod phip)，我们要求出所有可行的t。
然后就十分显然了，exgcd求出kx+yphip=gcd(k,phip)，如果n不是gcd(k,phip)则显然无解，否则我们能以n/gcd(k,phip)*x为初值，x%(phip/gcd(phip,k))为步长不断递增求出所有可行的t。
注意特判掉p=2的情况，就可以AC啦。
代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<tr1/unordered_map>
#include<cassert>
#define debug cout
typedef long long int lli;
using namespace std;
using namespace tr1;
const int maxn=5e5+1e2;

lli ans[maxn],anslen;
lli a,b,p,g;

inline bool isprime(lli x) {
    const lli sq = sqrt(x);
    for(lli i=2;i<=sq;i++) if( ! ( x % i ) ) return 0;
    return 1;
}

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);
    return y -= a / b * x , ret;
}

namespace BSGS {
    inline lli BSGS(lli a,lli b) {
        const lli sq = sqrt(p);
        unordered_map<lli,lli> mp;
        lli step = 1 , giant = 1;
        for(lli i=0;i<sq;i++) {
            if( mp.find(step) == mp.end() ) mp[step] = i;
            step = step * a % p;
        }
        for(lli i=0;i<=sq;i++) {
            const lli ned = b * fastpow(giant,p-2,p) % p;
            if( mp.find(ned) != mp.end() ) return sq * i + mp[ned];
            giant = giant * step % p;
        }
        assert(0);
    }
}

namespace GetPrimaryRoot {
    lli dvs[maxn],cnt;
    inline void cut(lli t) {
        const lli sq = sqrt(t);
        for(lli i=2;i<=sq;i++) {
            if( ! ( t % i ) ) {
                dvs[++cnt] = i;
                while( ! ( t % i ) ) t /= i;
            }
        }
        if( t != 1 ) dvs[++cnt] = t;
    }
    inline bool judge(lli x) {
        for(lli i=1;i<=cnt;i++) if( fastpow(x,(p-1)/dvs[i],p) == 1 ) return 0;
        return 1;
    }
    inline lli getroot() {
        for(lli i=1;i<p;i++) if( judge(i) ) return i;
        assert(0);
    }
}

int main() {
    static lli n,phi,x,y,gcd,step;
    scanf("%lld%lld%lld",&a,&b,&p) , p = isprime(p) ? p : 2;
    if( p == 2 ) return assert(b) , puts("1
1") , 0;
    GetPrimaryRoot::cut(p-1) , g = GetPrimaryRoot::getroot() , n = BSGS::BSGS(g,b);
    phi = p - 1 , gcd = exgcd(a,phi,x,y);
    if( n % gcd ) return puts("0") , 0;
    step = phi / gcd , x = ( x % step + step ) % step , x = x * ( n / gcd ) % step;
    while( x < phi ) ans[++anslen] = fastpow(g,x,p) , x += step;
    if( !anslen ) return puts("0") , 0;
    sort(ans+1,ans+1+anslen) , printf("%lld
",anslen);
    for(lli i=1;i<=anslen;i++) printf("%lld%c",ans[i],i!=anslen?' ':'
');
    return 0;
}

T2:

子树修改，链询问，不改变形态，一眼树剖+dfs序。
通过树剖我们能把询问变成dfs序上的logn个区间。
然后就是怎么维护这个序列的问题了，如果我们把点看做横坐标x，白兔数量看做纵坐标y，那么我们要进行的就是区间赋值，区间把点放到一条线上。
(不知道大家怎么想，反正我不会用线段树或者kdtree做......)
考虑分块，块内用数据结构(我选择了非旋treap)维护横坐标为x的最大的y。
这样对于整块的修改w，我们打标记，整块修改b，我们打标记，非整块修改，我们暴力push标记然后重构整个块。
查询怎么办？
对于整块的查询，如果有w标记且w标记在区间内，返回区间最大的b，否则返回0。
对于整块的查询，如果没有w标记，就是经典的treap区间查询了。(注意如果有b标记也不能直接返回b，因为我们需要的区间在块内可能为空)。
对于非整块的查询，暴力。
这个东西的时间复杂度是O(nsqrt(n)log^2n)，空间复杂度线性。但是由于树剖和非旋treap的常数都很小，于是就可以AC啦(踩爆标程的3个log)。
另外神仙lyy的复杂度和链上颜色数相关的算法也AC了......我能把他卡成n^2......辣鸡出题人不会造数据。
代码(又臭又长的蒟蒻码风就不要吐槽了):

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#define debug cerr
typedef long long int lli;
using namespace std;
const int maxn=1e5+1e2,maxe=3e5+1e2,maxb=4e2+1e2;

int n,bs;

struct pii{int l,r;};
struct RotatelessTreap {
    int lson[maxn],rson[maxn],dat[maxn],mx[maxn],fix[maxn];
    lli pv[maxn];
    RotatelessTreap() {
        for(int i=0;i<maxn;i++) fix[i] = i;
        random_shuffle(fix,fix+maxn);
    }
    inline void maintain(int pos) {
        mx[pos] = max( dat[pos] , max(mx[lson[pos]],mx[rson[pos]]) );
    }
    inline pii split(int pos,lli nv) { // left is <= nv .
        if( !pos ) return (pii){0,0};
        if( pv[pos] > nv ) { // split pos to right .
            pii spl = split(lson[pos],nv);
            lson[pos] = spl.r , maintain(pos);
            return (pii){spl.l,pos};
        } else {
            pii spr = split(rson[pos],nv);
            rson[pos] = spr.l , maintain(pos);
            return (pii){pos,spr.r};
        }
    }
    inline int merge(int x,int y) {
        if( !x || !y ) return x | y;
        if( fix[x] > fix[y] ) {
            rson[x] = merge(rson[x],y) , maintain(x);
            return x;
        } else {
            lson[y] = merge(x,lson[y]) , maintain(y);
            return y;
        }
    }
    inline void reset(int pos,lli p,int d) {
        lson[pos] = rson[pos] = 0 , pv[pos] = p , dat[pos] = mx[pos] = d;
    }
    inline void insert_node(int &root,int t) {
        pii sp = split(root,pv[t]);
        root = merge(sp.l,merge(t,sp.r));
    }
    inline pii query_seg(int &root,lli ll,lli rr) { // return pair<(bool)siz,max> of segment (ll,rr] .
        pii spl = split(root,ll) , spr = split(spl.r,rr);
        pii ret = (pii){spr.l,mx[spr.l]};
        root = merge(spl.l,merge(spr.l,spr.r));
        return ret;
    }
}treap;

int iw[maxn],ib[maxn];
int bel[maxn],st[maxb],ed[maxb],lazy_w[maxb],lazy_b[maxb],root[maxb];

inline lli gid(int pos,int st,int iw) { // iw can't be zero .
    return (lli) iw * bs + pos - st;
}
inline void rebuild_blk(int id) {
    root[id] = 0;
    for(int i=st[id];i<=ed[id];i++) {
        treap.reset(i,gid(i,st[id],iw[i]),ib[i]) , treap.insert_node(root[id],i);
    }
}
inline void push_all(int id) {
    if( ~lazy_w[id] ) {
        for(int i=st[id];i<=ed[id];i++) iw[i] = lazy_w[id];
        lazy_w[id] = -1;
    }
    if( ~lazy_b[id] ) {
        for(int i=st[id];i<=ed[id];i++) ib[i] = lazy_b[id];
        lazy_b[id] = -1;
    }
}
inline void full_apply_w(int id,int w) {
    lazy_w[id] = w;
}
inline void full_apply_b(int id,int b) {
    lazy_b[id] = b;
}
inline int full_query(int id,int l,int r) {
    if( ~lazy_w[id] ) {
        if( ! ( l <= lazy_w[id] && lazy_w[id] <= r ) ) return 0;
        if( ~lazy_b[id] ) return lazy_b[id];
        return treap.mx[root[id]];
    } else {
        lli ll = (lli) bs * l - 1 , rr = (lli) bs * ( r + 1 ) - 1;
        pii t = treap.query_seg(root[id],ll,rr);
        if( ~lazy_b[id] ) return t.l ? lazy_b[id] : 0;
        else return t.r;
    }
}
inline void part_apply_w(int id,int w,int l,int r) {
    push_all(id) , l = max( l , st[id] ) , r = min( r , ed[id] );
    for(int i=l;i<=r;i++) iw[i] = w;
    rebuild_blk(id);
}
inline void part_apply_b(int id,int b,int l,int r) {
    push_all(id) , l = max( l , st[id] ) , r = min( r , ed[id] );
    for(int i=l;i<=r;i++) ib[i] = b;
    rebuild_blk(id);
}
inline int part_query(int id,int l,int r,int segl,int segr) {
    segl = max( segl , st[id] ) , segr = min( segr , ed[id] );
    if( ~lazy_w[id] ) {
        if( ! ( l <= lazy_w[id] && lazy_w[id] <= r ) ) return 0;
        if( ~lazy_b[id] ) return lazy_b[id];
        int ret = 0;
        for(int i=segl;i<=segr;i++) ret = max( ret , ib[i] );
        return ret;
    } else {
        if( ~lazy_b[id] ) {
            for(int i=segl;i<=segr;i++) if( l <= iw[i] && iw[i] <= r ) return lazy_b[id];
            return 0;
        } else {
            int ret = 0;
            for(int i=segl;i<=segr;i++) if( l <= iw[i] && iw[i] <= r ) ret = max( ret , ib[i] );
            return ret;
        }
    }
}
inline int query_seg(int l,int r,int ll,int rr) { // ll , rr is value segment .
    if( bel[l] == bel[r] ) return part_query(bel[l],ll,rr,l,r);
    else {
        int ret = max( part_query(bel[l],ll,rr,l,r) , part_query(bel[r],ll,rr,l,r) );
        for(int i=bel[l]+1;i<bel[r];i++) ret = max( ret , full_query(i,ll,rr) );
        return ret;
    }
}
inline void apply_seg_w(int l,int r,int w) {
    if( bel[l] == bel[r] ) return part_apply_w(bel[l],w,l,r);
    else {
        part_apply_w(bel[l],w,l,r) , part_apply_w(bel[r],w,l,r);
        for(int i=bel[l]+1;i<bel[r];i++) full_apply_w(i,w);
    }
}
inline void apply_seg_b(int l,int r,int b) {
    if( bel[l] == bel[r] ) return part_apply_b(bel[l],b,l,r);
    else {
        part_apply_b(bel[l],b,l,r) , part_apply_b(bel[r],b,l,r);
        for(int i=bel[l]+1;i<bel[r];i++) full_apply_b(i,b);
    }
}

int s[maxn],t[maxn<<1],nxt[maxn<<1];
int fa[maxn],siz[maxn],dep[maxn],son[maxn],top[maxn],dfn[maxn],rit[maxn];

inline void coredge(int from,int to) {
    static int cnt;
    t[++cnt] = to , nxt[cnt] = s[from] , s[from] = cnt;
}
inline void addedge(int a,int b) {
    coredge(a,b) , coredge(b,a);
}
inline void pre(int pos) {
    siz[pos] = 1;
    for(int at=s[pos];at;at=nxt[at]) if( t[at] != fa[pos] ) {
        dep[t[at]] = dep[pos] + 1 , fa[t[at]] = pos , 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 dd;
    dfn[pos] = ++dd , top[pos] = pos == son[fa[pos]] ? top[fa[pos]] : 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]);
    rit[pos] = dd;
}

inline void apply_subtree_w(int pos,int w) {
    apply_seg_w(dfn[pos],rit[pos],w);
}
inline void apply_subtree_b(int pos,int b) {
    apply_seg_b(dfn[pos],rit[pos],b);
}
inline int query_chain(int x,int y,int ll,int rr) {
    int ret = 0;
    while( top[x] != top[y] ) {
        if( dep[top[x]] < dep[top[y]] ) swap(x,y);
        ret = max( ret , query_seg(dfn[top[x]],dfn[x],ll,rr) ) , x = fa[top[x]];
    }
    ret = max( ret , query_seg(min(dfn[x],dfn[y]),max(dfn[x],dfn[y]),ll,rr) );
    return ret;
}

inline void initblk() {
    bs = sqrt(n);
    for(int l=1,r,cnt=0;l<=n;l=r+1) {
        r = min( l + bs - 1 , n ) , st[++cnt] = l , ed[cnt] = r , lazy_w[cnt] = lazy_b[cnt] = -1;
        for(int i=l;i<=r;i++) bel[i] = cnt;
        rebuild_blk(cnt);
    }
}

int srt[maxn<<2],len;
int o[maxn],ox[maxn],oy[maxn],oll[maxn],orr[maxn];

inline int gid(int x) {
    return lower_bound(srt+1,srt+1+len,x) - srt;
}

int main() {
    static int m;
    static char ooo[50];
    scanf("%d%d",&n,&m);
    for(int i=1,a,b;i<n;i++) scanf("%d%d",&a,&b) , addedge(a,b);
    for(int i=1;i<=m;i++) {
        scanf("%s%d%d",ooo+1,ox+i,oy+i);
        if( ooo[1] == 'C' ) {
            if( ooo[7] == 'W' ) o[i] = 1 , srt[++len] = oy[i];
            else o[i] = 2;
        } else o[i] = 3 , scanf("%d%d",oll+i,orr+i) , srt[++len] = oll[i] , srt[++len] = orr[i]; 
    }
    sort(srt+1,srt+1+len) , len = unique(srt+1,srt+1+len) - srt - 1;
    for(int i=1;i<=m;i++) {
        if( o[i] == 1 ) oy[i] = gid(oy[i]);
        else if( o[i] == 3 ) oll[i] = gid(oll[i]) , orr[i] = gid(orr[i]);
    }
    pre(1) , dfs(1) , initblk();
    for(int i=1;i<=m;i++) {
        if( o[i] == 1 ) apply_subtree_w(ox[i],oy[i]);
        else if( o[i] == 2 ) apply_subtree_b(ox[i],oy[i]);
        else printf("%d
",query_chain(ox[i],oy[i],oll[i],orr[i]));
    }
    return 0;
}

T3:

这题我想了一个针对60分错误算法，爆零了......(另外这个题的前20%数据是不满足60%限制的，也就是说60%限制根本不够，辣鸡出题人不会造数据X2)
大概就是这样，f[i][x][y][s]表示i步在坐标(x,y)，状态为s的最小值(显然i最大是nm)，转移的话枚举怎么走，用队列存储状态加剪枝在随机数据下快到飞起。
看起来很有道理的样子，然而它是WA的，因为这样只能DP出一条简单路径的方案，但是最优方案可能不是一条路径(比如一个T形)。
正解是这样的:

我太菜了连斯坦纳树都看不出来了......
(话说我那个算法如果对的话斯坦纳树还有何用，心里就没点**吗)
随机化的话，随机数种子用老婆的名字，跑150次加上最优性剪枝，在Ofast加持下能卡进1.5s，踩爆std。
考场爆零代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#define debug cout
using namespace std;
const int maxn=25,maxs=1<<9;
const int inf=0x3f3f3f3f;
const int dx[]={1,-1,0,0},dy[]={0,0,1,-1};

int bin[maxs];
struct Node {int x,y,s;};
int a[maxn][maxn],b[maxn][maxn];
int f[2][maxn][maxn][maxs];
bool inq[2][maxn][maxn][maxs];
queue<Node> q[2];
int n,m,k,cur,ans;

inline void update(int &dst,const int &x) {
    dst = min( dst , x );
}
inline void trans() { // it works well under random input data .
    #define legal(x,y) (0<=x&&x<n&&0<=y&&y<m)
    while( q[cur^1].size() ) {
        const int x = q[cur^1].front().x , y = q[cur^1].front().y , s = q[cur^1].front().s; q[cur^1].pop();
        for(int i=0;i<4;i++) {
            const int tx = x + dx[i] , ty = y + dy[i];
            if( legal(tx,ty) && ~a[tx][ty]) {
                const int ts = s | ( 1 << a[tx][ty] ) , tf = f[cur^1][x][y][s] + b[tx][ty];
                if( bin[ts] >= k ) update(ans,tf);
                if( tf < ans ) {
                    update(f[cur][tx][ty][ts],tf);
                    if( !inq[cur][tx][ty][ts] ) q[cur].push((Node){tx,ty,ts}) , inq[cur][tx][ty][ts] = 1;
                }
            }
        }
        f[cur^1][x][y][s] = inf , inq[cur^1][x][y][s] = 0;
    }
    #undef legal
}

int main() {
    static int T;
    scanf("%d",&T) , memset(f,0x3f,sizeof(f));
    for(int i=1;i<maxs;i++) bin[i] = bin[i>>1] + ( i & 1 );
    while(T--) {
        scanf("%d%d%d",&n,&m,&k) , cur = 0 , ans = inf;
        if( !k ) { puts("0"); continue; }
        for(int i=0;i<n;i++) for(int j=0;j<m;j++) scanf("%d",a[i]+j);
        for(int i=0;i<n;i++) for(int j=0;j<m;j++) scanf("%d",b[i]+j);
        for(int i=0;i<n;i++) for(int j=0;j<m;j++) if( ~a[i][j] ) {
            f[cur][i][j][1<<a[i][j]] = b[i][j];
            if( !inq[cur][i][j][1<<a[i][j]] ) q[cur].push((Node){i,j,1<<a[i][j]});
        }
        for(int i=2;i<=n*m;i++) cur ^= 1 , trans();
        printf("%d
",ans==inf?-1:ans);
    }
    return 0;
}

正解代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#define debug cout
using namespace std;
const int maxn=26,maxs=1<<5;
const int inf=0x3f3f3f3f;
const int dx[]={1,-1,0,0},dy[]={0,0,1,-1};

struct Node{int x,y;};
int a[maxn][maxn],b[maxn][maxn],fakea[maxn][maxn];
int f[maxs][maxn][maxn];
int n,m,k,fs,ans;

inline void spfa(int dis[maxn][maxn]) {
    static bool inq[maxn][maxn];
    queue<Node> q;
    #define legal(x,y) (0<x&&x<=n&&0<y&&y<=m)
    for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) if( dis[i][j] < ans ) q.push((Node){i,j});
    while( q.size() ) {
        const int x = q.front().x , y = q.front().y; q.pop() , inq[x][y] = 0;
        for(int i=0;i<4;i++) {
            const int tx = x + dx[i] , ty = y + dy[i];
            if( legal(tx,ty) && ~fakea[tx][ty]  && dis[tx][ty] > dis[x][y] + b[tx][ty] ) {
                dis[tx][ty] = dis[x][y] + b[tx][ty];
                if( dis[tx][ty] >= ans ) { dis[tx][ty] = inf; continue; }
                if( !inq[tx][ty] ) q.push((Node){tx,ty});
            }
        }
    }
}
inline int solve() {
    int ret = inf;
    memset(f,0x3f,sizeof(f)) , fs = 1 << k;
    for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) if( ~fakea[i][j] ) f[1<<fakea[i][j]][i][j] = b[i][j];
    for(int i=0;i<fs;i++) {
        for(int j=i;j;j=(j-1)&i) for(int x=1;x<=n;x++) for(int y=1;y<=m;y++) if( ~fakea[i][j] )
            f[i][x][y] = min( f[i][x][y] , f[j][x][y] + f[i^j][x][y] - b[x][y] );
        spfa(f[i]);
    }
    for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) ret = min( ret , f[fs-1][i][j] );
    return ret;
}
inline void gen() {
    static int ls[maxn*maxn];
    for(int i=0;i<=n*m;i++) ls[i] = rand() % k;
    for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) fakea[i][j] = (~a[i][j]) ? ls[a[i][j]] : -1;
}
inline void getans() {
    for(int i=1;i<=150;i++) gen() , ans = min( ans , solve() );
}

inline void init() {
    static const char seed[] = "KurenaiKisaragi";
    int su = 0 , li = strlen(seed);
    for(int i=0;i<li;i++) su += seed[i];
    srand(su);
}

int main() {
    static int T;
    scanf("%d",&T) , init();
    while(T--) {
        scanf("%d%d%d",&n,&m,&k) , ans = inf;
        for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) scanf("%d",a[i]+j);
        for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) scanf("%d",b[i]+j);
        getans() , printf("%d
",ans==inf?-1:ans);
    }
    return 0;
}

这次又不是rank1了(还不是因为T3爆零)，果然我还是太菜了啊。
这次之前的话，已经不知道多长时间没有在考场上WA题了呢......

I am waiting for you And looking for truth But not a sound is heard
我在等着 ，寻找着真相 但却听不到声音
Whenever you need any help and my voice Lease let me know
无论何时 只要你需要任何帮助和我的声音 请让我知道
Can I sing for you or cry for dream ?
我可以为你歌唱或者呼唤梦想么
Let the wind blow
让风吹吧
So I can see the sky
这样我就能看到天空