擦弹

题目描述

输入

第一行是1个正整数n，代表道路长度。

接下来有4n-4行，每行n个整数，第i行第j个数代表在i时刻（开始为0时刻）在第j格内受到的伤害。

 

输出

两个整数，用空格隔开，分别代表最小的miss数，和在miss数最小的情况下最大的graze 数。

 

样例输入

2 1 2 2 2 3 2 4 2

样例输出

30 10

提示

只有一种走法。

第一回合：第一格3分身，第二格1分身，miss5，graze1。

第二回合：第一格2分身，第二格2分身，miss8，graze2。

第三回合：第一格1分身，第二格3分身，miss9，graze3。

第四回合：第一格0分身，第二格4分身，miss8，graze4。

其中30%数据:n<=3其中50%数据:n<=10其中70%数据:n<=30

100%数据:n<=100,每时刻每格中弹幕数均为正数且小于  1000

四维动规。

不难得到方程：

f[p][i][j][k][l]表示p回合，分身在i，j，k，l的最小miss数.graze[p][i][j][k][l]不多说.

f[p][i][j][k][l]=f[p-1][i-1][j][k][l]+d[i]+d[j]+d[k]+d[l];

（表i走一步）其他类推。
现在的问题是超时，超空间

超空间：

用滚动数组，将p和p-1变为0,1.滚动递推

空间O(n³)

超时：

1.O（n⁴），但可以常数优化。

令i<=j<=k<=l,并运用不等式缩小上下界

2.递推赋值时用指针取代，减少访问时间（见代码）

3.摒弃传统滚动数组直接交换f[1],f[0],而是用last，next指代0,1.每次交换last，next,则为一次滚动.

虽然复杂度理论上很高，但以上优化可将运算减少20-30倍.

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
int miss[2][101][101][101],graze[2][101][101][101];
int n;
int c[101][501];
int get()
{
    char ch;
    int x=0;
    ch=getchar();
    while (ch<'0'||ch>'9') ch=getchar();
    while (ch>='0'&&ch<='9')
    {
        x=x*10+ch-'0';
        ch=getchar();
    }
    return x;
}
int main()
{
//  freopen("graze.in","r",stdin);
//  freopen("graze.out","w",stdout);
    int i,j,k,p;
    cin>>n;
    for (i=1; i<=4*n-4; i++)
    {
        for (j=1; j<=n; j++)
            c[j-1][i]=get();
    }
    miss[0][0][0][0]=0;
    int lst=0,nxt=1;
    for (p=1; p<=4*n-4; p++)
    {
        for (i=0; i<=min(p,n-1); i++)
        {
            for (j=i; j<=min((p-i)-1,n-1); j++)
            {
                for (k=j; k<=min((p-i-j)/2,n-1); k++)
                    if (p-i-j-k>=k&&p-i-j-k<n)
                    {
                        int *x=&miss[nxt][i][j][k];
                        int *y=&graze[nxt][i][j][k];
                        int z=c[i][p]+c[j][p]+c[k][p]+c[p-i-j-k][p];
                        *x=2e9;
                        *y=0;
                        if (i)
                        {
                            if (*x>=miss[lst][i-1][j][k]+z)
                            {
                                if (*x==miss[lst][i-1][j][k]+z)
                                {
                                    if (graze[lst][i-1][j][k]+c[i-1][p]>*y)
                                        *y=graze[lst][i-1][j][k]+c[i-1][p];
                                }
                                else *y=graze[lst][i-1][j][k]+c[i-1][p];
 
                                *x=miss[lst][i-1][j][k]+z;
                            }
                        }
                        if (j-1>=i)
                        {
                            if (*x>=miss[lst][i][j-1][k]+z)
                            {
                                if (*x==miss[lst][i][j-1][k]+z)
                                {
                                    if (graze[lst][i][j-1][k]+c[j-1][p]>*y)
                                        *y=graze[lst][i][j-1][k]+c[j-1][p];
                                }
                                else *y=graze[lst][i][j-1][k]+c[j-1][p];
 
                                *x=miss[lst][i][j-1][k]+z;
                            }
                        }
                        if (k-1>=j)
                        {
                            if (*x>=miss[lst][i][j][k-1]+z)
                            {
                                if (*x==miss[lst][i][j][k-1]+z)
                                {
                                    if (graze[lst][i][j][k-1]+c[k-1][p]>*y)
                                        *y=graze[lst][i][j][k-1]+c[k-1][p];
                                }
                                else *y=graze[lst][i][j][k-1]+c[k-1][p];
 
                                *x=miss[lst][i][j][k-1]+z;
                            }
                        }
                        if (p-i-j-k-1>=k)
                        {
                            if (*x>=miss[lst][i][j][k]+z)
                            {
                                if (*x==miss[lst][i][j][k]+z)
                                    {
                                        if (graze[lst][i][j][k]+c[p-i-j-k-1][p]>*y)
                                         *y=graze[lst][i][j][k]+c[p-i-j-k-1][p];
                                    }
                                else *y=graze[lst][i][j][k]+c[p-i-j-k-1][p];
 
                                *x=miss[lst][i][j][k]+z;
                            }
                        }
                    }
            }
        }
        swap(lst,nxt);
    }
    cout<<miss[lst][n-1][n-1][n-1]<<' '<<graze[lst][n-1][n-1][n-1];
}