Java-如果2d数组包含目标编号，则将其行/列归零

给定如下所示的mxn矩阵：
1034
1234
3560

需要输出如下内容：
0000
1030
万

*目标编号为0

这是我的解决方案，但我认为它不是很有效（空间和运行时间，我认为是O（m^2*n）），我想知道是否有更简单、更有效的方法来做到这一点。如果是，是什么

int[][] m = { { 1, 0, 3, 4 }, { 1, 2, 3, 4 }, { 3, 5, 6, 0 } };  
m = zero(m, 0);

public static int[][] zero(int[][] m, int num) {

    int rows = m.length;
    int columns = m[0].length;
    int [][] myInt = new int[rows][];
    for(int i = 0; i < rows; i++){
        myInt[i] = m[i].clone();
    }
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < columns; j++) {
            if (myInt[i][j] == num) {
                m[i] = new int[columns];
                for(int k = 0; k < rows; k++){
                    m[k][j] = 0;
                }
                break;
            }
        }
    }       
    return m;
}

int[]m={{1,0,3,4}，{1,2,3,4}，{3,5,6,0}；
m=零（m，0）；
公共静态int[]zero（int[]m，int num）{
int行=m.length；
int columns=m[0]。长度；
int[][]myInt=新的int[行][]；
对于（int i=0；i

---

基本上，我首先克隆输入矩阵，然后遍历每一行并检查该行是否包含我的目标编号。如果是，则将原始矩阵中的整行设置为零。然后我执行另一个循环，将包含目标编号的列设置为零。我在开始时克隆了矩阵，因此每次迭代时都会根据克隆的参考矩阵而不是修改的参考矩阵进行检查。

我建议对行/列索引使用位集

public static void zero(int[][] m, int num) {

    int rows = m.length;
    int columns = m[0].length;
    BitSet rowsToClear = new BitSet(rows);
    BitSet columnsToClear = new BitSet(columns);
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < columns; j++) {
            if (m[i][j] == num) {
                rowsToClear.set(i);
                columnsToClear.set(j);
            }
        }
    }
    for (int i = rowsToClear.nextSetBit(0); i >= 0;
             i = rowsToClear.nextSetBit(i + 1)) {
        Arrays.fill(m[i], 0);
    }
    for (int j = columnsToClear.nextSetBit(0); j >= 0;
            j = columnsToClear.nextSetBit(j + 1)) {
        for (int i = 0; i < rows; ++i) {
            m[i][j] = 0;
        }
    }
    //return m;
}

publicstaticvoidzero（int[]m，int num）{
int行=m.length；
int columns=m[0]。长度；
BitSet rowsToClear=新的位集（行）；
BitSet columnsToClear=新的位集（列）；
对于（int i=0；i=0；
i=rowsToClear.nextSetBit（i+1））{
填充（m[i]，0）；
}
对于（int j=columnsToClear.nextSetBit（0）；j>=0；
j=列清除。下一列清除（j+1））{
对于（int i=0；i

我刚刚遇到了这个问题，并为其制定了解决方案

我希望得到一些关于代码的反馈，关于它的优劣以及它的运行时和空间复杂性。这一切都很新鲜：）

publicstaticvoidzeromatrix（int[]arr1）
{
ArrayList coord=新的ArrayList（）；
int row=arr1.1长度；
int column=arr1[0]。长度；
对于（int i=0；iwhile（示例中不清楚套件）（无代码）你想做什么。对不起，我忘了提到我的例子中的目标数字是0。所以需要将矩阵中包含0的行和列归零。没有问题，就没有答案。问题是有没有比我发布的更有效的方法来解决这个问题。如果有，那是什么。谢谢。r是什么此算法的运行时间？for的时间为NxM，是决定性的因素。
BitSet
在这种情况下是一个间接的长，而
nextSetBit
则是
long。trailingzero的数量非常优化。
int
i.o.a
BitSet
可能更优化，但是，二维数组也不是最优的在Java中。
array.fill
虽然很好。
public static void zeroMatrix(int[][] arr1)
{
    ArrayList<Integer> coord = new ArrayList<>();

    int row = arr1.length; 
    int column = arr1[0].length;
    for(int i=0; i < row; i++)
    {
        for(int j=0; j < column; j++)
        {
            if(arr1[i][j]==0)
            { 
                coord.add((10*i) + j);
            }       
        }
    }

    for(int n : coord)
    {
         int j=n%10;
         int i=n/10; int k=0;
        int l=0;
        while(k<row)
        {
            arr1[k][j]=0;
            k++;
        }
        while(l<column)
        {
            arr1[i][l]=0;
            l++;
        }
    }
}