Codeforces Beta Round #6 (Div. 2 Only) D. Lizards and Basements 2

题目大意

有排成一排的$n$个弓箭手，第$i$个弓箭手有 $h_i$ 的血量。主角可以使用火球术去攻击弓箭手。被直接攻击的弓箭手$i$受到$a$点伤害，同时第$i-1$个和第$i+1$个弓箭手会受到$b$点伤害。当弓箭手的血量小于$0$时弓箭手死亡。问最少需要释放多少个火球术，每个火球术攻击的是第几个弓箭手。

解题思路

这是一个动态规划问题。定义一个四维$dp$数组。对于$dp[i][j][k][l]$来说表示了当第$i-1$个弓箭手的血量是$j$，第$i$个弓箭手的血量是$k$，第$i+1$个弓箭手的血量是$l$时释放火球的最小数目。初始值$dp[1][h[0]][h[1]][h[2]]=0$,其他为无穷大，其中$h[i]$代表第$i$个弓箭手的血量。

题目代码

#include <set>
#include <map>
#include <queue>
#include <math.h>
#include <vector>
#include <string>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <cctype>
#include <algorithm>
#include <time.h>
#define eps 1e-10
#define pi acos(-1.0)
#define inf 107374182
#define inf64 1152921504606846976
#define lc l,m,tr<<1
#define rc m + 1,r,tr<<1|1
#define zero(a) fabs(a)<eps
#define iabs(x)  ((x) > 0 ? (x) : -(x))
#define clear1(A, X, SIZE) memset(A, X, sizeof(A[0]) * (min(SIZE,sizeof(A))))
#define clearall(A, X) memset(A, X, sizeof(A))
#define memcopy1(A , X, SIZE) memcpy(A , X ,sizeof(X[0])*(SIZE))
#define memcopyall(A, X) memcpy(A , X ,sizeof(X))
#define max( x, y )  ( ((x) > (y)) ? (x) : (y) )
#define min( x, y )  ( ((x) < (y)) ? (x) : (y) )
using namespace std;

int n,a,b,h[15];

int dp[15][20][20][20];

struct node
{
    int i,j,k,l;
} p[15][20][20][20],temp;

int main()
{
    scanf("%d%d%d",&n,&a,&b);
    for(int i=0; i<n; i++)
    {
        scanf("%d",&h[i]);
        h[i]++;
    }
    clearall(dp,0x3f);
    dp[1][h[0]][h[1]][h[2]]=0;
    int x,y,z,d1,d2,d3,init = dp[0][0][0][0];
    //cout<<init;
    for(int i=1; i<n-1; i++)
    {
        for(int j=h[i-1]; j>=0; j--)
        {
            for(int k=h[i]; k>=0; k--)
            {
                for(int l=h[i+1]; l>=0; l--)
                {
                    if(dp[i][j][k][l]!=init)
                    {
                        d1=max(0,j-b);
                        d2=max(0,k-a);
                        d3=max(0,l-b);
                        if(dp[i][d1][d2][d3]>dp[i][j][k][l]+1)
                        {
                            dp[i][d1][d2][d3]=dp[i][j][k][l]+1;
                            p[i][d1][d2][d3].j=j;
                            p[i][d1][d2][d3].k=k;
                            p[i][d1][d2][d3].l=l;
                            p[i][d1][d2][d3].i=i;
                        }
                        if(d1==0&&dp[i+1][d2][d3][h[i+2]]>dp[i][j][k][l]+1)
                        {
                            dp[i+1][d2][d3][h[i+2]]=dp[i][j][k][l]+1;
                            p[i+1][d2][d3][h[i+2]].i=i;
                            p[i+1][d2][d3][h[i+2]].j=j;
                            p[i+1][d2][d3][h[i+2]].k=k;
                            p[i+1][d2][d3][h[i+2]].l=l;
                        }
                        if(j==0&&dp[i+1][k][l][h[i+2]]>dp[i][j][k][l])
                        {
                            dp[i+1][k][l][h[i+2]]=dp[i][j][k][l];
                            p[i+1][k][l][h[i+2]]=p[i][j][k][l];
                        }
                    }
                }
            }
        }
    }

    printf("%d\n",dp[n-1][0][0][0]);
    temp.i=n-1;
    temp.j=0;
    temp.k=0;
    temp.l=0;
    while(!(temp.i==1&&temp.j==h[0]&&temp.k==h[1]&&temp.l==h[2]))
    {
        temp = p[temp.i][temp.j][temp.k][temp.l];
        printf("%d ",temp.i+1);
    }
    return 0;
}