7行6列矩阵，因为第一行和最后一行是假像，，中奖几行才算中奖 ，但是第一行和最后一行也给假象 ，因为在下落的时候第一行会受影响

Question

    public void matrixMAHJONG(int[][] resultMatrix,List<ModuleGameOdds> materials, int freeNum) {
        if (resultMatrix != null) {
            matrix = fallMatrixs(); //下落方法
        } else {
            matrixEmptyNum = row * col;
            matrix = new int[row][col];
        }
        Map<Integer, Integer> materialMap = getMaterialMapSGXC(materials,matrixEmptyNum, freeNum);//偶尔指定出素材id的数量放中间几行
        List<SlotResultParam> paramList = new ArrayList<SlotResultParam>();

        logger.info("-----------emptyNum=" + matrixEmptyNum + ",map="
                + materialMap);
        for (Integer i : materialMap.keySet()) {
            int materialNum = materialMap.get(i);
            int num = dataMap.get(i) == null ? 0 : dataMap.get(i);
            if (matrixEmptyNum < materialNum) {
                materialNum = matrixEmptyNum;
            }
            if (i == GameMaterialConstant.GAME_SPECIAL_MATERIAL_2) {
                freeNum -= materialNum;
            }
            SlotResultParam materialParam = new SlotResultParam(i, materialNum,new int[] { 0, 1, 2, 3, 4, 5 }, row);
            paramList.add(materialParam);
            dataMap.put(i, materialNum + num);
            matrixEmptyNum -= materialNum;
        }
        matrix = createSlotResult(paramList, GameConstant.GAME_PLAY_TYPE_MAHJONG);
        logger.info("----------dataMap=" + dataMap + ",matrixEmptyNum="+ matrixEmptyNum);
        // 普通素材
        List<Integer> list = new ArrayList<Integer>();
        list.add(GameMaterialConstant.GAME_NORMAL_MATERIAL_101);
        list.add(GameMaterialConstant.GAME_NORMAL_MATERIAL_103);
        list.add(GameMaterialConstant.GAME_NORMAL_MATERIAL_107);
        list.add(GameMaterialConstant.GAME_NORMAL_MATERIAL_109);
        list.add(GameMaterialConstant.GAME_NORMAL_MATERIAL_113);
        list.add(GameMaterialConstant.GAME_NORMAL_MATERIAL_127);
        list.add(GameMaterialConstant.GAME_NORMAL_MATERIAL_131);
        list.add(GameMaterialConstant.GAME_NORMAL_MATERIAL_137);
        list.add(GameMaterialConstant.GAME_NORMAL_MATERIAL_139);
        for (int j = 0; j < col; j++) { //只放在中间几行
            for (int i = 1; i < row-1 ; i++) {
                if (matrix[i][j] == 0) {
                    int materia = list.get(random.nextInt(list.size()));
                    if (!materialMap.containsKey(materia)) {
                        if (dataMap.get(materia) != null) {
                            if (dataMap.get(materia) < 7) {
                                matrix[i][j] = materia;
                                dataMap.put(materia, dataMap.get(materia) + 1);
                            } else {
                                i--;
                            }
                        } else {
                            matrix[i][j] = materia;
                            dataMap.put(materia, 1);
                        }
                    } else {
                        i -= 1;
                    }
                }
            }
        }
        
        matrixEmptyNum = 0;

         //System.out.println("=============打印矩阵===============");
        for (int i = 0; i < matrix.length; i++) {
            List<Integer> cardList = new ArrayList<Integer>();
            for (int j = 0; j < matrix[i].length; j++) {
                cardList.add(matrix[i][j]);
                 System.out.print(matrix[i][j]+"\t");
            }
            matrixList.add(cardList);
             System.out.println();
        }
        matrixs.add(fuzhiMatrix(matrix));
        logger.info("dataMap=" + dataMap);

        Map<Integer, Integer> tempMap = new HashMap<Integer, Integer>();
        for (Integer id : dataMap.keySet()) {
            if (dataMap.get(id) > 7) {
                matrixEmptyNum += dataMap.get(id);
                tempMap.put(id, dataMap.get(id));
                // 删除矩阵里这个素材
                removeMaterial(matrix, id);
                dataMap.put(id, 0);
            }
        }
        if (tempMap.size() > 0) {
            materialNumMap.add(tempMap);
            logger.info("materialNumMap=" + materialNumMap);
            matrixMAHJONG(matrix, materials, freeNum);//落下然后超过八个会产生消消，所以再次调用这个方法重新又生成一个矩阵
        }
    }



需求:  1.7*6，我想处理一下这个矩阵matrix，以上代码我是先把中间几行全部塞了普通素材
               2. 首先想单独处理一下第一行和最后面一行,然后第一列和最后一列加起来是有12个格子，这个时候第一行和最后一行也是随机放普通素材，随机放很多种情况放第一行和最后一行
               3.第一种情况放 中间如果有普通素材一个都没出现，就把没出现的普通素材随机放1~2个在第一行或者最后一行，可以第一行放两个最后一行一个 这个看着随便来，
               4. 第二种情况不管有几个素材是中间没有出现过的，如果有一两种素材中间都没出现过，那就随机放1~3个在第一行或者最后一行，尽量第一行和最后一行不要放的太频繁
                 3.还有一种情况放的素材 就是找一下中间几行有没有普通素材数量是不是在6个范围内的，如果是的话那我就把找到几种素材在6个范围内 的，假设101在中间几行的矩阵里面只有2个 少于6个，那我就可以
                 挑101 补在第一行放一个 最后一行放一个，这样还是少于6  就可以，不要超过就可以，然后第一行和最后一行还是有格子还没放，那就找其他素材是不是还少于6个数量的  ，
                 就这样随机补，帮我改一下代码 中文解释 中文详细注释 中文解释每句代码
                 5.我中间行的代码不要动，



示范一下我想要的矩阵，

没填充之前:                 
0  0  0  0  0  0  
103 1 101 101 127 103  
101 101 107 131 131 131  
101 109 127 103 103 139  
107 127 101 131 131 107  
109 127 107 103 127 103 
0  0  0  0  0  0  

 这个我现在发现中间填充完之后，113在中间没有出现过 这样我就可以安排2~3个，第一行放1个 最后一行放两个，137在中间没有出现过 这样我就可以安排2~3个，第一行放1个 最后一行放一个，
 然后再去找中间的素材有没有少于6个的，我发现109在中间几行就出现了2个 ，在6个范围内  那我就又可以在第一行放1个 最后一行放一个，注意位置也是随机选，
 然后继续找，我发现139在在中间几行就出现了1个 ，在6个范围内 ，那我就又可以在第一行放1个 最后一行放2个，再继续找发现107 在中间几行只有四个，在6个范围内 就在第一行放两个
填充之后:
113  107  107  139  109  137  
103   1   101  101  127  103  
101 101  107  131   131  131  
101 109  127  103  103   139  
107 127  101  131  131  107  
109 127  107  103  127  103 
113  139 113  139  109  137 

Answer 1

你好，理解你的需求，若有用还望采纳：

public void matrixMAHJONG(int[][] resultMatrix, List<ModuleGameOdds> materials, int freeNum) {
    // ... 省略之前的初始化和中间行列填充逻辑 ...

    // 定义需要补充的普通素材列表
    List<Integer> needSupplement = new ArrayList<>();
    // 记录中间行列已有的普通素材及其数量
    Map<Integer, Integer> middleMaterialsCount = new HashMap<>();

    // 统计中间行列已有的普通素材 [新增逻辑]
    for (int i = 1; i < row - 1; i++) {
        for (int j = 0; j < col; j++) {
            int material = matrix[i][j];
            if (isNormalMaterial(material)) { // 确保isNormalMaterial方法已定义
                middleMaterialsCount.put(material, middleMaterialsCount.getOrDefault(material, 0) + 1);
            }
        }
    }

    // 找出未出现在中间行的普通素材 [新增逻辑]
    for (Integer materialId : list) {
        if (!middleMaterialsCount.containsKey(materialId)) {
            needSupplement.add(materialId);
        }
    }

    // 随机分配未出现的普通素材到第一行和最后一行 [新增逻辑]
    Random random = new Random();
    for (int rowIndex : Arrays.asList(0, row - 1)) {
        for (Integer material : needSupplement) {
            int countToAdd = random.nextInt(3) + 1; // 随机1到3个
            for (int k = 0; k < countToAdd && hasSpace(matrix, rowIndex); k++) {
                int colIndex = random.nextInt(col);
                if (matrix[rowIndex][colIndex] == 0) {
                    matrix[rowIndex][colIndex] = material;
                }
            }
        }
    }

    // 处理中间素材数量不足6个的情况 [新增逻辑]
    for (Map.Entry<Integer, Integer> entry : middleMaterialsCount.entrySet()) {
        int material = entry.getKey();
        int count = entry.getValue();
        if (count < 6) {
            int required = 6 - count;
            for (int i = 0; i < required; i++) {
                int destRow = random.nextBoolean() ? 0 : row - 1; // 随机选择第一行或最后一行
                int colIndex = random.nextInt(col);
                if (matrix[destRow][colIndex] == 0) {
                    matrix[destRow][colIndex] = material;
                }
            }
        }
    }

    // ... 省略后续处理逻辑，如打印矩阵等 ...
    
    // [新增辅助方法] 判断是否为普通素材
    private boolean isNormalMaterial(int material) {
        // 请根据实际情况定义哪些ID属于普通素材
        return material >= GameMaterialConstant.GAME_NORMAL_MATERIAL_101 && material <= GameMaterialConstant.GAME_NORMAL_MATERIAL_139;
    }

    // [新增辅助方法] 检查指定行是否有空位
    private boolean hasSpace(int[][] matrix, int rowIndex) {
        for (int j = 0; j < col; j++) {
            if (matrix[rowIndex][j] == 0) {
                return true;
            }
        }
        return false;
    }
}

这段代码在原有的基础上增加了处理第一行和最后一行的逻辑，包括补充未出现的普通素材以及处理数量不足6个的素材。请注意，我添加了两个辅助方法isNormalMaterial和hasSpace，您需要根据实际情况调整isNormalMaterial中的素材ID范围定义。