Java 打印大小为m*n的矩阵中的所有元素组合 打印大小为m*n的矩阵中的所有元素组合 示例： 预期产出： 规则： 每个组合从矩阵的左侧开始，然后向右进行。但它可能会交换行 每个组合的元素数应等于列数 组合不能让同一列中的元素出现两次

列和行的数量可能会有所不同。所以解决方案必须是通用的

import java.util.Scanner;

class Combination {
public static void main(String args[]) {
int row, col, i, j;

Scanner in = new Scanner(System.in);
System.out.println("Enter the number of rows and columns of matrix:\n");
row = in.nextInt();
col = in.nextInt();

int first[][] = new int[row][col];
System.out.println("Enter the elements if matric m*n:\n");
for (i = 0; i < row; i++) {
    for (j = 0; j < col; j++) {
        first[i][j] = in.nextInt();
    }
}
System.out.println("Matrix:\n");
for (i = 0; i < row; i++) {
    for (j = 0; j < col; j++) {
        System.out.print(first[i][j] + "\t");
    }
    System.out.println();
}
// Final Logic from here...
System.out.println("\nOut Matrix:\n");
for (i = 0; i < 2; i++) {
    for (j = 0; j < 2; j++) {
        for (int k = 0; k < 2; k++) {
            System.out.println(first[i][0] + "," + first[j][1] + ","
                    + first[k][2]+"\n");
        }
    }
}
 /* while (i < 2) {
    j = 0;
    while (j < 2) {
        k = 0;
        while (k < 2) {
            System.out.println(first[i][0] + "," + first[j][1] + ","
                    + first[k][2]);
            k++;
        }
        j++;
    }
    i++;
}*/
in.close();
}
}

import java.util.Scanner；
阶级组合{
公共静态void main（字符串参数[]）{
int row，col，i，j；
扫描仪输入=新扫描仪（系统输入）；
System.out.println（“输入矩阵的行数和列数：\n”）；
row=in.nextInt（）；
col=in.nextInt（）；
int first[][]=新的int[行][col]；
System.out.println（“如果矩阵m*n:\n，则输入元素”）；
对于（i=0；i

适用于特定输入，但无法动态执行…需要帮助。。

---

提前感谢……您可以使用如下递归：

...
    // Final Logic from here...
    System.out.println("\nOut Matrix:\n");
    int[] outputRow = new int[col];
    print(0, row, col, first, outputRow);

}

private static void print(int j, int row, int col, int[][] first, int[] outputRow) {
    for (int i = 0; i < row; i++) {
        outputRow[j] = first[i][j];
        // recursively continue to populate outputRow until we reach the last column (j == col -1)
        if (j < col - 1) {
            print(j + 1, row, col, first, outputRow);               
        }
        // we have reached the last column (j == col -1) so now we could print current permutation
        if (j == col - 1) {
            for (int k = 0; k < col; k++) {
                System.out.print(" " + outputRow[k]);                   
            }
            System.out.println();                   
        }
    }
}

。。。
//最后的逻辑从这里。。。
System.out.println（“\n矩阵：\n”）；
int[]outputRow=新的int[col]；
打印（0，行，列，第一，输出）；
}
私有静态无效打印（int j，int行，int列，int[]first，int[]outputRow）{
对于（int i=0；i

这里，我们从

j==0开始，每个递归调用处理一列

outputRow
存储当前排列并递归更新

当我们递归地到达最后一列时，就是打印当前排列的时候了。
这是一种可能的方法

void printCombos(){
    visit(0,-1,"");
}

void visit(int r,int c,String s){
    if(c!=a[0].length-1)
        for(int i=0;i<a.length;i++)
            visit(i,c+1,s+" - "+a[i][c+1]);
    else
        System.out.println(s);
}

5和7是叶子。
首先再创建一个方法：

private static void increasePointerArray(int[] poinerArray, int row) 
{
    for (int i = poinerArray.length-1; i >= 0; i--) {
        if(poinerArray[i] == row-1) {
            continue;
        }
        else {
            poinerArray[i] = poinerArray[i] +1;
            for (int j = i+1; j < poinerArray.length; j++) {
                poinerArray[j] = 0;
            }
            break;
        }
    }
}

private static void increasePointerArray（int[]poinerray，int行）
{
对于（int i=poinerray.length-1；i>=0；i--）{
if（poinerray[i]==第1行）{
继续；
}
否则{
波利纳雷[i]=波利纳雷[i]+1；
对于（int j=i+1；j

现在，在最后的逻辑部分，输入以下代码：

int[] poinerArray = new int[col];
int[] MaxArray = new int[col];
List<int[]> resultList = new ArrayList<int[]>();

Arrays.fill(poinerArray, 0);
Arrays.fill(MaxArray, row-1);

while(!Arrays.equals(poinerArray, MaxArray)) {
    resultList.add(poinerArray.clone());
    increasePointerArray(poinerArray, row);
}
resultList.add(poinerArray.clone());

System.out.println("Printing desired result : ");

for (int[] ks : resultList) {
    StringBuffer sb = new StringBuffer();
    for (j = 0; j < col; j++) {
        sb.append(first[ks[j]][j]+"\t");
    }
    System.out.println(sb.toString());
    sb = null;
}

int[]poinerray=新的int[col]；
int[]MaxArray=新的int[col]；
List resultList=new ArrayList（）；
数组填充（poinerray，0）；
数组。填充（MaxArray，第1行）；
而（！Arrays.equals（poinerray，MaxArray））{
add（poinerray.clone（））；
递增指针阵列（POINERRAY，row）；
}
add（poinerray.clone（））；
System.out.println（“打印所需结果：”）；
for（int[]ks:resultList）{
StringBuffer sb=新的StringBuffer（）；
对于（j=0；j
导入java.io.BufferedReader；
导入java.io.IOException；
导入java.io.InputStreamReader；
导入java.util.ArrayList；
公共类置换{
公共静态字符串=”；
public static ArrayList out=new ArrayList（）；
公共静态void gen（ArrayList x，int索引）{
对于（int i=0；i0）{
String[]parts=strings.split（“，”）；
字符串=”；
对于（int k=0；k你说你不能动态地做它是什么意思，但它对特定的输入有效？我看到用户在程序开始时输入了行数和列数，那么你还想动态化什么？它对上述给定的输入有效我在最终逻辑中对2的位置做了一些更改，将其替换为行，但随后我IIT输入2×4矩阵它不起作用…谢谢。组合的显示顺序重要吗？来说明我的问题。以你的预期输出为例，如果元素2, 6, 7出现在输出的顶部还是中间，它仍然是一个有效的答案吗？YUP没有问题，它应该只打印上面的组合…我正在尝试一个通用代码，提前谢谢你……你不必使用递归，它只是一个way@SergeyPauk我不知道打印1 3 5后循环是如何工作的…u plzzz能提供更多的解释吗……打印
1 3 5
后变量
I
增加1，变成
1
，然后您用
first[1][2]
更新
outputRow
的最后一个元素（以前的值是
first[0][2]
），使当前输出行与前一个不同，只是在它的最后一个元素中。@SergeyPauk j=2 i=1行//j=2 outputRow[2]=7 13 j=1 i=1行//j=1 outputRow[1]=6 j=2行//j=2 outputRow[2]=5 j=2
* --- 1 -- 3 -- 5
  \     \/   \/
   \    /\   /\
    \ 2 -- 6 -- 7

private static void increasePointerArray(int[] poinerArray, int row) 
{
    for (int i = poinerArray.length-1; i >= 0; i--) {
        if(poinerArray[i] == row-1) {
            continue;
        }
        else {
            poinerArray[i] = poinerArray[i] +1;
            for (int j = i+1; j < poinerArray.length; j++) {
                poinerArray[j] = 0;
            }
            break;
        }
    }
}

int[] poinerArray = new int[col];
int[] MaxArray = new int[col];
List<int[]> resultList = new ArrayList<int[]>();

Arrays.fill(poinerArray, 0);
Arrays.fill(MaxArray, row-1);

while(!Arrays.equals(poinerArray, MaxArray)) {
    resultList.add(poinerArray.clone());
    increasePointerArray(poinerArray, row);
}
resultList.add(poinerArray.clone());

System.out.println("Printing desired result : ");

for (int[] ks : resultList) {
    StringBuffer sb = new StringBuffer();
    for (j = 0; j < col; j++) {
        sb.append(first[ks[j]][j]+"\t");
    }
    System.out.println(sb.toString());
    sb = null;
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class Permutations{
    public static String strings="";
    public static ArrayList<String> out=new ArrayList<String>();
    public static void gen(ArrayList<ArrayList<String>> x,int index){
        for(int i=0;i<x.size();i++){
            if(i>0){
                String[] parts=strings.split(",");
                strings="";
                for(int k=0;k<parts.length;k++){
                    if(k==index)
                        break;
                    strings=strings+parts[k]+",";
                }
            }
            if(index==x.get(0).size()-1){
                strings=strings+(x.get(i).get(index));
                out.add(strings);
            }
            else
                strings=strings+(x.get(i).get(index))+",";
            if(index+1<=x.get(0).size()-1)
                gen(x,index+1);
        }
    }
    public static void main(String[] args) throws IOException{
        ArrayList<ArrayList<String>> x=new ArrayList<ArrayList<String>>();
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        String line;
        while(true){
            line=br.readLine();
            if(line.contentEquals("")) break;
            String[] parts=line.split(" ");
            x.add(new ArrayList<String>());
            for(int i=0;i<parts.length;i++){
                x.get(x.size()-1).add(parts[i]);
            }
        }
        gen(x,0);
        for(int i=0;i<out.size();i++){
            System.out.println(out.get(i));
        }
    }
}