(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 的个数

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

用例

输入	12 7 2 1 1 -1 13 001000010000 001000010000 001000010000 001000010000 001000010000 001000010000 001000010000
输出	3
说明	初始位置为（2,1），速度为（1,-1），那么13个时间单位后，经过点1的个数为3

题目解析

题目运动示意图如下：

当物体以速度(sx,sy)从位置(x,y)移动后，若新位置超出边界，则按以下规则处理：

1. 水平边界检测（x坐标）：

   • 当x < 0时（此时x必为-1）：
     • 反射后位置：x = 1
     • 速度反转：sx = -sx
   • 当x ≥ w时（此时x必为w）：
     • 反射后位置：x = w-2
     • 速度反转：sx = -sx

2. 垂直边界检测（y坐标）：

   • 当y < 0时（此时y必为-1）：
     • 反射后位置：y = 1
     • 速度反转：sy = -sy
   • 当y ≥ h时（此时y必为h）：
     • 反射后位置：y = h-2
     • 速度反转：sy = -sy

注：速度分量sx和sy的取值范围均为[-1,1]。我们只需统计运动路径中遇到的元素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("%d\n", ans);

    return 0;
}