zoukankan      html  css  js  c++  java
  • 擦弹

    题目描述

    输入

    第一行是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];
    }
  • 相关阅读:
    8_python连接数据库
    7_数据类型
    Memcached delete 命令
    Memcached gets 命令
    Memcached get 命令
    Memcached CAS 命令
    Memcached prepend 命令
    Memcached append 命令
    Memcached replace 命令
    Memcached add 命令
  • 原文地址:https://www.cnblogs.com/Y-E-T-I/p/7050740.html
Copyright © 2011-2022 走看看