题目描述

擦弹_数据

输入

第一行是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(n3)
超时:
1.O(n4),但可以常数优化。
令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];
}