蓝桥杯2018年A组三体攻击题解

三体攻击

【题目描述】
三体人将对地球发起攻击。为了抵御攻击，地球人派出了 A × B × C 艘战舰，在太空中排成一个 A 层 B 行 C 列的立方体。其中，第 i 层第 j 行第 k 列的战舰（记为战舰 (i, j, k)）的生命值为 d(i, j, k)。

三体人将会对地球发起 m 轮“立方体攻击”，每次攻击会对一个小立方体中的所有战舰都造成相同的伤害。具体地，第 t 轮攻击用 7 个参数 lat, rat, lbt, rbt, lct, rct, ht 描述；
所有满足 i ∈ [lat, rat],j ∈ [lbt, rbt],k ∈ [lct, rct] 的战舰 (i, j, k) 会受到 ht 的伤害。如果一个战舰累计受到的总伤害超过其防御力，那么这个战舰会爆炸。

地球指挥官希望你能告诉他，第一艘爆炸的战舰是在哪一轮攻击后爆炸的。

【输入格式】
从标准输入读入数据。
第一行包括 4 个正整数 A, B, C, m；
第二行包含 A × B × C 个整数，其中第 ((i − 1)×B + (j − 1)) × C + (k − 1)+1 个数为 d(i, j, k)；
第 3 到第 m + 2 行中，第 (t − 2) 行包含 7 个正整数 lat, rat, lbt, rbt, lct, rct, ht。

【输出格式】
输出到标准输出。
输出第一个爆炸的战舰是在哪一轮攻击后爆炸的。保证一定存在这样的战舰。

【样例输入】

2 2 2 3
1 1 1 1 1 1 1 1
1 2 1 2 1 1 1
1 1 1 2 1 2 1
1 1 1 1 1 1 2

【样例输出】

2

【样例解释】
在第 2 轮攻击后，战舰 (1,1,1) 总共受到了 2 点伤害，超出其防御力导致爆炸。

【数据约定】
对于 10% 的数据，B = C = 1；
对于 20% 的数据，C = 1；
对于 40% 的数据，A × B × C, m ≤ 10, 000；
对于 70% 的数据，A, B, C ≤ 200；
对于所有数据，A × B × C ≤ 10^6, m ≤ 10^6, 0 ≤ d(i, j, k), ht ≤ 10^9。

题目思路
对于数据，可以理解为一个立体矩形体

——初出茅庐——

第一次我们采用暴力法，首先想到的就是四重循环逐次将飞船进攻。当出现有飞船损毁时，我们便直接返回。

#include<iostream>
using namespace std;
int A,B,C,m;
int main(){
    cin>>A>>B>>C>>m;
    int a[A][B][C][m],b[m+1][7];
    int i,j,k,n;
    for(i=0;i<A;i++)
        for(j=0;j<B;j++)
            for(k=0;k<C;k++)
                cin>>a[i][j][k][0];
    for(n=1;n<=m;n++)
        for(i=0;i<7;i++)
            cin>>b[n][i];
    for(n=1;n<=m;n++){
        int x1,x2,y1,y2,z1,z2,k;
        x1=b[n][0]-1;x2=b[n][1];
        y1=b[n][2]-1;y2=b[n][3];
        z1=b[n][4]-1;z2=b[n][5];
        k=b[n][6];
        for(;x1<x2;x1++)
            for(;y1<y2;y1++)
                for(;z1<z2;z1++){
                    a[x1][y1][z1][n]=a[x1][y1][z1][n-1]-k;
                    if(a[x1][y1][z1][n]<0){
                        cout<<n<<endl;
                        return 0;
                    }
                }
    }
    return 0;
}

——炉火纯青——

思路：对于这种这4个循环，我们能够简化的似乎只有攻击次数，因为对于这个三维空间的我们不可能做到只打击二维。所以首先需要减少攻击的次数。将他的及时检验飞船状态改成段时间检测。
这里我采用的思路是用二分法
如果检测时飞船以出现损毁，那么第一个飞船的损坏一定出现在我们上一次检测和这一次检测之中，直到检测出第一个飞船的损坏。
但是二分法只能将我们的时间复杂度从O(n⁴)变成O(n³log(n))的时间复杂度，对于大量数据而言这样的时间复杂度还是过大，那么我们必须用另外一种方式来减少前面O(n³)的时间复杂度。
想要解决这种方法最好的效果是将O(N)的时间复杂度转换为O(1)；
加分
而提到将O(N)的时间复杂度转换为O(1)我们就能够想到一种加分的方法，可以用O(1)的方法来处理对于N个数求和的问题，但是加分的缺点也很明显，每次修改完其中的数值的时候都需要我们重新去更新，而更新的时间又是O(N)。
此题不同于加分，我们需要修改一段区域内的值，而且是我们用O(1)的时间。
我们可以理解为加分的逆运用。想到这里我们的思路就出现了。
差分
我们将加分的方式整个的倒过来运用。
假如说这里有一组一维数组
我们用加分的方式来对一段数据求和

1	2	3	4	5	6	7
1	2	3	4	5	6	7

我们将每一项的值都讲上前面的一项

1	2	3	4	5	6	7
1	3	6	10	15	21	28

那么我们便能够通过O(1)的时间来直接得出前面的和，也可以求一个区间的值的和
a_i到a_j的值就等于a_j - a_i。
我们将这种思路反过来运用
还是这样一个一维数组

1	2	3	4	5	6	7
0	0	0	0	0	0	0

我们将他们的初值都设为0
如果我们想要将2-5之间的值全部加一

1	2	3	4	5	6	7
0	1	0	0	0	-1	0

我们将他们的值直接修改，然后还是每一项的值等于他本身加上前面的值
修改完后数组的值便变成了

1	2	3	4	5	6	7
0	1	1	1	1	0	0

通过这种方法，我们便能够通过O(1)的时间来修改N个数字，但是每次修改完都后需要O(N)的时间来更新我们的表，所以我们要尽量减少更新的次数。
对于此题，我们需要将差分的一维运用转换为三维。这就需要我们用自己的想象力了。
有兴趣的同学可以自行想象一下。

完整代码

#include<bits/stdc++.h>
#define _for(i,a,b) for(int i=a;i<b;i++)
using namespace std;
const int N=2e6;
int A,B,C,M;
struct xy{
    int x1,y1,z1,x2,y2,z2,t;
}T[N];
int s[N],c[N];
void xg(int ff,int l,int f)
{
    for(l++;l<=f;l++)
    {
        int x1=T[l].x1,x2=T[l].x2,y1=T[l].y1,y2=T[l].y2,z1=T[l].z1,z2=T[l].z2,t=ff*T[l].t;
        c[x1*B*C+y1*C+z1]+=t;
        c[(x2+1)*B*C+y1*C+z1]-=t;
        c[x1*B*C+(y2+1)*C+z1]-=t;
        c[x1*B*C+y1*C+z2+1]-=t;
        c[(x2+1)*B*C+(y2+1)*C+z1]+=t;
        c[(x2+1)*B*C+y1*C+(z2+1)]+=t;
        c[x1*B*C+(y2+1)*C+z2+1]+=t;
        c[(x2+1)*B*C+(y2+1)*C+z2+1]-=t;
    }
    _for(i,1,A+1)
        _for(j,1,B+1)
            _for(k,1,C+1)
                c[i*B*C+j*C+k]+=c[(i-1)*B*C+j*C+k]+c[i*B*C+(j-1)*C+k]+c[i*B*C+j*C+k-1]-c[(i-1)*B*C+(j-1)*C+k]-c[(i-1)*B*C+j*C+k-1]-c[i*B*C+(j-1)*C+k-1]+c[(i-1)*B*C+(j-1)*C+k-1];
}
int main()
{
    std::ios::sync_with_stdio(false);cin.tie(nullptr);
    cin>>A>>B>>C>>M;
    _for(i,1,A+1)
        _for(j,1,B+1)
            _for(k,1,C+1)
                cin>>s[i*B*C+j*C+k];
    _for(i,1,M+1)
        cin>>T[i].x1>>T[i].x2>>T[i].y1>>T[i].y2>>T[i].z1>>T[i].z2>>T[i].t;
    int l=0,f=M,fast=0;
    while(l<=f)
    {
        int cnt=(l+f)>>1;
        bool p=1;
        memset(c,0,sizeof(c));
        if(fast<=cnt)
            xg(-1,fast,cnt);
        else
            xg(1,cnt,fast);
        _for(i,1,A+1)
            _for(j,1,B+1)
                _for(k,1,C+1){
                    s[i*B*C+j*C+k]+=c[i*B*C+j*C+k];
                    if(s[i*B*C+j*C+k]<0)
                        p=0;
                }
        if(p)
            l=cnt+1;
        else
            f=cnt-1;
        fast=cnt;
    }
    cout<<l;
}

题目转自蓝桥杯2018年C++ A组。