PAT（Basic Level）（四）-- Practice 1068 万绿丛中一点红

长路漫漫2021

已于 2022-10-24 19:08:16 修改

阅读量205

点赞数

分类专栏： LC and PAT 文章标签： PAT 1068 pat考试 python

于 2022-05-22 16:44:35 首次发布

本文链接：https://blog.csdn.net/xq151750111/article/details/124912527

版权

LC and PAT 专栏收录该内容

30 篇文章 10 订阅

订阅专栏

1 题目描述

1. 定义
对于计算机而言，颜色不过是像素点对应的一个 24 位的数值。现给定一幅分辨率为 M×N 的画，要求你找出万绿丛中的一点红，即有独一无二颜色的那个像素点，并且该点的颜色与其周围 8 个相邻像素的颜色差充分大。

2. 输入格式
输入第一行给出三个正整数，分别是 M 和 N（≤ 1000），即图像的分辨率；以及TOL，是所求像素点与相邻点的颜色差阈值，色差超过TOL的点才被考虑。随后 N 行，每行给出 M 个像素的颜色值，范围在 $0,2^{24})$ 内。所有同行数字间用空格或TAB分开。

3. 输出格式
在一行中按照 (x, y): color 的格式输出所求像素点的位置以及颜色值，其中位置 x 和 y 分别是该像素在图像矩阵中的列、行编号（从 1 开始编号）。如果这样的点不唯一，则输出Not Unique；如果这样的点不存在，则输出Not Exist。

2 思路分析

1. 问题分析

独一无二的颜色，这个含义是指，可能存在某个点，它的所有邻居点的像素都满足这个“色差”要求，但是这个点的像素（颜色）在整个矩阵中出现不止一次，那么它就不是独一无二的，因此这样的点不是目标点；
该点的颜色与其周围 8 个相邻像素的颜色差充分大（注意，如果是边上的点只需要比较 5 个点，角上的点只需要比较 3 个点）。

2. 求解思路

如何判断是否独一无二：创建字典，在输入数据的同时对每个颜色值统计次数，字典的键：值关系是，颜色值：出现的次数，这样检索较快，也不占用太大空间。
充分理解“色差”：在中间的点我们依次判断周围 8 个点即可，但是如何解决边角上的点？有两种简单的解决办法：（1）为四条边和四个角专门写特判；（2）在遍历 8 个点的同时判断坐标是否越界，如果超出数组范围则不判断，默认符合要求。

小技巧： 这里使用的方法是为数组加四条边，即原本 $N\times M$ 的矩阵扩充到 $(N+2)\times (M+2)$ 。且周围多出来的四条边以及四个角上的颜色都是0，这样在遍历八个点的时候就不用特别判断了，对所有的点一视同仁即可。同时，差值要加上绝对值再和TOL作比较。加边的同时带来了另一个微小的好处，就是数组的行和列都从 1 开始计数了，符合题目的输出要求。

综上，整个流程就是，先用字典记录每个颜色值出现的次数，然后对次数为1的像素点，遍历周围所有像素点并进行比较，而想要计算与周围的差值，就涉及该像素点是否在边界上，若是，则要小心数组越界导致段错误，为了避免这种麻烦，我们可以直接将数组四周扩大一圈，边界的值默认就是0，对符合条件的像素点记录，并进行结果的打印。下面的代码一使用嵌套列表实现，代码二使用数组实现，切片，元素查找都比较方便。

温馨提示：

如果将输入的颜色平铺成一位数组（N×M个数据），使用count方法会超时！原因是，对于每个点的遍历是 $O (N \times M)$ ，然而在这个 $N \times M$ 个数据的一位数组上利用count方法计数，则内层相当于又嵌套了 $O (N \times M)$ ，所以时间性能十分低下。
如果采用“以空间换时间”的策略，开 $2^{24}$ 的列表存储颜色值的出现次数，虽然时间复杂度降低了，但是这样会内存超限。
综上所述，字典在两者之间作出了平衡。

3 代码实现

AC代码一：

import sys

M, N, TOL = list(map(int, input().split()))
fill_lst = [0 for _ in range(M + 2)]
input_list = []
input_dict = {}
result_list = []
for k in range(N):
    temp_lst = list(map(int, sys.stdin.readline().split()))
    for k in range(M):
        if temp_lst[k] in input_dict:
            input_dict[temp_lst[k]] += 1
        else:
            input_dict[temp_lst[k]] = 1
    temp_lst.append(0)              # 在两端填充零
    temp_lst.insert(0, 0)
    input_list.append(temp_lst)
input_list.insert(0, fill_lst)      # 在上下填充零
input_list.append(fill_lst)
for i in range(1, N + 1):
    for j in range(1, M + 1):
        if input_dict[input_list[i][j]] == 1:
            low, high = i + 1, i - 1
            right, left = j + 1, j - 1
            length1 = abs(input_list[i][j] - input_list[low][left])     # 计算周围八个元素的差值绝对值
            length2 = abs(input_list[i][j] - input_list[low][j])
            length3 = abs(input_list[i][j] - input_list[low][right])
            length4 = abs(input_list[i][j] - input_list[i][left])
            length5 = abs(input_list[i][j] - input_list[i][right])
            length6 = abs(input_list[i][j] - input_list[high][left])
            length7 = abs(input_list[i][j] - input_list[high][j])
            length8 = abs(input_list[i][j] - input_list[high][right])
            if length1 > TOL and length2 > TOL and length3 > TOL and length4 > TOL and length5 > TOL and length6 > TOL and length7 > TOL and length8 > TOL:
                result_list.append('({}, {}): {}'.format(
                    j, i, input_list[i][j]))

length = len(result_list)
if length == 1:
    print(result_list[0])
elif length == 0:
    print('Not Exist')
else:
    print('Not Unique')

AC代码二：

import sys
import numpy as np

# 计算3*3矩阵中心元素和周围元素差值的最小值
def min_matrix(matrix):
    mid = matrix[1][1]
    distance = 16777215
    for i in range(0, 3):
        for j in range(0, 3):
            if i != 1 and j != 1:
                temp = abs(matrix[i][j] - mid)
                if temp < distance:
                    distance = temp
    return distance


def main():
    M, N, TOL = list(map(int, input().split()))
    input_list = []
    input_dict = {}
    result_list = []
    for _ in range(N):
        temp_lst = list(map(int, sys.stdin.readline().split()))
        input_list.append(temp_lst)
        for k in range(M):
            if temp_lst[k] in input_dict:
                input_dict[temp_lst[k]] += 1
            else:
                input_dict[temp_lst[k]] = 1

    input_array = np.array(input_list)
    input_array = np.pad(input_array, (1, 1), 'constant')   # 使用数组在外围填充一圈零

    for iter in input_dict:
        if input_dict[iter] == 1:
            index_i, index_j = np.where(input_array == iter)    # 返回所查找元素的索引，返回值为二维元组
            index_i, index_j = index_i[0], index_j[0]
            if min_matrix(input_array[index_i - 1:index_i + 2,
                                      index_j - 1:index_j + 2]) > TOL:
                result_list.append('({}, {}): {}'.format(
                    index_j, index_i, input_array[index_i][index_j]))

    length = len(result_list)
    if length == 1:
        print(result_list[0])
    elif length == 0:
        print('Not Exist')
    else:
        print('Not Unique')

main()