要应用的数据结构

Which data structure to be applied?

本文关键字：数据结构 应用      更新时间：2023-10-16

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

示例：

n=3    
RS 1 10

意味着我们必须用10 更新第1行

0 0 0
0 0 0
0 0 0

更新后

10 10 10
 0  0  0    
 0  0  0

我们对专栏也必须这样做。最后，我们必须计算矩阵中0的数量

由于CCD_ 3是非常大的二维阵列，因此不能应用。那么，应用哪种数据结构呢？

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

行[n]和列[n]

因此，当你想知道元素（4,7）的值时，它将是row[4]+col[7]

进一步理解@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; };
 };
稀疏矩阵是一种适用于大部分为零的矩阵的数据结构。它的实施是为了提高空间效率。它适用于像你这样的情况，当你有信息很少的大矩阵时。

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

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

您可能需要使用一个非常不同的、文件到内存映射的二维整数数组数据结构。

相关文章：