17

给定一个大小为 nxm 的矩阵,其中填充了 0 和 1

例如:

1 1 0 1 0

0 0 0 0 0

0 1 0 0 0

1 0 1 1 0

如果矩阵在 (i,j) 处为 1,则用 1 填充第 j 列和第 i 行

即,我们得到:

1 1 1 1 1

1 1 1 1 0

1 1 1 1 1

1 1 1 1 1

所需复杂度:O(n*m) 时间和 O(1) 空间

注意:您不能在矩阵条目中存储除“0”或“1”之外的任何内容

以上是微软面试题。

我想了两个小时。我有一些线索,但不能再继续了。


行。这个问题的第一个重要部分是Even using a straight forward brute-force way,它不容易解决。

如果我只使用两个循环遍历矩阵中的每个单元格,并更改相应的行和列,则无法完成,因为生成的矩阵应基于原点矩阵。

例如,如果我看到a[0][0] == 1,我不能全部更改为row 0,因为那会影响as本来没有 0。column 01row 1row 1


我注意到的第二件事是,如果一行r只包含0而一列c只包含0,那么a[r][c]一定是0;对于不在此模式中的任何其他位置应该是1

然后另一个问题来了,如果我找到这样的行和列,我怎样才能将相应的单元格标记a[r][c]special它已经是 0。


我的直觉是我应该对此使用某种位操作。或者为了满足所需的复杂性,我必须做类似After I take care of a[i][j], I should then proceed to deal with a[i+1][j+1], instead of scan row by row or column by column.

即使对于不考虑时间复杂度的蛮力,我也无法用其他条件解决它。

有人有线索吗?


解决方案:Java版

@japreiss 已经回答了这个问题,他/她的回答是聪明而正确的。他的代码是 Python 的,现在我给出 Java 版本。学分都去@japreiss

public class MatrixTransformer {

    private int[][] a;
    private int m;
    private int n;
    
    public MatrixTransformer(int[][] _a, int _m, int _n) {
        a = _a;
        m = _m;
        n = _n;
    }
    
    private int scanRow(int i) {
        int allZero = 0;
        for(int k = 0;k < n;k++)
            if (a[i][k] == 1) {
                allZero = 1;
                break;
            }
        
        return allZero;
    }
    
    private int scanColumn(int j) {
        int allZero = 0;
        for(int k = 0;k < m;k++)
            if (a[k][j] == 1) {
                allZero = 1;
                break;
            }
        
        return allZero;
    }
    
    private void setRowToAllOnes(int i) {
        for(int k = 0; k < n;k++)
            a[i][k] = 1;
    }
    
    private void setColToAllOnes(int j) {
        for(int k = 0; k < m;k++)
            a[k][j] = 1;
    }
        
//  # we're going to use the first row and column
//  # of the matrix to store row and column scan values,
//  # but we need aux storage to deal with the overlap
//  firstRow = scanRow(0)
//  firstCol = scanCol(0)
//
//  # scan each column and store result in 1st row - O(mn) work
    
        
        
    public void transform() {
        int firstRow = scanRow(0);
        int firstCol = scanColumn(0);
                
                
        for(int k = 0;k < n;k++) {
            a[0][k] = scanColumn(k);
        }

        // now row 0 tells us whether each column is all zeroes or not
        // it's also the correct output unless row 0 contained a 1 originally

        for(int k = 0;k < m;k++) {
            a[k][0] = scanRow(k);
        }
        
        a[0][0] = firstCol | firstRow;
        
        for (int i = 1;i < m;i++)
            for(int j = 1;j < n;j++)
                a[i][j] = a[0][j] | a[i][0];


        
        if (firstRow == 1) {
            setRowToAllOnes(0);
        }
        
        if (firstCol == 1) 
            setColToAllOnes(0);
    }
    
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        
        for (int i = 0; i< m;i++) {
            for(int j = 0;j < n;j++) {
                sb.append(a[i][j] + ", ");
            }
            sb.append("\n");
        }
        
        return sb.toString();
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        int[][] a = {{1, 1, 0, 1, 0}, {0, 0, 0, 0, 0},{0, 1, 0, 0, 0},{1, 0, 1, 1, 0}};
        MatrixTransformer mt = new MatrixTransformer(a, 4, 5);
        mt.transform();
        System.out.println(mt);
    }

}
4

5 回答 5

19

这是 python 伪代码中的一个解决方案,它使用 2 个额外bool的存储空间。我认为它比我用英语做的更清楚。

def scanRow(i):
    return 0 if row i is all zeroes, else 1

def scanColumn(j):
    return 0 if col j is all zeroes, else 1

# we're going to use the first row and column
# of the matrix to store row and column scan values,
# but we need aux storage to deal with the overlap
firstRow = scanRow(0)
firstCol = scanCol(0)

# scan each column and store result in 1st row - O(mn) work
for col in range(1, n):
    matrix[0, col] = scanColumn(col)

# now row 0 tells us whether each column is all zeroes or not
# it's also the correct output unless row 0 contained a 1 originally

# do the same for rows into column 0 - O(mn) work
for row in range(1, m):
    matrix[row, 0] = scanRow(row)

matrix[0,0] = firstRow or firstCol

# now deal with the rest of the values - O(mn) work
for row in range(1, m):
    for col in range(1, n):
        matrix[row, col] = matrix[0, col] or matrix[row, 0]


# 3 O(mn) passes!

# go back and fix row 0 and column 0
if firstRow:
    # set row 0 to all ones

if firstCol:
    # set col 0 to all ones
于 2012-05-31T20:01:03.597 回答
8

这是另一种直觉,它给出了解决问题的简洁算法。

使用 O(n) 空间的初始算法。

现在,让我们忽略 O(1) 内存限制。假设您可以使用 O(n) 内存(如果矩阵为 m × n)。这将使这个问题变得容易得多,我们可以使用以下策略:

  • 创建一个布尔数组,每列一个条目。
  • 对于每一列,确定列中是否有任何 1 并将该信息存储在适当的数组条目中。
  • 对于每一行,如果该行中有任何 1,则将该行设置为全 1。
  • 对于每一列,如果设置了相应的数组条目,则将该列设置为全 1。

例如,考虑这个数组:

1 1 0 1 0
0 0 0 0 0
0 1 0 0 0
1 0 1 1 0

我们将从创建和填充辅助数组开始,这可以通过一次访问每一列在 O(mn) 时间内完成。这显示在这里:

1 1 0 1 0
0 0 0 0 0
0 1 0 0 0
1 0 1 1 0

1 1 1 1 0  <--- aux array

接下来,我们遍历行并填充每一行,如果它包含任何 1。这给出了这个结果:

1 1 1 1 1
0 0 0 0 0
1 1 1 1 1
1 1 1 1 1

1 1 1 1 0  <--- aux array

最后,如果辅助数组在该位置有 1,我们用 1 填充每一列。这显示在这里:

1 1 1 1 1
1 1 1 1 0
1 1 1 1 1
1 1 1 1 1

1 1 1 1 0  <--- aux array

所以有一个问题:这使用了我们没有的 O(n) 空间!那么为什么还要走这条路呢?

使用 O(1) 空间的改进算法。

事实证明,我们可以使用一个非常可爱的技巧来使用 O(1) 空间运行这个算法。我们需要一个关键的观察:如果每一行至少包含一个 1,那么整个矩阵就变成了 1。因此,我们首先看看是否是这种情况。如果是,那就太好了!我们完成了。

否则,矩阵中一定有某行全为 0。由于该行全为 0,我们知道在“用 1 填充包含 1 的每一行”步骤中,该行不会被填充。因此,我们可以将该行用作我们的辅助数组!

让我们看看这个在行动。从这个开始:

1 1 0 1 0
0 0 0 0 0
0 1 0 0 0
1 0 1 1 0

现在,我们可以找到一个全为 0 的行,并将其用作我们的辅助数组:

1 1 0 1 0
0 0 0 0 0  <-- Aux array
0 1 0 0 0
1 0 1 1 0

我们现在通过查看每一列并标记哪些列至少包含一个 1 来填充辅助数组:

1 1 0 1 0
1 1 1 1 0  <-- Aux array
0 1 0 0 0
1 0 1 1 0

在这里填写 1 是完全安全的,因为我们知道他们无论如何都会被填写。现在,对于包含 1 的每一行,除了辅助数组 row,我们用 1 填充这些行:

1 1 1 1 1
1 1 1 1 0  <-- Aux array
1 1 1 1 1
1 1 1 1 1

我们跳过辅助数组,因为最初它全是 0,所以它通常不会被填充。最后,我们在辅助数组中用 1 填充每一列,给出最终结果:

1 1 1 1 1
1 1 1 1 0  <-- Aux array
1 1 1 1 1 
1 1 1 1 1

让我们再举一个例子。考虑这个设置:

1 0 0 0
0 0 1 0
0 0 0 0
0 0 1 0

我们首先找到一个全为零的行,如下所示:

1 0 0 0
0 0 1 0
0 0 0 0 <-- Aux array
0 0 1 0

接下来,让我们通过标记包含 1 的列来填充该行:

1 0 0 0
0 0 1 0
1 0 1 0 <-- Aux array
0 0 1 0

现在,填写所有包含 1 的行:

1 1 1 1
1 1 1 1
1 0 1 0 <-- Aux array
1 1 1 1

接下来,用 1 填充 aux 数组中包含 1 的所有列。这已经在这里完成了,我们有我们的结果!

作为另一个例子,考虑这个数组:

1 0 0
0 0 1
0 1 0

这里的每一行至少包含一个 1,所以我们只需用 1 填充矩阵就完成了。

最后,让我们试试这个例子:

0 0 0 0 0
0 0 0 0 0
0 1 0 0 0
0 0 0 0 0
0 0 0 1 0

我们有很多辅助数组的选择,所以让我们选择第一行:

0 0 0 0 0 <-- aux array
0 0 0 0 0
0 1 0 0 0
0 0 0 0 0
0 0 0 1 0

现在,我们填写 aux 数组:

0 1 0 1 0 <-- aux array
0 0 0 0 0 
0 1 0 0 0
0 0 0 0 0
0 0 0 1 0

现在,我们填写行:

0 1 0 1 0 <-- aux array
0 0 0 0 0 
1 1 1 1 1
0 0 0 0 0
1 1 1 1 1

现在,我们根据 aux 数组填充列:

0 1 0 1 0 <-- aux array
0 1 0 1 0 
1 1 1 1 1
0 1 0 1 0
1 1 1 1 1

我们完成了!整个过程在 O(mn) 时间内运行,因为我们

  • 做 O(mn) 工作来找到 aux 数组,如果一个不存在,可能 O(mn) 立即工作。
  • 做 O(mn) 工作来填充辅助数组。
  • 做 O(mn) 工作来填充包含 1 的行。
  • 做 O(mn) 的工作来填充包含 1 的列。

另外,它只使用 O(1) 空间,因为我们只需要存储辅助数组的索引和足够的变量来对矩阵进行循环。

编辑:我有这个算法的 Java 实现,并在我的个人网站上提供了详细描述它的评论。享受!

希望这可以帮助!

于 2014-03-06T19:33:40.957 回答
1

假设矩阵是从 0 开始的,即第一个元素在 mat[0][0]

  1. 使用第一行和第一列作为表头分别包含列和行信息。1.1 注意 mat[0][0] 处的元素。如果是1,最后需要特殊处理(后面会讲)

  2. 现在,从 index[1][1] 开始扫描内部矩阵直到最后一个元素 2.1 如果元素 at[row][col] == 1 则更新表头数据如下行:mat[row][0 ] = 1; 列:mat[0][col] = 1;

至此,我们有了关于应该将哪一列和哪一行设置为 1 的完整信息

  1. 再次开始扫描从 mat[1][1] 开始的内部矩阵,如果当前行或列在表头中包含 1,则将每个元素设置为 1: if ( (mat[row][0] == 1) | | (mat[0][col] == 1) ) 然后将 mat[row][col] 设置为 1。

此时我们已经处理了内部矩阵中的所有单元格,我们还没有处理表头本身

  1. 处理表头 如果 matt[0][0] == 1 则将第一列和第一行中的所有元素设置为 1
  2. 完毕

时间复杂度O(2*((n-1)(m-1)+(n+m-1)),即O(2*n*m - (n+m) + 1),即O(2* n*m) 空间 O(1)

在http://codepad.org/fycIyflw查看我的实现

于 2012-06-03T05:48:15.373 回答
-1

另一种解决方案是像往常一样扫描矩阵,并在第一个 1 处将矩阵分成 4 个象限。然后将行和列设置为 1,并递归处理每个象限。只需确保设置整个列和行,即使您只扫描一个象限。

于 2012-06-12T19:04:59.347 回答
-1
public void setOnes(int [][] matrix){

    boolean [] row = new boolean [matrix.length]
    boolean [] col = new boolean [matrix[0].length]
    for (int i=0;i<matrix.length;i++){
        for(int j=0;j<matrix[0].length;j++){
            if (matrix[i][j] == 1){
                row[i] = true
                col[j] = true
            }
        }
    }

    for (int i=0;i<matrix.length;i++){
        for(int j=0;j<matrix[0].length;j++){
            if (row[i] || col[j]){
                matrix[i][j] = 1;
            }
        }
    }
}
于 2014-01-16T06:39:27.080 回答