考场

第一次在 hz 考试。害怕会困，但其实还好

看完题感觉不太难，估计有人 AK。

T3 比较套路，没办法枚举黑点就从 LCA 处考虑，在一个点变成黑点时计算其他点和它的 LCA 的贡献，暴力跳父亲，显然每对 \((fa,son)\) 只有对答案的影响是相同的，即每对只需要处理一次，均摊 \(O(\log n)\)，线段树在 dfs 序维护答案，区间取 \(\max\)、单点查询。

T1 T2 没啥想法，就先把 T3 码了，除了数组越界+变量打反外 顺利过大样例，拍上就丢了

T1 尝试推式子直接算答案，但又有平方项又有 \(\mod\) 很烦，那就打表找规律吧。发现有循环节，那就把首尾不是循环节的部分和一段循环节拎出来暴力 LIS，中间每个循环节显然会让答案 \(+1\)。过不了拍，膜了几组 WA 掉的数据发现两个循环节中对应数的 LIS 不一定只 \(+1\)，调了调参发现拎出来循环节长度个循环节就行了，大概 9.20 过拍

时间不多了，T2 就没咋想正解。尝试反转费用和价值（DP 数组是 bool 类型怎么转啊）无果就暴力背包了。\(n=2\) 时可以扩欧，但不会求非正整数解的情况，弃了。最后 20min 无所事事

res

rk1 100+30+100

没有挂分，好耶

ycx rk2 100+30+60

ys rk3 20+90+80

最长不下降子序列

一些证明：

发现 \(a_i\) 会确定地产生 \(a_{i+1}\) ，那么在产生至多 \(D\) 个数后会出现循环节，且循环节长度不超过 \(D\)

如果循环节中有逆序对，那么答案就不止加一（后一个循环节中的大数能接在前一个的较小数中），最坏情况就是循环节是降序的，因此需要循环节长度个循环节

考场代码

const int N = 1e7+5;
int A,B,C,D;
LL n;

int pre,len,suf,m,a[N],pos[200];
LL ans;

struct BIT {
    int t[200];
    void add(int i,int x) { for(++i;i<=D;i+=i&-i)t[i]=max(t[i],x); }
    int query(int i) { int res=0; for(++i;i;i-=i&-i)res=max(res,t[i]); return res; }
} bit;

signed main() {
    // freopen("a.in","r",stdin);
    // freopen("a.out","w",stdout);
    read(n,a[1],A,B,C,D);
    pos[a[ pre=1 ]] = 1;
    for(pre = 2; ; ++pre) {
        a[pre] = (A*a[pre-1]*a[pre-1] + B*a[pre-1] + C) %D;
        if( pos[a[pre]] ) { len = pre-pos[a[pre]], pre -= len+1; break; }
        pos[a[pre]] = pre;
    }
    suf = (n-pre)%len, m = min((LL)pre+len*len+suf,n);
    For(i,pre+len,m) a[i] = (A*a[i-1]*a[i-1] + B*a[i-1] + C) %D;
    For(i,1,m) {
        int f = bit.query(a[i]) + 1;
        bit.add(a[i],f);
        if( i <= m-len ) ans = max(ans,(LL)f);
        else ans = max(ans,f+(n-m)/len);
    }
    write(ans);
    return iocl();
} 

完全背包问题

一个比较好的做法是 分层图同余最短路

一个比较 naive 的做法是 DP。

solution 写的蛮清楚的，但代码不好写，自己口胡了 1.5h

DP

const int N = 55;
int n,m,v[N],l,c;

const LL inf = 0x3f3f3f3f3f3f3f3f;
int v0;
LL f[N][35][10000];
bool vis[10000];

int add(int x,int y) { return ((x+y)%v0+v0)%v0; }
void ckmin(LL &x,LL y) { if( y < x ) x = y; }

namespace sub {
bitset<300001> f[55][35];
void main() {
    if( v0 < l ) return;
    f[0][0][0] = 1;
    For(i,1,n) For(j,1,c) f[i][j] = f[i-1][j] | (f[i][j-1]<<v[i]);
    while( m-- ) {
        LL w; read(w);
        if( w > 3e5 ) puts("No");
        else puts(f[n][c][w] ? "Yes" : "No");
    }
    exit(0);
}
}

signed main() {
    read(n,m);
    For(i,1,n) read(v[i]);
    read(l,c);
    v0 = *min_element(v+1,v+n+1);
    sub::main();
    memset(f,0x3f,sizeof f);
    f[0][0][0] = 0;
    For(i,1,n) {
        if( v[i] >= l ) {
            for(int k = 0; k < v0; ++k) f[i][0][k] = f[i-1][0][k];
            For(j,1,c) for(int k = 0; k < v0; ++k)
                ckmin(f[i][j][k] , min(f[i-1][j][k],f[i][j-1][add(k,-v[i])]+v[i]));
        } else For(j,0,c) {
            memset(vis,0,sizeof vis);
            for(int l = 0; l < v0; ++l) if( !vis[l] ) { // 找环
                int p = l;
                for(int k = add(l,v[i]); k != l; k = add(k,v[i])) // 找环内开始的点
                    if( f[i-1][j][k] < f[i-1][j][p] )
                        p = k;
                f[i][j][p] = f[i-1][j][p], vis[p] = 1;
                for(int k = add(p,v[i]); k != p; k = add(k,v[i]))
                    f[i][j][k] = min(f[i-1][j][k],f[i][j][add(k,-v[i])]+v[i]),
                    vis[k] = 1;
            }
        }
        For(j,0,c) for(int k = 0; k < v0; ++k) {
            ckmin(f[i][j][k],f[i-1][j][k]);
            if( j ) ckmin(f[i][j][k],f[i][j-1][k]);
        }
    }
    while( m-- ) {
        LL w; read(w);
        puts(f[n][c][w%v0]<=w ? "Yes" : "No");
    }
    return 0;
} 

最近公共祖先

线段树维护子树

考场代码

char readc() {
    char c=getchar();
    while(!isalpha(c))c=getchar();
    return c;
}
void ckmax(int &x,int y) { if( y > x ) x = y; }

const int N = 1e5+5;
int n,m,val[N];
vector<int> to[N];

int ind,fa[N],siz[N],dfn[N],which[N];
vector<bool> vis[N];

void dfs(int u,int fa) {
    ::fa[u] = fa, siz[u] = 1, dfn[u] = ++ind;
    vis[u].assign(to[u].size()+1,0);
    int son = 0;
    for(int v : to[u]) if( v != fa ) which[v] = ++son, dfs(v,u), siz[u] += siz[v];
}

namespace seg {
#define ls (u<<1)
#define rs (u<<1|1)
struct Node { int l,r,mx; } t[N*4];
void down(int u,int x) { ckmax(t[u].mx,x); }
void down(int u) {
    down(ls,t[u].mx), down(rs,t[u].mx);
    t[u].mx = -1;
}
void build(int u,int l,int r) {
    t[u] = Node{l,r,-1};
    if( l == r ) return;
    int mid = l+r>>1;
    build(ls,l,mid), build(rs,mid+1,r);
}
void modify(int u,int l,int r,int x) {
    if( l > r ) return;
    if( l <= t[u].l && t[u].r <= r ) { down(u,x); return; }
    down(u);
    if( l <= t[ls].r ) modify(ls,l,r,x);
    if( t[rs].l <= r ) modify(rs,l,r,x);
}
int query(int u,int p) {
    if( t[u].l == t[u].r ) return t[u].mx;
    down(u);
    return query( p<=t[ls].r?ls:rs ,p);
}
}

signed main() {
    // freopen("c.in","r",stdin);
    // freopen("c.out","w",stdout);
    read(n,m);
    For(i,1,n) read(val[i]);
    for(int i = 1; i < n; ++i) {
        int x,y; read(x,y);
        to[x].pb(y), to[y].pb(x);
    }
    dfs(1,0), seg::build(1,1,n);
    while( m-- ) {
        char op = readc(); int x; read(x);
//        assert(dfn[x]<=n);
        if( op == 'M' ) {
            seg::modify(1,dfn[x],dfn[x]+siz[x]-1,val[x]);
            for(int y = fa[x]; y && !vis[y][which[x]]; x = y, y = fa[y])
//                printf("@ %d %d\n",y,x),
                seg::modify(1,dfn[y],dfn[x]-1,val[y]),
                seg::modify(1,dfn[x]+siz[x],dfn[y]+siz[y]-1,val[y]),
                vis[y][which[x]] = 1;
        } else write(seg::query(1,dfn[x]));
    }
    return iocl();
} 

关于数据

极水，T2 T3 过不了样例都能拿 90pts，T2 不分层能拿 80pts，根本没有卡最短路，跑的比 DP 快多了