Educational DP Contest K-N

K - Stones

题意: K个石子，Taro和Jiro两人轮流从(a₁, a₂,...,a_N)中取a_i石子，Taro先取，直到无法取则判负。
思路: dp[i]: i个石子时Taro赢否？(true为赢，false为输），则dp[i] = {dp[i-a[k]]}其中有一个true即为true，dp[0] = false。
代码:

#include
using namespace std;

const int MAXN = 110;
const int MAXK = 1e5+10;

using ll = long long;

int N, K;
int a[MAXN];


// dp[i]: can i stones win?
int dp[MAXK];

int main() {
    cin >> N >> K;
    for(int i=1; i<=N; i++) cin >> a[i];
    sort(a+1, a+N+1);
    
    dp[0] = 0;
    for(int i=a[0]; i<=K; i++) {
        int flag = 0;
        for(int j=1; j<=N; j++) {
            if(i-a[j]>=0 && !dp[i-a[j]]){
                flag = 1;
                break;
            } 
        }
        if(flag) dp[i] = 1;
    }
    string res = dp[K]?"First":"Second";
    cout << res << endl; 
    return 0;
}

L - Deque

题意: 一堆数，两人轮流从中取（只能头或尾），Taro要最大化X-Y，Jiro要最小化X-Y，求最终结果X-Y。
思路: 有最大有最小，既然要dp显然要调整一下步调。Jiro最小化X-Y，实际上就是最大化Y-X。设dp[i][j]: i到j的X-Y，则每一轮dp[i][j]就是max{Taro(X-Y), Jiro(Y-X)}，即dp[i][j] = max{a[i]-dp[i+1][j] , (a[j]-dp[i][j-1])}。
代码：

#include 
using namespace std;

using LL = long long;
const int MAXN = 3010;

int A[MAXN];
LL dp[MAXN][MAXN];
int N;

int main() {
    cin >> N;
    for(int i=1; i<=N; i++) cin >> A[i];
    
    memset(dp, 0, sizeof(dp));
    for(int i=N; i>0; i--) {
        for(int j=i; j<=N; j++) {
            if(i==j) dp[i][j] = A[i];
            dp[i][j] = max(A[j]-dp[i][j-1], A[i]-dp[i+1][j]);
        }
    }
    
    cout << dp[1][N] << endl;
    return 0;
}

M - Candies

题意：求n个孩子分m个糖果的种类数，其中第i个孩子最多分a[i]个糖果。
思路：dp[i][j]: 前i个孩子分前j个糖果的和种类数，则有。
第一种O(n³)方法如下：

#include

using namespace std;

const int MAXN  = 110;
const int MAXK = 1e5+10;

int N, K;
int A[MAXN];
int dp[MAXN][MAXK];

int main() {
    cin >> N >> K;
    for(int i=1; i<=N; i++) {
        cin >> A[i];
    }

    dp[0][0] = 1;
    for(int i=1; i<=N; i++) {
        for(int j=0; j<=K; j++) {
            for(int k=0; k<=min(A[i], j); k++) {
                dp[i][j] += dp[i-1][j-k];
            }
        }
    }
    cout << dp[N][K] << endl;
    return 0;
}

但显然超时。
观察到dp[i][j]是从j-min(A[i],j)到j的和，可以用前缀和解决，dp[i][j] = prefix(j) - prefix(j-min(A[i],j)-1)，减少一层循环，复杂度为O(n²)。

#include

using namespace std;

const int MAXN  = 110;
const int MAXK = 1e5+10;
const int MOD = 1e9+7;

int N, K;
int A[MAXN];
int dp[MAXN][MAXK];
int prefix[MAXK];

int addmod(int a, int b) {
    a += b;
    if(a > MOD) {
        a -= MOD;
    }
    return a;
}

int submod(int a, int b) {
    a -= b;
    if(a < 0) {
        a += MOD;
    }
    return a;
}
int main() {
    cin >> N >> K;
    for(int i=1; i<=N; i++) {
        cin >> A[i];
    }

    dp[0][0] = 1;
    prefix[0] = 1;
    for(int j=1; j<=K; j++) {
        prefix[j] = addmod(prefix[j], prefix[j-1]);
    }
    for(int i=1; i<=N; i++) {
        for(int j=0; j<=K; j++) {
            int L, R;
            L = j-min(A[i],j)-1>=0?prefix[j-min(A[i], j)-1]:0;
            R = prefix[j];
            
            dp[i][j] = addmod(dp[i][j], submod(R, L));
        }
        for(int j=0; j<=K; j++) {
            prefix[j] = dp[i][j];
        }
        for(int j=1; j<=K; j++) {
            prefix[j] = addmod(prefix[j], prefix[j-1]);
        }
    }
    cout << dp[N][K] << endl;
    return 0;
}

N - Slimes

题意：合并石块
思路：区间dp，复杂度O(N³)，可以用平行四边形不等式优化，复杂度是O(N²)。
代码：

#include

using namespace std;
const int MAXN = 410;
using LL = long long;

int N;
int A[MAXN];
LL dp[MAXN][MAXN];
LL sum[MAXN];

int main() {
    cin >> N;
    sum[0] = 0;
    memset(dp, 0x3f, sizeof(dp));
    for(int i=1; i<=N; i++) {
        cin >> A[i];
        dp[i][i] = 0;
        sum[i] += sum[i-1]+A[i];
    }
    
    for(int len = 1; len<=N-1; len++) {
        for(int i=1; len+i<=N; i++) {
            int j = i+len;
//            if(j>N) continue;
            for(int k=i; k

平行四边形不等式优化

#include

using namespace std;
const int MAXN = 410;
using LL = long long;

int N;
int A[MAXN];
LL dp[MAXN][MAXN];
LL s[MAXN][MAXN];
LL sum[MAXN];

int main() {
    cin >> N;
    sum[0] = 0;
    memset(dp, 0x3f, sizeof(dp));
    for(int i=1; i<=N; i++) {
        cin >> A[i];
        dp[i][i] = 0;
        s[i][i] = i;
        sum[i] += sum[i-1]+A[i];
    }
    
    for(int len = 1; len<=N-1; len++) {
        for(int i=1; len+i<=N; i++) {
            int j = i+len;
//            if(j>N) continue;
            // 平行四边形不等式优化
            for(int k=s[i][j-1]; k<=s[i+1][j]; k++) {
                if(dp[i][k] + dp[k+1][j] + sum[j] - sum[i-1] <= dp[i][j]) {
                    dp[i][j] = dp[i][k] + dp[k+1][j] + sum[j] - sum[i-1];
                    s[i][j] =  k;
                }
            }
        }
    }

    cout << dp[1][N] << endl;
    return 0;
}