返回目录

题目描述

给定一个包含 0 和 1 的二维矩阵，给定一个初始位置和速度，一个物体从给定的初始位置触发, 在给定的速度下进行移动, 遇到矩阵的边缘则发生镜面反射。

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

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

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

+--------------------------- 递增(x)
| 0 0 1 0 0 0 0 1 0 0 0 0
| 0 0 1 0 0 0 0 1 0 0 0 0
| 0 0 1 0 0 0 0 1 0 0 0 0
| 0 0 1 0 0 0 0 1 0 0 0 0
| 0 0 1 0 0 0 0 1 0 0 0 0
| 0 0 1 0 0 0 0 1 0 0 0 0
| 0 0 1 0 0 0 0 1 0 0 0 0
|
递增(y)

注意:

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

输入描述

第一行为初始信息

第二行开始一共 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 的个数

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

示例：

解题思路

1. 模拟运动：首先初始化一个计数器 count，并将物体的初始位置的值（即 matrix[y][x]）加到计数器上。然后，进入一个循环，每次循环模拟一个时间单位的运动。

   • 移动物体：在每个时间单位内，根据物体的速度 (sx, sy)移动物体，即更新物体的位置 (x, y)。
   • 处理反射：如果物体移动后到达了二维矩阵的边界（即 x等于0或 w-1，或者 y等于0或 h-1），则改变物体的方向，即反转速度的相应分量。
   • 更新计数器：如果物体移动后的位置是1，即 matrix[y][x]等于1，则将该值加到计数器上。

Python算法源码

# 计算物体在移动过程中经过的1的数量的函数
def count_ones(w, h, x, y, sx, sy, t, matrix):
    count = matrix[y][x]
    while t > 0:
        x += sx
        y += sy

        # 如果物体撞到左右边界，反转x轴方向速度分量
        if x == 0 or x == w - 1:
            sx = -sx
        # 如果物体撞到上下边界，反转y轴方向速度分量
        if y == 0 or y == h - 1:
            sy = -sy

        # 每次移动后，如果新位置是1，则累加到计数器
        count += matrix[y][x]
        t -= 1
    return count

if __name__ == "__main__":
    w, h, x, y, sx, sy, t = map(int, input().split())
    matrix = []

    for _ in range(h):
        row = list(map(int, input()))
        matrix.append(row)

    print(count_ones(w, h, x, y, sx, sy, t, matrix))

C算法源码

#include <stdio.h>
#include <stdlib.h>

// 计算物体在移动过程中经过的1的数量的函数
int countOnes(int w, int h, int x, int y, int sx, int sy, int t, int **matrix) {
    int count = matrix[y][x];
    while (t-- > 0) {
        x += sx;
        y += sy;

        // 如果物体撞到左右边界，反转x轴方向速度分量
        if (x == 0 || x == w - 1) sx = -sx;
        // 如果物体撞到上下边界，反转y轴方向速度分量
        if (y == 0 || y == h - 1) sy = -sy;

        // 每次移动后，如果新位置是1，则累加到计数器
        count += matrix[y][x];
    }
    return count;
}

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);
    int **matrix = (int **)malloc(h * sizeof(int *));
    for (int i = 0; i < h; ++i) {
        matrix[i] = (int *)malloc(w * sizeof(int));
    }

    for (int i = 0; i < h; ++i) {
        for (int j = 0; j < w; ++j) {
            char ch;
            scanf(" %c", &ch);
            matrix[i][j] = ch - '0';
        }
    }

    printf("%d\n", countOnes(w, h, x, y, sx, sy, t, matrix));

    // 释放动态分配的内存
    for (int i = 0; i < h; ++i) {
        free(matrix[i]);
    }
    free(matrix);

    return 0;
}

Java算法源码

import java.util.Scanner;

public class Main {
    // 计算物体在移动过程中经过的1的数量的函数
    static int countOnes(int w, int h, int x, int y, int sx, int sy, int t, int[][] matrix) {
        int count = matrix[y][x];
        while (t-- > 0) {
            x += sx;
            y += sy;

            // 如果物体撞到左右边界，反转x轴方向速度分量
            if (x == 0 || x == w - 1) sx = -sx;
            // 如果物体撞到上下边界，反转y轴方向速度分量
            if (y == 0 || y == h - 1) sy = -sy;

            // 每次移动后，如果新位置是1，则累加到计数器
            count += matrix[y][x];
        }
        return count;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int w = scanner.nextInt();
        int h = scanner.nextInt();
        int x = scanner.nextInt();
        int y = scanner.nextInt();
        int sx = scanner.nextInt();
        int sy = scanner.nextInt();
        int t = scanner.nextInt();
        int[][] matrix = new int[h][w];

        for (int i = 0; i < h; ++i) {
            String line = scanner.next();
            for (int j = 0; j < w; ++j) {
                char ch = line.charAt(j);
                matrix[i][j] = Character.getNumericValue(ch);
            }
        }

        System.out.println(countOnes(w, h, x, y, sx, sy, t, matrix));
    }
}