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 =  << ;
 typedef __int64 LL;
 /*

 */
 const int N =  + ;
 int b[N];
 int dp[N][N];
 int solve(int n)
 {
     for (int i = ;i <= n;++i)
         dp[i][i] = b[i - ] + b[i + ];
     for (int len = ;len <= n;++len)
     {
         for (int i = ;i + len- <= n;++i)
         {
             int j = i + len - ;
             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 - ] + dp[k + ][j] + b[i - ] + b[j + ]);
             }
         }
     }
     return dp[][n];
 }
 int main()
 {
     int t, n;
     int a, ans;
     scanf("%d", &t);
     for (int k = ;k <= t;++k)
     {
         ans = ;
         scanf("%d", &n);
         for (int i = ;i <= n;++i)
         {
             scanf("%d", &a);
             ans += a;
         }
         for (int i = ;i <= n;++i) scanf("%d", &b[i]);
         printf("Case #%d: %d\n", k, ans + solve(n));
     }
     return ;
 }