(C卷,100分)- 灰度图存储（Java & JS & Python & C）

在线OJ刷题

题目描述

黑白图像常采用灰度图的方式存储，即图像的每个像素填充一个灰色阶段值，256阶灰图是一个灰阶值取值范围为 0~255 的灰阶矩阵，0表示全黑，255表示全白，范围内的其他值表示不同的灰度。

但在计算机中实际存储时，会使用压缩算法，其中一个种压缩格式描述如如下：

10 10 255 34 0 1 255 8 0 3 255 6 0 5 255 4 0 7 255 2 0 9 255 21

1. 所有的数值以空格分隔；
2. 前两个数分别表示矩阵的行数和列数；
3. 从第三个数开始，每两个数一组，每组第一个数是灰阶值，第二个数表示该灰阶值从左到右，从上到下（可理解为二维数组按行存储在一维矩阵中）的连续像素个数。比如题目所述的例子， “255 34” 表示有连续 34 个像素的灰阶值是 255。

如此，图像软件在打开此格式灰度图的时候，就可以根据此算法从压缩数据恢复出原始灰度图矩阵。

请从输入的压缩数恢复灰度图原始矩阵，并返回指定像素的灰阶值。

输入描述

10 10 255 34 0 1 255 8 0 3 255 6 0 5 255 4 0 7 255 2 0 9 255 21
3 4

输入包行两行：

• 第一行是灰度图压缩数据
• 第二行表示一个像素位置的行号和列号，如 0 0 表示左上角像素

输出描述

0

输出数据表示的灰阶矩阵的指定像素的灰阶值。

备注

• 系保证输入的压缩数据是合法有效的，不会出现数据起界、数值不合法等无法恢复的场景
• 系统保证输入的像素坐标是合法的，不会出现不在矩阵中的像素
• 矩阵的行和列数范图为:(0,100]
• 灰阶值取值范图:[0,255]

用例

题目解析

用例1图示

用例2图示

因此，本题很简单，其实就是按照输入给定数量的灰阶值，顺序填充矩阵（从左到右，从上到下），最后返回矩阵指定坐标位置的灰阶值即可。

本题可以将 二维矩阵 一维化，这样填充按顺序填充指定数量的灰阶值时，就会更加方便。

本质上，二维数组在内存上也是一段连续的内存

用例1一维化图示：

如上图是，定义了一个10*10长度的一维数组，然后按顺序填充指定数量个灰阶值，最后要找的（3，4）二维坐标的灰阶值，对应到一维坐标为 3 * 列数 + 4，即 3 * 10 + 4 = 34 索引位置的灰阶值。

JS算法源码

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
  const nums = (await readline()).split(" ").map(Number);
  const [x, y] = (await readline()).split(" ").map(Number);

  const rows = nums[0];
  const cols = nums[1];

  const graph = new Array(rows * cols).fill(-1);

  let start = 0;
  for (let i = 2; i < nums.length; i += 2) {
    const gray = nums[i];
    const len = nums[i + 1];

    graph.fill(gray, start, start + len);
    start += len;
  }

  console.log(graph[x * cols + y]);
})();

Java算法源码

import java.util.Arrays;
import java.util.Scanner;

public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    int[] nums = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
    int[] pos = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();

    int rows = nums[0];
    int cols = nums[1];

    int[] graph = new int[rows * cols];

    int start = 0;

    for (int i = 2; i < nums.length; i += 2) {
      // 灰阶值
      int gray = nums[i];
      // 该灰阶值从左到右，从上到下（可理解为二维数组按行存储在一维矩阵中）的连续像素个数
      int len = nums[i + 1];
      Arrays.fill(graph, start, start + len, gray);
      start += len;
    }

    // 将二维坐标转为一维坐标
    int target = pos[0] * cols + pos[1];
    System.out.println(graph[target]);
  }
}

Python算法源码

# 输入获取
nums = list(map(int, input().split()))
x, y = map(int, input().split())


# 算法入口
def getResult():
    rows = nums[0]
    cols = nums[1]

    graph = [-1] * (rows * cols)

    start = 0
    for i in range(2, len(nums), 2):
        gray = nums[i]
        length = nums[i + 1]

        graph[start:start + length] = [gray] * length

        start += length

    return graph[x * cols + y]


# 算法调用
print(getResult())

C算法源码

#include <stdio.h>

int main() {
    int rows, cols;
    scanf("%d %d", &rows, &cols);

    int graph[rows * cols];
    int start = 0;

    int gray;
    int len;
    while (scanf("%d %d", &gray, &len)) {
        for (int i = start; i < start + len; i++) {
            graph[i] = gray;
        }

        start += len;

        if (getchar() != ' ') break;
    }

    int x, y;
    scanf("%d %d", &x, &y);

    printf("%dn", graph[x * cols + y]);

    return 0;
}