知道矩阵下落的时候 开始位置和最后位置怎么计算

Question

public int[][] fallMatrixs() {
        logger.info("下落之前~~~"+bonusList +"第几个矩阵·····"+matrixs.size());
        int[][] tempMatrix = new int[row][col];
        for (int i = matrix[0].len*** - 1; i >= 0; i--) {
            int index = row - 1;
            for (int j = matrix.len*** - 1; j >= 0; j--) {
                    if (matrix[j][i] != 0) {
                        tempMatrix[index--][i] = matrix[j][i];
                    }
            }
        }
        return tempMatrix;
    }
 需求: 底部有0就会依次往下掉，底向上查找非零元素，将其依次往下掉，我想知道4id素材往下落的时候最后是掉落在哪个位置，帮我改一下代码，我想要LIst存储开始位置和最后落到底部的那个位置，假设矩阵现在是这样，这3个司都会掉下去 ，开始位置是start=[4_0,3_2,4_2],每一个4都只有一个最终位置,我希望能找到最终位置怎么改代码
2,     0,       0,       0,    0,    0
109, 131, 113, 109, 131, 109
109, 131, 113, 109, 131, 109
139, 139, 4,   139, 139, 139
4,   139, 4,   139, 127, 127
0,   139, 0,   113, 127, 127
109, 131, 113, 109, 131, 109

Answer 1

以下内容由CHATGPT及阿里嘎多学长共同生成、有用望采纳：

---

根据您提供的代码和需求，您想要实现的是一个矩阵中的元素在遇到0时向下掉落的逻辑，并且记录每个元素的起始位置和最终位置。下面是对您提供的代码进行修改和补充，以实现这个功能：

1. 首先，我们需要一个方法来记录每个非零元素的起始位置。
2. 然后，实现下落逻辑，记录每个元素的最终位置。
3. 最后，将起始位置和最终位置存储在一个List中。

以下是修改后的Java代码示例：

import java.util.ArrayList;
import java.util.List;
import java.util.logging.Logger;

public class MatrixFaller {
    private static final Logger logger = Logger.getLogger(MatrixFaller.class.getName());
    private int[][] matrix;
    private int row; // 矩阵的行数
    private int col; // 矩阵的列数
    private List<int[]> startPositions; // 存储起始位置
    private List<int[]> endPositions; // 存储最终位置

    public MatrixFaller(int[][] matrix) {
        this.matrix = matrix;
        this.row = matrix.length;
        this.col = matrix[0].length;
        this.startPositions = new ArrayList<>();
        this.endPositions = new ArrayList<>();
    }

    public void recordStartPositions() {
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (matrix[i][j] != 0) {
                    startPositions.add(new int[]{i, j});
                }
            }
        }
    }

    public List<int[]> fallMatrixs() {
        logger.info("下落之前~~~" + startPositions);
        int[][] tempMatrix = new int[row][col];
        for (int i = 0; i < row; i++) {
            int index = 0;
            for (int j = 0; j < col; j++) {
                if (matrix[i][j] != 0) {
                    while (index < j && matrix[i][index] == 0) {
                        index++;
                    }
                    tempMatrix[i][index++] = matrix[i][j];
                    endPositions.add(new int[]{i, index - 1});
                }
            }
        }
        return endPositions;
    }

    public static void main(String[] args) {
        int[][] matrix = {
            {2, 0, 0, 0, 0, 0},
            {109, 131, 113, 109, 131, 109},
            {109, 131, 113, 109, 131, 109},
            {139, 139, 4, 139, 139, 139},
            {4, 139, 4, 139, 127, 127},
            {0, 139, 0, 113, 127, 127},
            {109, 131, 113, 109, 131, 109}
        };

        MatrixFaller faller = new MatrixFaller(matrix);
        faller.recordStartPositions();
        List<int[]> endPositions = faller.fallMatrixs();
        logger.info("起始位置: " + faller.startPositions);
        logger.info("最终位置: " + endPositions);
    }
}

这段代码首先定义了一个MatrixFaller类，它包含了记录起始位置和下落逻辑的方法。recordStartPositions方法会记录所有非零元素的起始位置，而fallMatrixs方法则实现了下落逻辑，并记录了每个元素的最终位置。在main方法中，我们创建了一个MatrixFaller实例，并调用这些方法来获取起始位置和最终位置的列表。

请注意，这个示例代码假设矩阵中的元素在遇到0时会立即下落，并且每个元素只会下落到最近的上方非零元素的下方。如果矩阵的下落规则有所不同，您可能需要根据具体情况调整下落逻辑。