nyoj 737 石子合并（一）。区间dp

http://acm.nyist.net/JudgeOnline/problem.php?pid=737

数据很小，适合区间dp的入门

对于第[i, j]堆，无论你怎么合并，无论你先选哪两堆结合，当你把[i, j]合成一堆的那一步的时候，花费肯定就是sum[i....j]

可以用纸模拟下。

那么我们设dp[i][j]表示把i...j堆合成一堆的时候的最小花费。

比如dp[1][1] = 0。dp[1][2] = a[1] + a[2];

那么要求dp[i][j]，则可以是dp[i][k] + dp[k + 1][j] + cost

注意dp的时候的顺序，因为要求dp[1][n]，则需要用到dp[1][k]和dp[k][n]

你需要考虑下怎么for，才能使得子问题已经被算出，建议一开始用dfs + 记忆化做。

这里dp的顺序应该是先算出2个集合的，3个、4个、......

就是先算出dp[1][2], dp[2][3]，这使得求dp[1][3]成为可能。

all dp[i][i] = 0

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <assert.h>
#define IOS ios::sync_with_stdio(false)
using namespace std;
#define inf (0x3f3f3f3f)
typedef long long int LL;
 
#include <iostream>
#include <sstream>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <string>
 
const int maxn =  + ;
int n;
int a[maxn];
int dp[maxn][maxn];
int sum[maxn];
int dfs(int be, int en) {
    if (be > en) return ;
    if (be == en) {
        return dp[be][en] = ;
    }
    if (dp[be][en] != inf) return dp[be][en];
    for (int k = be; k <= en; ++k) {
        dp[be][k] = dfs(be, k);
        dp[k + ][en] = dfs(k + , en);
        assert(dp[be][k] >= );
        assert(dp[k + ][en] >= );
        dp[be][en] = min(dp[be][k] + dp[k + ][en] + sum[en] - sum[be - ], dp[be][en]);
//        cout << dp[2][3] << endl;
    }
    return dp[be][en];
}
void work() {
    for (int i = ; i <= n; ++i) {
        scanf("%d", &a[i]);
        sum[i] = sum[i - ] + a[i];
    }
    memset(dp, , sizeof dp);
//    cout << dfs(1, n) << endl;
//    cout << dp[2][3] << endl;
    for (int k = ; k <= n - ; ++k) {
        for (int i = ; i <= n - ; ++i) {
            int be = i;
            int en = i + k;
            if (en > n) break;
            dp[be][en] = inf;
            for (int h = be; h <= en - ; ++h) {
                dp[be][en] = min(dp[be][en], dp[be][h] + dp[h + ][en] + sum[en] - sum[be - ]);
            }
        }
    }
    printf("%d\n", dp[][n]);
}
 
int main() {
#ifdef local
    freopen("data.txt", "r", stdin);
//    freopen("data.txt", "w", stdout);
#endif
    while (scanf("%d", &n) != EOF) work();
    return ;
}

平行四边形优化，其实我还不是很懂。那个证明太难了。

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <assert.h>
#define IOS ios::sync_with_stdio(false)
using namespace std;
#define inf (0x3f3f3f3f)
typedef long long int LL;
 
#include <iostream>
#include <sstream>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <string>
int n;
const int maxn = 1e3 + ;
int dp[maxn][maxn];
int s[maxn][maxn];
int sum[maxn];
void work() {
    for (int i = ; i <= n; ++i) {
        int x;
        scanf("%d", &x);
        sum[i] = sum[i - ] + x;
        dp[i][i] = ;
        s[i][i] = i;
    }
    for (int dis = ; dis <= n - ; ++dis) {
        for (int be = ; be + dis <= n; ++be) {
            int en = be + dis;
            dp[be][en] = inf;
            int t = s[be][en];
            for (int k = s[be][en - ]; k <= s[be + ][en]; ++k) {
                if (k +  > en) break;
                if (dp[be][en] >= dp[be][k] + dp[k + ][en] + sum[en] - sum[be - ]) {
                    dp[be][en] = dp[be][k] + dp[k + ][en] + sum[en] - sum[be - ];
                    t = k;
                }
            }
            s[be][en] = t;
        }
    }
    cout << dp[][n] << endl;
}
int main() {
#ifdef local
    freopen("data.txt", "r", stdin);
//    freopen("data.txt", "w", stdout);
#endif
    while (scanf("%d", &n) != EOF) work();
    return ;
}

简单来说，就是设s[i][j]表示第i---j堆石子合并的时候，在第s[i][j]那里合并，是最优的。

那么可以证明的是：s[i][j - 1] <= s[i][j] <= s[i + 1][j]

那么只需要枚举里面的值就好了。