1。 Techmonk的

Question

有一个大小为n*n的矩阵，其中n<=500000。最初所有元素都是0.我们必须在每次有输入时将整行或列更新一定数量

示例：

n=3    
RS 1 10

表示我们必须将第1行更新为10

0 0 0
0 0 0
0 0 0

更新后

10 10 10
 0  0  0    
 0  0  0

我们必须为列做。最后，我们必须计算矩阵中的0的数量

因为n非常大的双维数组无法应用。那么应用哪种数据结构？

Answer 1

这很有意思，它当然取决于您要执行的操作数量，但我会将其保存为2个单维数组。一个是行输入，另一个是列输入。

row [n]和col [n]

所以当你想知道say元素（4,7）的值时，它会是row [4] + col [7]

Answer 2

进一步理解@ Techmonk的答案：我提出了两种方法：

1。 Techmonk的

O（1）用于更新，O（n ^ 2）用于恢复0的数量

 class matZeroCount {
     std::vector< int > m_rows;
     std::vector< int > m_cols;
 public:
     matZeroCount( unsigned int n ): m_rows( n, 0 ), m_cols( n, 0 ) {};
     void updateRow( unsigned int idx, int update ) { 
          // check idx range w.r.t m_rows.size()
          // ignore update == 0 case
          m_rows[ idx ] += update; 
     }
     void updateCol( unsigned int idx, int update ) { 
          // check idx range w.r.t m_cols.size()
          // ignore update == 0 case
          m_cols[ idx ] += update; 
     }
     unsigned int countZeros() const {
         unsigned int count = 0;
         for ( auto ir = m_rows.begin(); ir != m_rows.end(); ir++ ) {
             for ( auto ic = m_cols.begin(); ic != m_cols.end(); ic++ ) {
                  count += ( ( *ir + * ic ) == 0 );
             }
         }
         return count;
     }
 };

2。快速计数

此方法允许O（1）恢复零的数量，每次更新的代价为O（n）。如果您期望少于O（n）更新 - 这种方法可能更有效。

 class matZeroCount {
     std::vector< int > m_rows;
     std::vector< int > m_cols;
     unsigned int       m_count;
 public:
     matZeroCount( unsigned int n ): m_rows( n, 0 ), m_cols( n, 0 ), count(0) {};
     void updateRow( unsigned int idx, int update ) { 
          // check idx range w.r.t m_rows.size()
          // ignore update == 0 case
          m_rows[ idx ] += update;
          for ( auto ic = m_cols.begin(); ic != m_cols.end(); ic++ ) {
               m_count += ( ( m_rows[ idx ] + *ic ) == 0 ); // new zeros
               m_count -= ( ( m_rows[ idx ] - update + *ic ) == 0 ); // not zeros anymore
          }
     }
     void updateCol( unsigned int idx, int update ) { 
          // check idx range w.r.t m_cols.size()
          // ignore update == 0 case
          m_cols[ idx ] += update; 
          for ( auto ir = m_rowss.begin(); ir != m_rows.end(); ir++ ) {
               m_count += ( ( m_cols[ idx ] + *ir ) == 0 ); // new zeros
               m_count -= ( ( m_cols[ idx ] - update + *ir ) == 0 ); // not zeros anymore
          }

     }
     unsigned int countZeros() const { return m_count; };
 };

Answer 3

Sparse Matrix是一种适用于主要使用零填充的矩阵的数据结构。其实施旨在提高空间效率。当你的信息很少的大型矩阵时，它就像你的情况一样适合。

Answer 4

您可能需要一个内部包含std::list <std::list<int>>的用户定义类型。

但实际上，你能同时在内存中保存2500亿个整数吗？我对此表示怀疑！

您可能需要使用二维数组整数的文件到内存映射数据结构。

要应用哪种数据结构？

4 个答案:

1。 Techmonk的

2。快速计数