如何计算矩阵中不存在 2 个元素的 4*3 矩阵的组合总数

Question

下面是矩阵的格式。并且不允许字母的对角组合，只允许垂直和水平组合。 谁能建议如何计算特定级别所需的组合数量。 示例：如果我说级别为 1，则只允许 1 个字母组合，即 A、B、C、D、E、F、G、H、I 即 10 种组合 如果我说级别是 2，那么可能的组合是 AA、BB、AB、AD、BC、BE、...等等，所以级别 2 总共有 36 种组合。 像这样，如果输入是给定的任何级别数，那么我如何计算可能的组合数？

A   B   C
D   E   F
G   H   I
    J   

我试过用这个公式：

(n!/(r!(n-r)!)

但从第 2 级开始计算不正确。 注意：J 的两边没有字母。

请提出建议。

Answer 1

@Thientvse 这是我编写的代码......它给出了正确的输出......你能告诉我我的代码是否正确以及它是否能满足这个场景的所有测试用例

import java.util.ArrayList;
import java.util.Scanner;
public class Game {
    public static int combinationCounts(int input1){
        ArrayList<String> mainalternatestring = new ArrayList<String>();
        ArrayList<String> mainverticalstring = new ArrayList<String>();
        String sb = "ABC#DEF#GHI# J ";
        String a=null,b=null,c=null,nw=null;

        int mainindex = 0,counter,totalcount=10,index=0,mainindex_duplicate=0,count=1;

        if(input1 > 1 && input1 <= 4){
            while(mainindex != 11){
                int level =  0;
                counter = 0;
                count=1;
                char[] strtoworkon = new char[sb.length()];
                index=0;

                if(mainindex != 0)
                    mainindex = mainindex+1;

                for(int j = mainindex; count!= (sb.length()-mainindex) ; j++){
                    if(level == input1)
                        break;

                    if(sb.charAt(j) == '#'){
                        level++;
                        if (counter == 0){
                            mainindex_duplicate = j;  
                            counter = 1;
                        }
                    }

                    if(level <= input1){
                        strtoworkon[index] = sb.charAt(j);
                        index++;
                    }
                    count++;
                }
                mainindex = mainindex_duplicate;

                // for sideways combinations
                for(int m = 0; m <= strtoworkon.length; m++){
                    c = null;
                    if(strtoworkon[m] == ' ')
                        break;
                    if(!String.valueOf(strtoworkon).substring(m, m+(input1)).contains("#")){
                        c = String.valueOf(strtoworkon).substring(m, m+(input1));

                        if(!c.matches(".*[A-Z].*"))
                            break;

                        if(!mainalternatestring.contains(c))
                            mainalternatestring.add(c);

                    }
                }

                //for vertical combinations  
                nw = "#" + (String.valueOf(strtoworkon));
                int counter1=0;
                while(counter1 != 3){
                    c="";
                    for(int n = 0; n<= strtoworkon.length; n++){
                        if(nw.charAt(n) == '#'){
                            Character test = nw.charAt(n+counter1);

                            a = Character.toString(strtoworkon[n+counter1]).trim();
                            if(a.contains("#"))
                                break;
                            c = a+c;
                            c.trim();
                        }
                    }
                    if(!mainverticalstring.contains(c) && c.length() == input1)
                        mainverticalstring.add(c);
                    counter1++;
                }

                if(mainindex == 11)
                    break;
            }
            totalcount = totalcount + (2*mainalternatestring.size()) + (2*mainverticalstring.size());
        }
        return totalcount;

    }

    public static void main(String[] args) {

         Scanner in = new Scanner(System.in);
            int output = 0;
            int ip1 = Integer.parseInt(in.nextLine().trim());
            output = combinationCounts(ip1);
            System.out.println(String.valueOf(output));
    }
}