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]\)

  1. 当 \(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;
}