Fatal编程技术网

C++ 联想矩阵c++；太大

c++ arrays matrix

C++ 联想矩阵c++；太大,c++,arrays,matrix,2d,C++,Arrays,Matrix,2d,减少矩阵大小的方法在哪里？（x2阵列） 例如，我只需要将数据（0、1、2）存储到数组中 但元素最多可以达到25万。？ 有没有一种方法可以像在字典中那样存储值 const int MAX = 250000; short data[MAX][MAX] = {};//wont compile.. 我记得静态变量的sizeof有一些限制。使用动态内存。 根据元素数量和内存限制，可以使用不同类型的存储 当元素数小于某个预定义值时，即数据密度较低时，可以使用稀疏矩阵。 稀疏矩阵的思想很简单：不保留所有可能

减少矩阵大小的方法在哪里？（x2阵列） 例如，我只需要将数据（0、1、2）存储到数组中 但元素最多可以达到25万。？ 有没有一种方法可以像在字典中那样存储值

const int MAX = 250000;
short data[MAX][MAX] = {};//wont compile..
我记得静态变量的sizeof有一些限制。使用动态内存。 根据元素数量和内存限制，可以使用不同类型的存储

  • 当元素数小于某个预定义值时，即数据密度较低时，可以使用稀疏矩阵。 稀疏矩阵的思想很简单：不保留所有可能的元素；相反，您保留了一些大数量的元素的普通数组，比如1000，类型为struct{int line，row；unsigned char value；}。在一定值下，这种数组的内存消耗小于矩阵。但这可能是随机访问的巨大开销。可以应用一些优化来减少它
  • 如果数据密度较高，“活动”元素的数量较大，则使用压缩矩阵、位填充可以达到一定效果。这可能是非常有效的记忆。在您的示例中，每个值只需要2位，因此int64将在“行”中保留32个值。这里需要精细的优化访问方法，以减少时间消耗
  • 您可以在上述解决方案之间切换，以从稀疏矩阵迁移到压缩矩阵
    • 我记得静态变量的sizeof有一些限制。使用动态内存。 根据元素数量和内存限制，可以使用不同类型的存储

  • 当元素数小于某个预定义值时，即数据密度较低时，可以使用稀疏矩阵。 稀疏矩阵的思想很简单：不保留所有可能的元素；相反，您保留了一些大数量的元素的普通数组，比如1000，类型为struct{int line，row；unsigned char value；}。在一定值下，这种数组的内存消耗小于矩阵。但这可能是随机访问的巨大开销。可以应用一些优化来减少它
  • 如果数据密度较高，“活动”元素的数量较大，则使用压缩矩阵、位填充可以达到一定效果。这可能是非常有效的记忆。在您的示例中，每个值只需要2位，因此int64将在“行”中保留32个值。这里需要精细的优化访问方法，以减少时间消耗
  • 您可以在上述解决方案之间切换，以从稀疏矩阵迁移到压缩矩阵
    • 这对我来说非常有效，正如我在上面所评论的（）：

    #包括
#包括
std：：无序的地图数据；
int main（）{

    std:：cout这对我来说非常有效，正如我在上面所评论的（）：
    

    #包括
#包括
std：：无序的地图数据；
int main（）{

    std:：cout如果数据非常稀疏，则每个项目都有额外的
    无序映射的开销。较低的开销解决方案是使用成对索引无序映射：
    

    #include <iostream>
#include <unordered_map>

/// Hash specialization for a pair of unsigned ints
template<> struct std::hash<std::pair<unsigned int, unsigned int>>
{
  typedef std::pair<unsigned int, unsigned int> argument_type;
  typedef std::size_t value_type;
  value_type operator()(argument_type const& s) const
  {
    value_type const h1 ( std::hash<unsigned int>()(s.first) );
    value_type const h2 ( std::hash<unsigned int>()(s.second) );
    return h1 ^ (h2 << 1);
  }
};

std::unordered_map<std::pair<unsigned int, unsigned int>, unsigned char> data;

int main() {
  using std::make_pair;
  data[make_pair(232432u, 234234u)] = 2;
  data[make_pair(2u, 3u)] = 1;
  std::cout << int(data[make_pair(232432u, 234234u)]) << std::endl;
  std::cout << int(data[make_pair(3u, 3u)]) << std::endl;
  std::cout << int(data[make_pair(232432u, 1u)]) << std::endl;
  std::cout << int(data[make_pair(2u, 3u)]) << std::endl;
}

    

    #包括
#包括
///一对无符号整数的哈希专门化
模板结构std:：hash
{
typedef std:：pair参数类型；
typedef std:：size\u t value\u type；
值类型运算符（）（参数类型常量&s）常量
{
值_type const h1（std:：hash（）（s.first））；
值_type const h2（std:：hash（）（s.second））；

    返回h1^（h2如果数据非常稀疏，则每个项都有额外的
    无序映射的开销。较低的开销解决方案是使用成对索引无序映射：
    

    #include <iostream>
#include <unordered_map>

/// Hash specialization for a pair of unsigned ints
template<> struct std::hash<std::pair<unsigned int, unsigned int>>
{
  typedef std::pair<unsigned int, unsigned int> argument_type;
  typedef std::size_t value_type;
  value_type operator()(argument_type const& s) const
  {
    value_type const h1 ( std::hash<unsigned int>()(s.first) );
    value_type const h2 ( std::hash<unsigned int>()(s.second) );
    return h1 ^ (h2 << 1);
  }
};

std::unordered_map<std::pair<unsigned int, unsigned int>, unsigned char> data;

int main() {
  using std::make_pair;
  data[make_pair(232432u, 234234u)] = 2;
  data[make_pair(2u, 3u)] = 1;
  std::cout << int(data[make_pair(232432u, 234234u)]) << std::endl;
  std::cout << int(data[make_pair(3u, 3u)]) << std::endl;
  std::cout << int(data[make_pair(232432u, 1u)]) << std::endl;
  std::cout << int(data[make_pair(2u, 3u)]) << std::endl;
}

    

    #包括
#包括
///一对无符号整数的哈希专门化
模板结构std:：hash
{
typedef std:：pair参数类型；
typedef std:：size\u t value\u type；
值类型运算符（）（参数类型常量&s）常量
{
值_type const h1（std:：hash（）（s.first））；
值_type const h2（std:：hash（）（s.second））；

    返回h1^（h2压缩
您可以压缩数据值，这将节省内存，但会增加访问时间
    
您的值范围：0、1、2需要2位来表示。因此，一个8位uint8_t变量可以包含4列值：
    

     3  2  1  0  
+--+--+--+--+  
|xx|xx|xx|xx|  
+--+--+--+--+  

    
要访问这些值，您需要执行一些二进制算术：
    

    value of column 0 == (byte & 0x03); /* >> 0 */
value of column 1 == (byte & 0x0c) >> 2;  
value of column 2 == (byte & 0x30) >> 4;
value of column 3 == (byte & 0xC0) >> 6;

    
字节将通过以下方式访问：
    （索引/4）
    
视角的改变
    
因为您只有3个值，所以可以将坐标存储在数组的列表中。您可以在数组中搜索坐标
    

    Data        row   col       row   col
+---+     +-----+----+     +-----+---+   
| 0 | --> | 115 | 25 | --> |20961| 4 |  
+---+     +-----+----+     +-----+---+  
| 1 |  
+---+  
| 2 |  
+---+  

    
在上图中，矩阵位置[115][25]包含零，以及[20961][4]
    

    在上述技术中，您可以使用范围压缩矩阵位置。
    压缩
    
您可以压缩数据值，这将节省内存，但会增加访问时间
    
您的值范围：0、1、2需要2位来表示。因此，一个8位uint8_t变量可以包含4列值：
    

     3  2  1  0  
+--+--+--+--+  
|xx|xx|xx|xx|  
+--+--+--+--+  

    
要访问这些值，您需要执行一些二进制算术：
    

    value of column 0 == (byte & 0x03); /* >> 0 */
value of column 1 == (byte & 0x0c) >> 2;  
value of column 2 == (byte & 0x30) >> 4;
value of column 3 == (byte & 0xC0) >> 6;

    
字节将通过以下方式访问：
    （索引/4）
    
视角的改变
    
因为您只有3个值，所以可以将坐标存储在数组的列表中。您可以在数组中搜索坐标
    

    Data        row   col       row   col
+---+     +-----+----+     +-----+---+   
| 0 | --> | 115 | 25 | --> |20961| 4 |  
+---+     +-----+----+     +-----+---+  
| 1 |  
+---+  
| 2 |  
+---+  

    
在上图中，矩阵位置[115][25]包含零，以及[20961][4]
    

    在上述技术中，您可以使用范围来压缩矩阵位置。
    std:：unordered_map
    将是我最初的想法。我只需将数据（0、1、2）存储到数组中，但元素最多可以达到250000。这是非常不清楚的。矩阵的维度是什么？什么是{min，max}值的范围？每行/每列有多少个非零元素？值只能是0、1、2，但键最多可以是250000，例如data[249043][245235]=0您询问字典……这是否意味着
    data[i][j]
    没有为许多
    i
    s和
    j
    定义