(C卷,200分)- 反射计数（Java & JS & Python & C）

题目描述

给定一个包含 0 和 1 的二维矩阵。

给定一个初始位置和速度，一个物体从给定的初始位置出发，在给定的速度下进行移动，遇到矩阵的边缘则发生镜面发射。

无论物体经过 0 还是 1，都不影响其速度。

请计算并给出经过 t 时间单位后，物体经过 1 点的次数。

矩阵以左上角位置为 [0, 0]（列(x)，行(y)），例如下面A点坐标为 [2, 1]（第二列，第一行）

注意：

1. 如果初始位置的点是 1，也计算在内
2. 时间的最小单位为 1，不考虑小于 1 个时间单位内经过的点

输入描述

第一行为初始信息

<w><h><x><y><sx><sy><t>

第二行开始一共 h 行，为二维矩阵信息

其中：

• w，h 为矩阵的宽和高
• x，y 为起始位置
• sx，sy 为初始速度
• t 为经过的时间

所有输入都是有效的，数据范围如下：

• 0 < w < 100
• 0 < h < 100
• 0 ≤ x < w
• 0 ≤ y < h
• -1 ≤ sx ≤ 1
• -1 ≤ sy ≤ 1
• 0 ≤ t ＜100

输出描述

经过 1 的个数

注意初始位置也要计算在内

用例

题目解析

题目运动示意图如下：

如果当前位置 x,y 按照速度 sx,sy 运动后，新位置越界的话，比如新位置x,y：

• x < 0

  注意 -1 ≤ sx, sy ≤ 1，因此 x < 0 越界时必然 x = -1, 则经过反射，x = 1

• x >= w

  注意 -1 ≤ sx, sy ≤ 1，因此 x >= w 越界时必然 x = w, 则经过反射，x = w – 2

• y < 0

  注意 -1 ≤ sx, sy ≤ 1，因此 y < 0 越界时必然 y = -1，则经过反射，y = 1

• y >= h​​​​​​​

  注意 -1 ≤ sx, sy ≤ 1，因此 y >= h 越界时必然 y = h，则经过反射，y = h – 2

还需要注意的是，反射不仅会影响位置，而且会影响和后续的速度方向：

• 一旦新位置x越界，则后续速度 sx = -sx
• 一旦新位置y越界，则后续速度 sy = -sy

我们只要记录运动路径中遇到的元素1的个数即可。

JS算法源码

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

void (async function () {
  // 注意本题横纵坐标是反的，因此y其实是行号，x是列号
  let [w, h, x, y, sx, sy, t] = (await readline()).split(" ").map(Number);

  const matrix = [];
  for (let i = 0; i < h; i++) {
    matrix.push(await readline());
  }

  let ans = 0;

  while (t >= 0) {
    if (matrix[y][x] == "1") {
      ans++;
    }

    y += sy;
    x += sx;

    if (x < 0) {
      x = 1;
      sx = -sx;
    } else if (x >= w) {
      //  注意本题横纵坐标是反的，因此x是列号，w是矩阵列数
      x = w - 2;
      sx = -sx;
    }

    if (y < 0) {
      y = 1;
      sy = -sy;
    } else if (y >= h) {
      //  注意本题横纵坐标是反的，因此y是行号，h是矩阵行数
      y = h - 2;
      sy = -sy;
    }

    t--;
  }

  console.log(ans);
})();

Java算法源码

import java.util.Scanner;

public class Main {

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

    int w = sc.nextInt();
    int h = sc.nextInt();
    int x = sc.nextInt();
    int y = sc.nextInt();
    int sx = sc.nextInt();
    int sy = sc.nextInt();
    int t = sc.nextInt();

    char[][] matrix = new char[h][w];
    for (int i = 0; i < h; i++) {
      matrix[i] = sc.next().toCharArray();
    }

    int ans = 0;

    while (t >= 0) {
      // 注意本题横纵坐标是反的，因此y其实是行号，x是列号
      if (matrix[y][x] == '1') {
        ans++;
      }

      y += sy;
      x += sx;

      if (x < 0) {
        x = 1;
        sx = -sx;
      } else if (x >= w) { //  注意本题横纵坐标是反的，因此x是列号，w是矩阵列数
        x = w - 2;
        sx = -sx;
      }

      if (y < 0) {
        y = 1;
        sy = -sy;
      } else if (y >= h) { //  注意本题横纵坐标是反的，因此y是行号，h是矩阵行数
        y = h - 2;
        sy = -sy;
      }

      t--;
    }

    System.out.println(ans);
  }
}

Python算法源码

# 输入获取
w, h, x, y, sx, sy, t = map(int, input().split())
matrix = [input() for _ in range(h)]


# 算法入口
def getResult():
    global x, y, sx, sy, t
    ans = 0

    while t >= 0:
        # 注意本题横纵坐标是反的，因此y其实是行号，x是列号
        if matrix[y][x] == '1':
            ans += 1

        y += sy
        x += sx

        if x < 0:
            x = 1
            sx = -sx
        elif x >= w:  # 注意本题横纵坐标是反的，因此x是列号，w是矩阵列数
            x = w - 2
            sx = -sx

        if y < 0:
            y = 1
            sy = -sy
        elif y >= h:  # 注意本题横纵坐标是反的，因此y是行号，h是矩阵行数
            y = h - 2
            sy = -sy

        t -= 1

    return ans


# 算法调用
print(getResult())

C算法源码

#include <stdio.h>

#define MAX_SIZE 100

int main() {
    int w, h, x, y, sx, sy, t;
    scanf("%d %d %d %d %d %d %d", &w, &h, &x, &y, &sx, &sy, &t);
    getchar();

    char matrix[MAX_SIZE][MAX_SIZE];
    for (int i = 0; i < h; i++) {
        gets(matrix[i]);
    }

    int ans = 0;

    while (t >= 0) {
        // 注意本题横纵坐标是反的，因此y其实是行号，x是列号
        if (matrix[y][x] == '1') {
            ans++;
        }

        y += sy;
        x += sx;

        if (x < 0) {
            x = 1;
            sx = -sx;
        } else if (x >= w) { //  注意本题横纵坐标是反的，因此x是列号，w是矩阵列数
            x = w - 2;
            sx = -sx;
        }

        if (y < 0) {
            y = 1;
            sy = -sy;
        } else if (y >= h) { //  注意本题横纵坐标是反的，因此y是行号，h是矩阵行数
            y = h - 2;
            sy = -sy;
        }

        t--;
    }

    printf("%dn", ans);

    return 0;
}