2. 程式人生 > >「PKUWC2018/PKUSC2018」試題選做

「PKUWC2018/PKUSC2018」試題選做

阿新 • • 發佈：2019-05-07
str 合數 ever get 轉移 std else if 多維 線段樹合並

「PKUWC2018/PKUSC2018」試題選做

最近還沒想好報THUSC還是PKUSC，THU發我的三類約（再來一瓶）不知道要不要用，甚至不知道營還辦不辦，協議還有沒有用。所以這些事情就暫時先不管了，PKU的題還是不錯的，就刷一刷劃水。因為比較簡單，所以就不單獨寫博客了。

loj2537 Minimax

數據結構題，兩個 \(\log\) 直接啟發式合並，一個 \(\log\) 需要轉移的時候多維護一些東西。

對於每個節點維護一下選擇其子樹裏每個葉子的權值的概率，線段樹合並轉移即可。


code

/*program by mangoyang*/
#include <bits/stdc++.h>
#define inf (0x7f7f7f7f)
#define Max(a, b) ((a) > (b) ? (a) : (b))
#define Min(a, b) ((a) < (b) ? (a) : (b))
typedef long long ll;
using namespace std;
template <class T>
inline void read(T &x){
    int ch = 0, f = 0; x = 0;
    for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = 1;
    for(; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
    if(f) x = -x;
}
const int M = 1e9, N = 300005, mod = 998244353;
int a[N], rt[N], P, n, ans;
vector<int> g[N];
vector<pair<int, int> > Ans;
namespace Seg{
    #define mid ((l + r) >> 1)
    int s[N*30], tag[N*30], lc[N*30], rc[N*30], size;
    inline void init(){ for(int i = 1; i < N * 30; i++) tag[i] = 1; }
    inline void pushdown(int u){
        if(tag[u] == 1) return;
        if(lc[u]){
            s[lc[u]] = 1ll * tag[u] * s[lc[u]] % mod;
            tag[lc[u]] = 1ll * tag[lc[u]] * tag[u] % mod;
        }
        if(rc[u]){
            s[rc[u]] = 1ll * tag[u] * s[rc[u]] % mod;
            tag[rc[u]] = 1ll * tag[rc[u]] * tag[u] % mod;
        }
        tag[u] = 1;
    }
    inline void insert(int &u, int l, int r, int pos){
        if(!u) u = ++size;
        if(l == r) return (void) (s[u] = 1);
        if(pos <= mid) insert(lc[u], l, mid, pos);
        else insert(rc[u], mid + 1, r, pos);
        s[u] = s[lc[u]] + s[rc[u]];
    }
    inline int merge(int x, int y, int sumx, int sumy){
        if(!x){ 
            if(!sumx) return y;
            s[y] = 1ll * s[y] * sumx % mod;
            tag[y] = 1ll * tag[y] * sumx % mod;
            return y;
        }
        if(!y){
            if(!sumy) return x;
            s[x] = 1ll * s[x] * sumy % mod;
            tag[x] = 1ll * tag[x] * sumy % mod; 
            return x;
        }
        pushdown(x), pushdown(y);
        int o = ++size;
        int Lx = (sumx + 1ll * P * s[lc[x]] % mod) % mod;
        int Ly = (sumy + 1ll * P * s[lc[y]] % mod) % mod;
        int Rx = (sumx + 1ll * (mod + 1 - P) * s[rc[x]] % mod) % mod;
        int Ry = (sumy + 1ll * (mod + 1 - P) * s[rc[y]] % mod) % mod;
        lc[o] = merge(lc[x], lc[y], Rx, Ry);
        rc[o] = merge(rc[x], rc[y], Lx, Ly);
        s[o] = (s[lc[o]] + s[rc[o]]) % mod;
        return o;
    }
    inline void getans(int u, int l, int r){
        if(l == r) return (void) Ans.push_back(make_pair(l, s[u]));
        pushdown(u);
        if(lc[u]) getans(lc[u], l, mid);
        if(rc[u]) getans(rc[u], mid + 1, r);
    }
}
inline int Pow(int a, int b){
    int ans = 1;
    for(; b; b >>= 1, a = 1ll * a * a % mod)
        if(b & 1) ans = 1ll * ans * a % mod;
    return ans;
}
inline void dfs(int u){
    if(!(int) g[u].size()) Seg::insert(rt[u], 1, M, a[u]);
    for(int i = 0; i < (int) g[u].size(); i++){
        dfs(g[u][i]);
        P = a[u];
        rt[u] = Seg::merge(rt[u], rt[g[u][i]], 0, 0);
    }
}
int main(){
    read(n);
    for(int i = 1, x; i <= n; i++) read(x), g[x].push_back(i);
    for(int i = 1; i <= n; i++){
        read(a[i]);
        if((int) g[i].size()) a[i] = 1ll * a[i] * Pow(10000, mod1- 2) % mod;
    }
    Seg::init();
    dfs(1), Seg::getans(rt[1], 1, M), sort(Ans.begin(), Ans.end());
    for(int i = 0; i < (int) Ans.size(); i++){
        (ans += 1ll * (i + 1) * Ans[i].first % mod * Ans[i].second % mod * Ans[i].second % mod) %= mod;
    }
    cout << ans << endl;
    return 0;
}


loj2538 Slay the Spire

一個顯然的貪心策略是從大到小盡可能打出強化牌（至多 \(k-1\) 張），然後從大到小盡可能打出攻擊牌。

可以分別對兩種牌排序然後按照這個策略設計 dp。

\(f[i][j]\) 表示前 \(i\) 張強化牌摸了 \(j\) 張的期望加成，從大到小對強化牌排序，枚舉當前這張牌是否被摸到來轉移。

\(g[i][j]\) 表示前 \(i\) 張攻擊牌摸了 \(j\) 張的期望攻擊力之和，\(j\) 越大可以打的攻擊牌越多，所以從小到大排序來轉移。


code

/*program by mangoyang*/
#include <bits/stdc++.h>
#define inf (0x7f7f7f7f)
#define Max(a, b) ((a) > (b) ? (a) : (b))
#define Min(a, b) ((a) < (b) ? (a) : (b))
typedef long long ll;
using namespace std;
template <class T>
inline void read(T &x){
    int ch = 0, f = 0; x = 0;
    for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = 1;
    for(; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
    if(f) x = -x;
}
const int N = 3005, mod = 998244353;
int a[N], b[N], js[N], inv[N], f[2][N], g[2][N], n, m, k;
inline void up(int &x, int y){
    x = (x + y >= mod ? x + y - mod : x + y);
}
inline int Pow(int a, int b){
    int ans = 1;
    for(; b; b >>= 1, a = 1ll * a * a % mod)
        if(b & 1) ans = 1ll * ans * a % mod;
    return ans;
}
inline int C(int x, int y){
    return 1ll * js[x] * inv[y] % mod * inv[x-y] % mod;
}
inline void solve(){
    read(n), read(m), read(k);
    for(int i = 1; i <= n; i++) read(a[i]);
    for(int i = 1; i <= n; i++) read(b[i]);
    sort(a + 1, a + n + 1, greater<int>());
    sort(b + 1, b + n + 1);
    for(int i = 0; i <= n; i++) 
        f[0][i] = f[1][i] = g[0][i] = g[1][i] = 0;
    f[0][0] = 1;
    for(int i = 1, o = 1; i <= n; i++, o ^= 1){
        for(int j = 0; j <= i; j++){
            f[o][j] = f[o^1][j];
            if(j && j < k) up(f[o][j], 1ll * a[i] * f[o^1][j-1] % mod);
            else if(j) up(f[o][j], f[o^1][j-1]);
        }
    }
    for(int i = 1, o = 1; i <= n; i++, o ^= 1){
        for(int j = 0; j <= i; j++){
            g[o][j] = g[o^1][j];
            if(j){
                if(m - j < k - 1) up(g[o][j], g[o^1][j-1]);
                up(g[o][j], 1ll * C(i - 1, j - 1) * b[i] % mod);
            }
        }
    }
    int ans = 0;
    for(int i = 0; i <= min(m, n); i++) 
        if(m - i <= n) up(ans, 1ll * f[n&1][i] * g[n&1][m-i] % mod);
    printf("%d\n", ans);
}
int main(){
    js[0] = inv[0] = 1;
    for(int i = 1; i < N; i++) 
        js[i] = 1ll * js[i-1] * i % mod, inv[i] = Pow(js[i], mod - 2);
    int T; read(T); while(T--) solve();
    return 0;
}


loj2540 隨機算法

直接狀壓 \(dp\) 是 \(O(3^nn)\) 的，實際上選了會沖突的點與已經選了的點顯然可以看做同一類點，然後就 \(O(2^nn)\) 了。


code

/*program by mangoyang*/ 
#include<bits/stdc++.h>
#define inf (0x7f7f7f7f)
#define Max(a, b) ((a) > (b) ? (a) : (b))
#define Min(a, b) ((a) < (b) ? (a) : (b))
typedef long long ll;
using namespace std;
template <class T>
inline void read(T &x){
    int ch = 0, f = 0; x = 0;
    for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = 1;
    for(; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
    if(f) x = -x;
}
const int mod = 998244353;
int cnt[1<<21], dp[1<<21][21], js[21], inv[21], ed[21], n, m;
inline int Pow(int a, int b){
    int ans = 1;
    for(; b; b >>= 1, a = 1ll * a * a % mod)
        if(b & 1) ans = 1ll * ans * a % mod;
    return ans;
}
inline int A(int x, int y){
    return 1ll * js[x] * inv[x-y] % mod;
}
inline void up(int &x, int y){
    x = (x + y >= mod ? x + y - mod : x + y);
}
int main(){
    read(n), read(m);
    js[0] = inv[0] = 1;
    for(int i = 1; i <= n; i++){
        js[i] = 1ll * js[i-1] * i % mod;
        inv[i] = Pow(js[i], mod - 2);
    }
    for(int i = 1, x, y; i <= m; i++){
        read(x), read(y);
        ed[x] |= 1 << (y - 1);
        ed[y] |= 1 << (x - 1);
    }
    for(int s = 0; s < (1 << n); s++)
        for(int i = 0; i < n; i++) 
            if((1 << i) & s) cnt[s]++;
    dp[0][0] = 1;
    for(int s = 0; s < (1 << n) - 1; s++)
        for(int i = 0; i < n; i++) if(dp[s][i]){ 
            for(int j = 0; j < n; j++) if(!((1 << j) & s)){
                int t = s | (1 << j) | ed[j+1];
                up(dp[t][i+1], 1ll * dp[s][i] * A(n - cnt[s] - 1, cnt[s^t] - 1) % mod);
            }
        }
    int mx = 0;
    for(int i = 1; i <= n; i++) if(dp[(1<<n)-1][i]) mx = i;
    cout << 1ll * dp[(1<<n)-1][mx] * inv[n] % mod << endl;
    return 0;
}


loj2542 隨機遊走

設 \(dp[x][s]\) 為從 \(x\) 出發走到點集 \(s\) 中任意一個點的期望步數，然後 \(\min-\max\) 容斥即可 ，直接分層圖+高斯消元跑不過去，可以用小套路把未知數設出來以後每個點都可以用其父親的答案乘上一個系數再加上一個常數來表示，然後跑一遍樹形dp就做完了。

code

/*program by mangoyang*/
#include<bits/stdc++.h>
#define inf (0x7f7f7f7f)
#define Max(a, b) ((a) > (b) ? (a) : (b))
#define Min(a, b) ((a) < (b) ? (a) : (b))
typedef long long ll;
using namespace std;
template <class T>
inline void read(T &x){
    int ch = 0, f = 0; x = 0;
    for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = 1;
    for(; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
    if(f) x = -x;
}
const int N = 1 << 21, mod = 998244353;
vector<int> g[N];
int mn[N], cnt[N], in[N], A[N], B[N], n, q, rt;
inline int Pow(int a, int b){
    int ans = 1;
    for(; b; b >>= 1, a = 1ll * a * a % mod)
        if(b & 1) ans = 1ll * ans * a % mod;
    return ans;
}
inline void dfs(int u, int fa){
    if(in[u]) return (void) (A[u] = B[u] = 0);
    int SA = 0, SB = 0, deg = (int) g[u].size();
    for(int i = 0; i < (int) g[u].size(); i++){
        int v = g[u][i];
        if(v == fa) continue;
        dfs(v, u);
        SA = (SA + A[v]) % mod, SB = (SB + B[v]) % mod;     
    }
    deg = Pow(deg, mod - 2);
    int x = (1 - 1ll * SA * deg % mod + mod) % mod;
    x = Pow(x, mod - 2);
    A[u] = 1ll * deg * x % mod;
    B[u] = 1ll * x * (1ll * SB * deg % mod + 1) % mod;
}
int main(){
    read(n), read(q), read(rt);
    for(int i = 1, x, y; i < n; i++){
        read(x), read(y);
        g[x].push_back(y), g[y].push_back(x);
    }
    for(int s = 0; s < (1 << n); s++){
        for(int i = 1; i <= n; i++){ 
            in[i] = ((1 << (i - 1)) & s) ? 1 : 0;
            cnt[s] += in[i];
        }
        dfs(rt, 0), mn[s] = B[rt];
    }
    while(q--){
        int num, sta = 0;
        read(num);
        for(int i = 1, x; i <= num; i++) read(x), sta |= 1 << (x - 1); 
        int ans = 0;
        for(int s = sta; s; s = (s - 1) & sta)
            (ans += 1ll * ((cnt[s] & 1) ? 1 : mod - 1) * mn[s] % mod) %= mod;
        printf("%d\n", ans);
    }
    return 0;
}


loj6432 真實排名

對於每個點枚舉一下要不要，統計一下會影響的人數，組合數算一下就好了


code

/*program by mangoyang*/
#include <bits/stdc++.h>
#define inf (0x7f7f7f7f)
#define Max(a, b) ((a) > (b) ? (a) : (b))
#define Min(a, b) ((a) < (b) ? (a) : (b))
typedef long long ll;
using namespace std;
template <class T>
inline void read(T &x){
    int ch = 0, f = 0; x = 0;
    for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = 1;
    for(; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
    if(f) x = -x;
}
#define fi first
#define se second
const int N = 1000005, mod = 998244353;
pair<int, int> a[N];
int js[N], inv[N], ans[N], n, k;
inline int Pow(int a, int b){
    int ans = 1;
    for(; b; b >>= 1, a = 1ll * a * a % mod)
        if(b & 1) ans = 1ll * ans * a % mod;
    return ans;
}   
inline int C(int x, int y){
    if(x < y || x < 0 || y < 0) return 0;
    return 1ll * js[x] * inv[y] % mod * inv[x-y] % mod;
}
int main(){
    read(n), read(k);
    js[0] = inv[0] = 1;
    for(int i = 1; i <= n; i++){
        js[i] = 1ll * js[i-1] * i % mod; 
        inv[i] = Pow(js[i], mod - 2);
        read(a[i].fi), a[i].se = i;
    }
    sort(a + 1, a + n + 1);
    int p = 0, q = 0;
    for(int i = 1; i <= n; i++){
        if(a[i].fi == a[i-1].fi && i > 1){
            ans[a[i].se] = ans[a[i-1].se];
            continue;
        }
        while(a[p+1].fi * 2 < a[i].fi && p < n) p++;
        while(a[q+1].fi < a[i].fi * 2 && q < n) q++;
        int tot1 = i - p - 1, tot2 = max(q, i) - i + 1;
        (ans[a[i].se] += C(n - tot1 - 1, k)) %= mod;
        (ans[a[i].se] += C(n - tot2, k - tot2)) %= mod;
    }
    for(int i = 1; i <= n; i++) printf("%d\n", ans[i]);
    return 0;
}


loj6433 最大前綴和

考慮每一個集合成為最大前綴和的方案數，這個等於其內部排列滿足全部選是最大前綴和乘上剩余元素無論怎麽排都不存在一個前綴和 \(>0\) 的方案數，兩部分分開來狀壓 \(dp\) 即可。


code

/*program by mangoyang*/
#include <bits/stdc++.h>
#define inf (0x7f7f7f7f)
#define Max(a, b) ((a) > (b) ? (a) : (b))
#define Min(a, b) ((a) < (b) ? (a) : (b))
typedef long long ll;
using namespace std;
template <class T>
inline void read(T &x){
    int ch = 0, f = 0; x = 0;
    for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = 1;
    for(; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
    if(f) x = -x;
}
const int N = (1 << 20), mod = 998244353;
int a[N], f[N], sum[N], g[N], n;
inline void up(int &x, int y){ 
    x = x + y >= mod ? x + y - mod : x + y;
}
int main(){
    read(n);
    for(int i = 1; i <= n; i++) read(a[i]);
    for(int s = 1; s < (1 << n); s++)
        for(int i = 0; i < n; i++) 
            if((1 << i) & s) sum[s] += a[i+1];
    g[0] = 1;
    for(int i = 0; i < n; i++) f[1<<i] = 1;
    for(int s = 0; s < (1 << n); s++)
        for(int i = 0; i < n; i++) if(!((1 << i) & s)){
            int t = s ^ (1 << i);
            if(sum[s] > 0) up(f[t], f[s]); 
            if(sum[t] <= 0) up(g[t], g[s]);
        }
    int ans = 0;
    for(int s = 0; s < (1 << n); s++){
        sum[s] = (sum[s] % mod + mod) % mod;
        up(ans, 1ll * sum[s] * f[s] % mod * g[((1<<n)-1)^s] % mod);
    }
    cout << ans << endl;
    return 0;
}


loj6436 星際穿越

可以發現每個點出發最多會向右走一步，於是倍增出每個點走 \(2^j\) 步能走到的最左端點，已經走到這之間所有點的距離和，每次詢問拆成兩個以 \(x\) 結尾的後綴來詢問即可。


code

/*program by mangoyang*/
#include <bits/stdc++.h>
#define inf (0x7f7f7f7f)
#define Max(a, b) ((a) > (b) ? (a) : (b))
#define Min(a, b) ((a) < (b) ? (a) : (b))
typedef long long ll;
using namespace std;
template <class T>
inline void read(T &x){
    int ch = 0, f = 0; x = 0;
    for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = 1;
    for(; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
    if(f) x = -x;
}
const int N = 300005;
ll a[N], f[N][21], s[N][21];
int n, q;
inline ll calc(int x, int L){
    if(a[x] <= L) return x - L;
    ll ans = x - a[x], now = 1; x = a[x];
    for(int i = 20; ~i; i--) if(f[x][i] >= L){
        ans += s[x][i] + (x - f[x][i]) * now;
        now += 1 << i, x = f[x][i];
    }
    return ans + (x - L) * (now + 1);
}
int main(){
    read(n), a[1] = 1;
    for(int i = 2; i <= n; i++) read(a[i]);
    for(int i = n; i >= 1; i--){
        f[i][0] = min(a[i], i == n ? inf : f[i+1][0]);
        s[i][0] = i - f[i][0];
    }
    for(int j = 1; j <= 20; j++)
        for(int i = 1; i <= n; i++){
            f[i][j] = f[f[i][j-1]][j-1];
            s[i][j] = s[i][j-1] + s[f[i][j-1]][j-1];
            s[i][j] += (f[i][j-1] - f[f[i][j-1]][j-1]) << (j - 1);
        }
    read(q);
    for(int i = 1, l, r, x; i <= q; i++){
        read(l), read(r), read(x);
        ll ans = calc(x, l) - calc(x, r + 1);
        ll g = __gcd(ans, (ll) r - l + 1);
        printf("%lld/%lld\n", ans / g, (r - l + 1) / g);
    }
    return 0;
}


loj6436 神仙的遊戲

border有關的計數題可以從等差數列和周期兩個角度考慮，這個題顯然不能等差數列於是就直接上周期定理。

套用周期定理得到如果 \(i\) 是一個 border，那麽所有模 \(|S|-i\) 同余的位置必須相同，也就是不能出現兩個距離為 \(|S|-i-1\) 的 \(0,1\) 位置，直接用 FTT 統計所有差的信息即可。


code

/*program by mangoyang*/
#include <bits/stdc++.h>
#define inf (0x7f7f7f7f)
#define Max(a, b) ((a) > (b) ? (a) : (b))
#define Min(a, b) ((a) < (b) ? (a) : (b))
typedef long long ll;
using namespace std;
template <class T>
inline void read(T &x){
    int ch = 0, f = 0; x = 0;
    for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = 1;
    for(; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
    if(f) x = -x;
}
const int N = (1 << 22), P = 998244353, G = 3;
char s[N];
int a[N], b[N];
namespace poly{
    int rev[N], lg, len;
    inline int Pow(int a, int b){
        int ans = 1;
        for(; b; b >>= 1, a = 1ll * a * a % P)
            if(b & 1) ans = 1ll * ans * a % P;
        return ans;
    }
    inline void timesinit(int lenth){
        for(len = 1, lg = 0; len <= lenth; len <<= 1, lg++);
        for(int i = 0; i < len; i++)
            rev[i] = (rev[i>>1] >> 1) | ((i & 1) << (lg - 1));
    }
    inline void dft(int *a, int sgn){
        for(int i = 0; i < len; i++)
            if(i < rev[i]) swap(a[i], a[rev[i]]);
        for(int k = 2; k <= len; k <<= 1){
            int w = Pow(G, (P - 1) / k);
            if(sgn == - 1) w = Pow(w, P - 2);
            for(int i = 0; i < len; i += k){
                int now = 1;
                for(int j = i; j < i + (k >> 1); j++){
                    int x = a[j], y = 1ll * a[j+(k>>1)] * now % P;
                    a[j] = x + y >= P ? x + y - P : x + y;
                    a[j+(k>>1)] = x - y < 0 ? x - y + P : x - y;
                    now = 1ll * now * w % P;
                }
            }   
        }
        if(sgn == -1){
            int Inv = Pow(len, P - 2);
            for(int i = 0; i < len; i++)    
                a[i] = 1ll * a[i] * Inv % P;
        }
    }
}   
using poly::timesinit;
using poly::dft;
int main(){
    scanf("%s", s); int n = strlen(s);
    for(int i = 0; i < n; i++) 
        a[i] = s[i] == '0', b[i] = s[i] == '1';
    reverse(b, b + n);
    timesinit(n + n - 1);
    dft(a, 1), dft(b, 1);
    for(int i = 0; i < poly::len; i++) 
        a[i] = 1ll * a[i] * b[i] % P;
    dft(a, -1);
    ll ans = 1ll * n * n;
    for(int i = 1; i < n; i++){
        int flag = 0;
        for(int j = i; j < n; j += i)
            if(a[n-1+j] || a[n-1-j]) flag = 1;
        if(!flag) ans ^= 1ll * (n - i) * (n - i);   
    }
    cout << ans << endl;
    return 0;
}

「PKUWC2018/PKUSC2018」試題選做

相關推薦

「PKUWC2018/PKUSC2018」試題選做

str 合數 ever get 轉移 std else if 多維 線段樹合並 「PKUWC2018/PKUSC2018」試題選做 最近還沒想好報THUSC還是PKUSC，THU發我的三類約（再來一瓶）不知道要不要用，甚至不知道營還辦不辦，協議還有沒有用。所以這些事情就暫時

「美團 CodeM 資格賽」試題泛做

問號 main scanf one closed cal amp blank bsp LibreOJ真是吼啊！ 數碼 推個式子，把枚舉因數轉為枚舉倍數。然後就發現它是根號分段的。然後每一段算一下就好了。 1 #include <cstdio>

2019各省省選試題選做

http amp news 與或 new svi blog minimax 字符串 標題蒯的gsy的 感覺做不動了orz HNOI2019 D1T1魚 D1T2JOJO D1T3多邊形 D2T1校園旅行 D2T2白兔之舞 D2T3序列 十二省聯考2019 D1T1異或

loj2291. 「THUSC 2016」補退選

post arp loj begin brush switch return -- thusc https://loj.ac/problem/2291 在Tire樹套vector上亂搞一波 如何二分查找時間 #include<cstdio> #inc

[日常摸魚]「網絡流 24 題」試題庫

輸出 題目 flow void name amp date div ref https://loj.ac/problem/6006 題意：$n$道題每題有若幹種類別，一共有$k$種類別，告訴你每種類別各自需要的題數，構造一種選題目的方案並輸出方案。 雖然題目好像沒說不過一道

「PKUSC2018」星際穿越 (70分做法)

期望 成功 習慣 ons 由於 nbsp inpu 開始 long long 5371: [Pkusc2018]星際穿越 Time Limit: 10 Sec Memory Limit: 512 MBSubmit: 27 Solved: 11[Submit][Stat

loj2537 「PKUWC2018」Minimax 【概率 + 線段樹合並】

tdi size pri 題目 概率 log mini source ima 題目鏈接 loj2537 題解 觀察題目的式子似乎沒有什麽意義，我們考慮計算出每一種權值的概率 先離散化一下權值 顯然可以設一個\(dp\)，設\(f[i][j]\)表示\(i\)節點權值為\(j

【LOJ】 #2540. 「PKUWC2018」隨機算法

namespace 就是 int div esp 排列 template 每次 LV 題解 感覺極其神奇的狀壓dp \(dp[i][S]\)表示答案為i，然後不可選的點集為S 我們每次往答案裏加一個點，然後方案數是，設原來可以選的點數是y，新加入一個點後導致了除了新加的點之

codehunter 「Adera 6」杯省選模擬賽 網絡升級 【樹形dp】

siri ren getchar 樹形 usr mes getc img pre 直接抄ppt好了……來自SiriusRen 註意只用對根判斷是否喲留下兒子 #include<iostream> #include<cstdio> using nam

【刷題】LOJ 6006 「網絡流 24 題」試題庫

urn std ret ble 多個 網絡流 屬性 template += 題目描述 假設一個試題庫中有 \(n\) 道試題。每道試題都標明了所屬類別。同一道題可能有多個類別屬性。現要從題庫中抽取 \(m\) 道題組成試卷。並要求試卷包含指定類型的試題。試設計一個滿足要求的

做了「負載均衡」就可以隨便加機器了嗎？這三招來幫你！

本文長度為3056字，預計讀完需1.1MB流量，建議閱讀8分鐘。   閱讀目錄 什麼是Session丟失？ nginx是如何來解決這個問題的? Session保持的其它方案 結語

做了「負載均衡」就可以隨便加機器了嗎？

下面這個場景不知是否在你面前出現過： 開發Z哥對運維Y弟喊：“Y弟，現在系統好卡，剛上了一波活動，趕緊幫我加幾臺機器上去頂一下。” Y弟回覆說：“沒問題，分分鐘搞定”。 然後就發現數據庫的壓力迅速上升，DBA就吼了：“Z哥，你丫的搞什麼呢？資料庫要被你弄垮了”。 然後客

loj2542 「PKUWC2018」隨機遊走 min-max容斥證明

題目描述 給定一棵 n 個結點的樹，你從點 x 出發，每次等概率隨機選擇一條與所在點相鄰的邊走過去。 有 Q 次詢問，每次詢問給定一個集合 S，求如果從 x 出發一直隨機遊走，直到點集 S 中所有點都至少經過一次的話，期望遊走幾步。 特別地，點 x（即起點）視為一開始就被經過

LOJ #2542「PKUWC2018」隨機遊走

$ Min$-$Max$容斥真好用 $ PKUWC$滾粗後這題一直在$ todolist$裡 今天才補掉..還要更加努力啊.. LOJ #2542 題意：給一棵不超過$ 18$個節點的樹，$ 5000$次詢問，每次問從根隨機遊走走遍一個集合的期望步數 $ Solution:$ 考慮$ Min$

LOJ #2541「PKUWC2018」獵人殺

這樣$ PKUWC$就只差一道鬥地主了 假裝補題補完了吧..... 這題還是挺巧妙的啊...... LOJ # 2541 題意：每個人有一個嘲諷值$a_i$，每次殺死一個人，殺死某人的概率為$ \frac{a_i}{a_{alive}}$，求第一個人最後死的概率 資料範圍：$ 1 \leq a_i

「PKUSC2018」神仙的遊戲

qq截圖 定義 mem ret define n-1 char 說了 inline 題目鏈接 比如說上面\(|S|\)為12的字符串，我們欲求出\(f(9)\)的值，那麽上面相同顏色的字符必須兩兩能夠匹配。也就是說，同種顏色的字符集裏不能同時出現0和1。如果只考慮同種顏色

Loj2537 「PKUWC2018」Minimax （線段樹合併維護dp）

分析 設 f [ i ]

「爬蟲教程」Python做一個簡單爬蟲，小白也能看懂的教程

俗話說“巧婦難為無米之炊”，除了傳統的資料來源，如歷史年鑑，實驗資料等，很難有更為簡便快捷的方式獲得資料，在目前網際網路的飛速發展寫，大量的資料可以通過網頁直接採集，“網路爬蟲”應運而生，本篇將會講解簡單的網路爬蟲編寫方法。   開發環境 每個人的開發環境各異，下面上是我的開發

LOJ2538. 「PKUWC2018」Slay the Spire【組合數學】

LINK 思路 首先因為式子後面把方案數乘上了 所以其實只用輸出所有方案的攻擊力總和 然後很顯然可以用強化牌就儘量用 因為每次強化至少把下面的牌翻一倍，肯定是更優的 然後就只有兩種情況 強化牌數量少於k 強化牌數量大於等於k 根據乘法原理，設\(f_{i,j}\)是選i張強化

【LOJ】#6433. 「PKUSC2018」最大字首和

題解 神仙的狀壓啊QAQ 設一個\(f[S]\)表示數字的集合為\(S\)時\(sum[S]\)為字首最大值的方案數 \(g[S]\)表示數字集合為\(S\)時所有字首和都小於等於0的方案數 答案就是\(sum_{S} sum[S] * f[S] * g[2^{N} - 1 - S]\) 求\(f\)