CSP 202206-2

如风的少年-

已于 2023-03-09 16:43:55 修改

阅读量198

点赞数

分类专栏： PAT 挑战程序设计文章标签：算法

于 2023-03-05 22:20:49 首次发布

本文链接：https://blog.csdn.net/qq_45806136/article/details/129351950

版权

PAT 同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

挑战程序设计

2 篇文章 0 订阅

订阅专栏

寻宝！大冒险！
题目链接

题目背景

暑假要到了。可惜由于种种原因，小 P 原本的出游计划取消。失望的小 P 只能留在西西艾弗岛上度过一个略显单调的假期……直到……

某天，小 P 获得了一张神秘的藏宝图。

问题描述

西西艾弗岛上种有 n 棵树，这些树的具体位置记录在一张绿化图上。简单地说，西西艾弗岛绿化图可以视作一个大小为 (L+1)×(L+1) 的 01 矩阵 A，地图左下角（坐标 (0,0)）和右上角（坐标 (L,L)）分别对应 A[0] [0] 和 A[L] [L]。其中 A[i] [j]=1 表示坐标 (i,j) 处种有一棵树，A[i] [j]=0 则表示坐标 (i,j) 处没有树。换言之，矩阵 A 中有且仅有的 n 个 1 展示了西西艾弗岛上 n 棵树的具体位置。

传说，大冒险家顿顿的宝藏就埋藏在某棵树下。并且，顿顿还从西西艾弗岛的绿化图上剪下了一小块，制作成藏宝图指示其位置。具体来说，藏宝图可以看作一个大小为 (S+1)×(S+1) 的 01 矩阵 B（S 远小于 L），对应着 A 中的某一部分。理论上，绿化图 A 中存在着一处坐标 (x,y)（0≤x,y≤L−S）与藏宝图 B 左下角 (0,0) 相对应，即满足：对 B 上任意一处坐标 (i,j)（0≤i,j≤S），都有 A[x+i] [y+j]=B[i] [j]。当上述条件满足时，我们就认为藏宝图 B 对应着绿化图 A 中左下角为 (x,y)、右上角为 (x+S,y+S) 的区域。

实际上，考虑到藏宝图仅描绘了很小的一个范围，满足上述条件的坐标 (x,y) 很可能存在多个。请结合西西艾弗岛绿化图中 n 棵树的位置，以及小 P 手中的藏宝图，判断绿化图中有多少处坐标满足条件。

特别地，藏宝图左下角位置一定是一棵树，即 A[x][y]=B[0][0]=1，表示了宝藏埋藏的位置。

输入格式

从标准输入读入数据。

输入的第一行包含空格分隔的三个正整数 n、L 和 S，分别表示西西艾弗岛上树的棵数、绿化图和藏宝图的大小。

由于绿化图尺寸过大，输入数据中仅包含 n 棵树的坐标而非完整的地图；即接下来 n 行每行包含空格分隔的两个整数 x 和 y，表示一棵树的坐标，满足 0≤x,y≤L 且同一坐标不会重复出现。

最后 (S+1) 行输入小 P 手中完整的藏宝图，其中第 i 行（0≤i≤S）包含空格分隔的 (S+1) 个 0 和 1，表示 B[S−i][0]⋯B[S−i][S]。需要注意，最先输入的是 B[S][0]⋯B[S][S] 一行，B[0][0]⋯B[0][S] 一行最后输入。

输出格式

输出到标准输出。

输出一个整数，表示绿化图中有多少处坐标可以与藏宝图左下角对应，即可能埋藏着顿顿的宝藏。

样例 1 输入

样例 1 输出

样例 1 解释

绿化图上 (0,0)、(1,1) 和 (2,2) 三处均可能埋有宝藏。

样例 2 输入

样例 2 输出

样例 2 解释
如果将藏宝图左下角与绿化图(3, 3)处对应，则藏宝图右上角会超出绿化图边界，对应不成功。

在这里插入图片描述

（1）按照题意进行模拟

由于藏宝图左下角位置一定是一棵树，即 A[x][y]=B[0][0]=1，表示了宝藏埋藏的位置。，那么我们只需要将所有的树的位置(x, y)都在藏宝图（0,0）处进行枚举即可，时间复杂度O(n * S * S)，时间复杂度在 $2.5 * 10 ^ 6$

#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;

const int MAXN = 2010, MAXM = 50;
int n, L, S, A[MAXN][MAXN], B[MAXM][MAXM];
vector<vector<int>> trees;

bool judge(int x, int y){
    //enum tree's position (x, y) put in B[0][0]
    for (int i = 0; i <= S; i++){ 
        for (int j = 0; j <= S; j++){
            if (i+x > L || j+y > L) 
                return false;
            if (A[i+x][j+y] != B[i][j])
                return false;
        }
    }
    return true;
}

int main(){
    cin >> n >> L >> S;
    for (int i = 1; i <= n; i++){
        int x, y;
        cin >> x >> y;
        A[x][y] = 1; //i-th tree's position
        trees.push_back({x, y});
    }

    for (int i = S; i >= 0; i--){
        for (int j = 0; j <= S; j++)
            cin >> B[i][j];
    }

    int res = 0;
    for (vector<int> tree : trees){
        int x = tree[0], y = tree[1];
        if (judge(x, y))
            res++;
    }
    cout << res << endl;
    return 0;
}

提交之后发现只能通过70%的用例，回到题目中发现 $\leq 10^9$ ，显然利用二维数组进行存储肯定是不可取的

利用map来优化空间

对于上述问题，时间复杂度在可以接受的范围之内，但我们开不了 $10^9 * 10^9$ 的二维数组，但是题目中绿化图中树的数量n<=1000，我们只需要存储每棵树所在的位置，而其他的位置上必然就是0（没有树）

#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;

const int MAXM = 60;
int n, L, S, B[MAXM][MAXM];
map<vector<int>, bool> mp;

bool judge(int x, int y){
    //enum tree's position (x, y) put in B[0][0]
    for (int i = 0; i <= S; i++){ 
        for (int j = 0; j <= S; j++){
            if (x+i > L || y+j > L)
                return false;
            if (mp.find({x+i, y+j}) == mp.end() && B[i][j] == 0){
                continue;
            }else if (mp.find({x+i, y+j}) != mp.end() && B[i][j])
                continue;
            else
                return false;
        }
    }
    return true;
}

int main(){
    cin >> n >> L >> S;
    for (int i = 1; i <= n; i++){
        int x, y;
        cin >> x >> y;
        mp[{x, y}] = true;
    }

    for (int i = S; i >= 0; i--){
        for (int j = 0; j <= S; j++)
            cin >> B[i][j];
    }
    
    int res = 0;
    for (auto it = mp.begin(); it != mp.end(); it++){
        vector<int> pos = it->first;
        if (judge(pos[0], pos[1]))
            res++;
    }
    
    cout << res << endl;

    return 0;
}

注意

在上述只能用map来优化空间复杂度，而不能使用unordered_map来存储树的位置上

在C++中，map和unordered_map都是关联容器，用于存储键值对，即将一个键与一个值相关联。它们之间的主要区别在于它们的实现方式和性能特征。

map是一个基于红黑树实现的关联容器，它会对键进行排序，并且支持有序遍历。它的优点是在有序的情况下可以快速进行查找、插入和删除操作，时间复杂度为O(log n)。但是，由于需要对键进行排序，所以在插入和删除元素时，需要对整个红黑树进行重排，性能相对较低。
map可以将任意的STL容器映射到其他STL容器中（包括string类型）

而unordered_map是一个基于哈希表实现的关联容器，它使用哈希函数将键映射到桶中，然后在桶中进行查找。它的优点是在无序的情况下可以快速进行查找、插入和删除操作，时间复杂度为O(1)。但是，由于哈希表需要处理哈希冲突，因此在处理大量数据时可能会导致性能下降。同时，unordered_map不支持有序遍历。

因此，如果需要在有序的情况下进行查找、插入和删除操作，应该选择map；如果不需要有序遍历，但需要快速的查找、插入和删除操作，则应该选择unordered_map。

并没有unordered_map<vector<int>, int>的类型

因为
在C++中，unordered_map是基于哈希表实现的，因此它的键类型必须满足以下要求：

支持哈希函数计算；
支持相等运算符（==）比较。

而vector类型不满足以上两个要求，因此不能作为unordered_map的键类型。

vector类型不支持哈希函数计算，因为哈希函数需要将键映射到桶中，如果键无法进行哈希函数计算，则无法使用哈希表实现。而vector类型的元素是可变长的，因此无法确定一个确定的哈希函数。

另外，vector类型也不支持相等运算符（==）比较，因为vector类型是一个复合类型，需要对其中的每一个元素进行比较。但是，C++中并没有为vector类型定义相等运算符（==），因此无法直接进行比较。

因此，如果需要使用vector类型作为unordered_map的键类型，可以自定义哈希函数和相等运算符。但是这需要花费一定的时间和精力，并且需要确保自定义的哈希函数和相等运算符能够正确地处理vector类型的键。

如风的少年-

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
CSP 202206-2

，因此无法直接进行比较。因此，如果需要使用vector类型作为unordered_map的键类型，可以自定义哈希函数和相等运算符。但是这需要花费一定的时间和精力，并且需要确保自定义的哈希函数和相等运算符能够正确地处理vector类型的键。
复制链接

扫一扫