hdu5115（区间dp）

n头狼排成一列，每头狼有两个属性，基础攻击力和附加攻击力，

第i只狼的基础攻击力是ai，附加攻击力是b(i-1) + b(i+1)

消灭一只狼，受到的伤害为基础攻击力+附加攻击力。

问消灭所有的狼受到的最小伤害。

基础攻击力的伤害肯定是要承受的。关键是怎么将附加攻击力的伤害降低到最小

像这种不能从前往后状态转移的dp，应该是用区间dp。

设dp[i][j] 为消灭区间i->j所有狼的最小代价

我们枚举最后一只要消灭的狼k，那么消灭这只狼要收到的附加攻击力是b[i-1] + b[j+1]

所有dp[i][j] = min(dp[i][j],dp[i][k-1] + dp[k+1][j] + b[i-1] + b[j+1]);

最后的答案是dp[1][n] + sum(a[i]);

#pragma warning(disable:4996)
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <math.h>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <bitset>
#include <algorithm>
#include <iostream>
#include <string>
#include <functional>
const int INF = 1 << 30;
typedef __int64 LL;
/*

*/
const int N = 200 + 10;
int b[N];
int dp[N][N];
int solve(int n)
{
    for (int i = 1;i <= n;++i)
        dp[i][i] = b[i - 1] + b[i + 1];
    for (int len = 2;len <= n;++len)
    {
        for (int i = 1;i + len-1 <= n;++i)
        {
            int j = i + len - 1;
            dp[i][j] = INF;
            for (int k = i;k <= j;++k)
            {
                //dp[i][j] 表示消灭区间的最小代价，枚举最后一只消灭的狼，那么要受到的附加伤害是b[i-1]+b[j+1]
                dp[i][j] = std::min(dp[i][j], dp[i][k - 1] + dp[k + 1][j] + b[i - 1] + b[j + 1]);
            }
        }
    }
    return dp[1][n];
}
int main()
{
    int t, n;
    int a, ans;
    scanf("%d", &t);
    for (int k = 1;k <= t;++k)
    {
        ans = 0;
        scanf("%d", &n);
        for (int i = 1;i <= n;++i)
        {
            scanf("%d", &a);
            ans += a;
        }
        for (int i = 1;i <= n;++i) scanf("%d", &b[i]);
        printf("Case #%d: %d
", k, ans + solve(n));
    }
    return 0;
}