CodeStar2022年秋第9周周赛普及进阶组

T1: k的幂分拆

本题难度中等，完全背包模板题，以 $k$ 的幂作为物品大小

记 dp[i][j] 表示使用若干个 $k^0 \sim k^i$，相加恰好为 $j$ 的方案数

转移：

$dp[i][j] = dp[i-1][j] + dp[i][j-k^i]$

假设 $n$ 是满足 $k^n \leqslant m$ 的最大值，时间复杂度就是 $O(nm)$
这里 $n \leqslant 20$

代码实现

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
 
using namespace std;
using ll = long long;
 
//const int mod = 998244353;
const int mod = 1000000007;
struct mint {
    ll x;
    mint(ll x=0):x((x%mod+mod)%mod) {}
    mint operator-() const {
        return mint(-x);
    }
    mint& operator+=(const mint a) {
        if ((x += a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator-=(const mint a) {
        if ((x += mod-a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator*=(const mint a) {
        (x *= a.x) %= mod;
        return *this;
    }
    mint operator+(const mint a) const {
        return mint(*this) += a;
    }
    mint operator-(const mint a) const {
        return mint(*this) -= a;
    }
    mint operator*(const mint a) const {
        return mint(*this) *= a;
    }
    mint pow(ll t) const {
        if (!t) return 1;
        mint a = pow(t>>1);
        a *= a;
        if (t&1) a *= *this;
        return a;
    }
 
    // for prime mod
    mint inv() const {
        return pow(mod-2);
    }
    mint& operator/=(const mint a) {
        return *this *= a.inv();
    }
    mint operator/(const mint a) const {
        return mint(*this) /= a;
    }
};
istream& operator>>(istream& is, mint& a) {
    return is >> a.x;
}
ostream& operator<<(ostream& os, const mint& a) {
    return os << a.x;
}
 
int p[20];
mint dp[100005];
 
int main() {
    int m, k;
    cin >> m >> k;
    
    int n = 0;
    p[n] = 1;
    while (p[n]*k <= m) {
        p[n+1] = p[n]*k;
        ++n;
    }
    
    dp[0] = 1;
    rep(i, n+1) {
        for (int j = p[i]; j <= m; ++j) {
            dp[j] += dp[j-p[i]];
        }
    } 
    
    cout << dp[m] << '\n';
    
    return 0;
}

方法2：

记 dp[j] 表示 $j$ 的 $k$ 次幂分拆方案数

$j = a_0k^0 + a_1k^0 + \cdots + a_nk^n$

1. 当 $j \% k \neq 0$ 时，

$$\begin{aligned}j &\equiv a_0 \pmod k\\ j-1 &\equiv a_0 -1 \pmod k \end{aligned}$$

所以，$dp[j] = dp[j-1]$

2. 当 $j \% k = 0$ 时，

• $a_0 = 0$，$j = a_1k^1 + \cdots a_nk^n$，$\frac{j}{k} = a_1k^0 + \cdots + a_nk^{n-1}$

• $a_0 \neq 0$，和上面 $j \% k \neq 0$ 的情况一样

所以 $dp[j] = dp[\frac{j}{k}] + dp[j-1]$

时间复杂度为 $O(m)$

代码实现

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
 
using namespace std;
using ll = long long;
 
//const int mod = 998244353;
const int mod = 1000000007;
struct mint {
    ll x;
    mint(ll x=0):x((x%mod+mod)%mod) {}
    mint operator-() const {
        return mint(-x);
    }
    mint& operator+=(const mint a) {
        if ((x += a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator-=(const mint a) {
        if ((x += mod-a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator*=(const mint a) {
        (x *= a.x) %= mod;
        return *this;
    }
    mint operator+(const mint a) const {
        return mint(*this) += a;
    }
    mint operator-(const mint a) const {
        return mint(*this) -= a;
    }
    mint operator*(const mint a) const {
        return mint(*this) *= a;
    }
    mint pow(ll t) const {
        if (!t) return 1;
        mint a = pow(t>>1);
        a *= a;
        if (t&1) a *= *this;
        return a;
    }
 
    // for prime mod
    mint inv() const {
        return pow(mod-2);
    }
    mint& operator/=(const mint a) {
        return *this *= a.inv();
    }
    mint operator/(const mint a) const {
        return mint(*this) /= a;
    }
};
istream& operator>>(istream& is, mint& a) {
    return is >> a.x;
}
ostream& operator<<(ostream& os, const mint& a) {
    return os << a.x;
}
 
mint dp[100005];
 
int main() {
    int m, k;
    cin >> m >> k;
    
    dp[0] = 1;
    for (int j = 1; j <= m; ++j) {
        dp[j] = dp[j-1];
        if (j%k == 0) dp[j] += dp[j/k];
    }
    
    cout << dp[m] << '\n';
    
    return 0;
}

T2：垃圾游戏

本题难度较大，用dp算出恰好获得 $1$ 到 $50000$ 点经验值分别需要的最少时间。计算每级需要时间时，在dp数组中经验大于等于所需经验时需要的最少时间。

从 $1$ 级升到 $n$ 级，$n-1$ 次升级，每一次互不影响
每次升级是一个单独的问题
本质是同一个问题
想获得至少 $j$ 点经验所需时间 min

代码实现

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
 
using namespace std;
using ll = long long;
 
const int M = 51000;
 
int main() {
    int n, m;
    cin >> n >> m;
    
    vector<int> e(n-1), p(m), t(m);
    rep(i, n-1) cin >> e[i];
    rep(i, m) cin >> p[i];
    rep(i, m) cin >> t[i];
    
    const int INF = 1001001001;
    vector<int> dp(M+1, INF);
    dp[0] = 0;
    rep(i, m) {
        for (int j = p[i]; j <= M; ++j) {
            dp[j] = min(dp[j], dp[j-p[i]] + t[i]);
        }
    }
    
    vector<int> mint(M+2);
    mint[M+1] = INF;
    for (int i = M; i >= 1; --i) {
        mint[i] = min(mint[i+1], dp[i]);
    }
    
    ll ans = 0;
    rep(i, n-1) ans += mint[e[i]];
    
    cout << ans << '\n';
    
    return 0;
}