洛谷NOIP提高组训练吊打记录（动态规划）

没错，是我被吊打。

洛谷 – P1970 – 花匠（递推dp）
https://www.luogu.org/fe/problem/P1970
被NOIP普及难度的dp吊打？我咋那么菜？

int a[maxn], dp[maxn], dp2[maxn];//dp：波峰，dp2：波谷
int main()
{
    ios::sync_with_stdio(0); cin.tie(0);
    int n;
    cin >> n;
    for (int i = 1; i <= n; ++i) cin >> a[i];

    //首先第一盆一定要选，因为如果从第二盆开始选，无论如何结果都不会更优
    //如果第i - 1盆的高度小于第i盆的，
    //那么第i盆一定要当波峰，第i - 1盆一定要当波谷，
    //如果要当波谷的话，那么第i盆不如第i - 1盆当波谷好，直接弃掉
    //相反同理

    dp[1] = dp2[1] = 1;
    for (int i = 2; i <= n; ++i){
        if (a[i - 1] < a[i]){
            dp[i] = dp2[i - 1] + 1;
            dp2[i] = dp2[i - 1];
        }else if (a[i - 1] > a[i]){
            dp2[i] = dp[i - 1] + 1;
            dp[i] = dp[i - 1];
        //别忘了有相等的情况，直接把前面的结果拿过来不会影响答案，否则就空了
        }else dp[i] = dp[i - 1], dp2[i] = dp2[i - 1];
    }

    cout << max(dp[n], dp2[n]) << endl;
    return 0;
}

P1018 乘积最大
https://www.luogu.org/fe/problem/P1018
定义dp[i][j]：前i个数有j个隔板的答案，枚举上一个隔板放的位置转移即可。
注意：Java的BigInteger的默认初始化值是NULL！无法参与数值运算，所以需要先手动循环初始化。

import java.math.BigInteger;
import java.util.Scanner;

public class Main {

    static BigInteger a[] = new BigInteger[55];
    static BigInteger dp[][] = new BigInteger[55][10];
    static void init()
    {
        for (int i = 0; i < 55; ++i) {
            a[i] = BigInteger.valueOf(0);
            for (int j = 0; j < 10; ++j) {
                dp[i][j] = BigInteger.valueOf(0);
            }
        }
    }
    static BigInteger cal(int l, int r)
    {
        BigInteger res = BigInteger.valueOf(0);
        for (int i = l; i <= r; ++i) {
            res = res.multiply(BigInteger.valueOf(10));
            res = res.add(a[i]);
        }
        return res;
    }
    static BigInteger max(BigInteger one, BigInteger two) {
        if (one.compareTo(two) == 1) return one;
        else return two;
    }
    public static void main(String[] args) {
       
        init();
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        String s = in.next();
        for (int i = 0; i < s.length(); ++i) a[i + 1] = BigInteger.valueOf((int)(s.charAt(i) - '0'));
       
        for (int i = 1; i <= n; ++i){
            dp[i][0] = cal(1, i);
        }

        for (int i = 2; i <= n; ++i){
            for (int k = 1; k <= m; ++k){
                for (int j = 1; j < i; ++j){
                    dp[i][k] = max(dp[i][k], dp[j][k - 1].multiply(cal(j + 1, i)));
                }
            }
        }
        System.out.println(dp[n][m]);
    }

}

P1006 传纸条
https://www.luogu.org/problemnew/show/P1006
dp[i][j][k][l]：第一个人走到(i, j)，第二个人走到(k, l)的答案。
每人每次都必须走一步，都可以继承来自左和上的最优值，所以一共有四种情况。
如果两个人走到同一个点了，这个点的值只计算一次。

int a[55][55], dp[55][55][55][55];

int main()
{
    ios::sync_with_stdio(0); cin.tie(0);
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; ++i){
        for (int j = 1; j <= m; ++j){
            cin >> a[i][j];
        }
    }
    for (int i = 1; i <= n; ++i){
        for (int j = 1; j <= m; ++j){
            for (int k = 1; k <= n; ++k){
                for (int l = 1; l <= m; ++l){
                    int tm = 0;
                    tm = max(tm, dp[i - 1][j][k - 1][l] + a[i][j] + a[k][l]);
                    tm = max(tm, dp[i - 1][j][k][l - 1] + a[i][j] + a[k][l]);
                    tm = max(tm, dp[i][j - 1][k - 1][l] + a[i][j] + a[k][l]);
                    tm = max(tm, dp[i][j - 1][k][l - 1] + a[i][j] + a[k][l]);
                    if (i == k && j == l) dp[i][j][k][l] = max(dp[i][j][k][l], tm - a[i][j]);
                    else dp[i][j][k][l] = max(dp[i][j][k][l], tm);
                }
            }
        }
    }
    cout << dp[n][m][n][m] << endl;
    return 0;
}

P1541 乌龟棋
https://www.luogu.org/problemnew/show/P1541
这题关键是每种卡片只能使用一次。
定义dp[i][j][k][l]：第一种用了i个，第二种用了j个，……。
每次当前的状态都可以由使用四种卡片转移过来，相当于枚举了所有的使用顺序。

int a[355], b[5], dp[45][45][45][45];

int main()
{
    ios::sync_with_stdio(0); cin.tie(0);
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; ++i){
        cin >> a[i];
    }
    for (int i = 1; i <= m; ++i){
        int x;
        cin >> x;
        ++b[x];
    }
    for (int i = 0; i <= b[1]; ++i){
        for (int j = 0; j <= b[2]; ++j){
            for (int k = 0; k <= b[3]; ++k){
                for (int l = 0; l <= b[4]; ++l){
                    int tm = 0;
                    if (i > 0) tm = max(tm, dp[i - 1][j][k][l]);
                    if (j > 0) tm = max(tm, dp[i][j - 1][k][l]);
                    if (k > 0) tm = max(tm, dp[i][j][k - 1][l]);
                    if (l > 0) tm = max(tm, dp[i][j][k][l - 1]);
                    dp[i][j][k][l] = max(dp[i][j][k][l], tm + a[1 + i * 1 + j * 2 + k * 3 + l * 4]);
                }
            }
        }
    }
    cout << dp[b[1]][b[2]][b[3]][b[4]] << endl;
    return 0;
}

P1040 加分二叉树
https://www.luogu.org/problemnew/show/P1040
好像一个区间dp，dp[l][r]为l到r这段区间的答案，然后在区间内枚举根转移即可。

int a[35], dp[35][35], root[35][35];
void print(int l, int r)
{
    if (l > r) return ;
    int rt = root[l][r];
    cout << rt << ' ';
    print(l, rt - 1);
    print(rt + 1, r);
}
int dfs(int l, int r)
{
    if (dp[l][r] > 0) return dp[l][r];
    if (l == r) return a[l];
    if (l > r) return 1;
    for (int i = l; i <= r; ++i){
        int t = dfs(l, i - 1) * dfs(i + 1, r) + a[i];
        if (t > dp[l][r]){
            dp[l][r] = t;
            root[l][r] = i;
        }
    }
    return dp[l][r];
}
int main()
{
    ios::sync_with_stdio(0); cin.tie(0);

    int n;
    cin >> n;
    for (int i = 1; i <= n; ++i) cin >> a[i];
    for (int i = 1; i <= n; ++i) dp[i][i] = a[i], root[i][i] = i;
    cout << dfs(1, n) << endl;
    print(1, n);
    return 0;
}