如何在 C++ 中的矩阵中搜索向量以及哪种算法？

Posted 2023-02-22

【中文标题】如何在 C++ 中的矩阵中搜索向量以及哪种算法？

【英文标题】：How to search for a vector in a matrix in C++ and which algorithm?

【发布时间】：2015-10-09 06:14:21

【问题描述】：

假设我有一个矩阵和一个由给出的向量。如何执行二进制搜索之类的搜索算法来返回索引？ 示例：

const int V_SIZE = 10,H_SIZE = 7;
   int a1[V_SIZE][H_SIZE] = 
                                1,2,0,0,0,0,0,
                                1,3,0,0,0,0,0,
                                2,2,4,0,0,0,0,
                                2,2,6,0,0,0,0,
                                3,2,4,7,0,0,0,
                                4,1,3,5,9,0,0,
                                4,1,4,6,8,0,0,
                                4,2,3,4,7,0,0,
                                5,2,3,5,7,8,0,
                                6,1,3,4,5,7,10
                            ; // sorted
  int a2 [H_SIZE] = 4,1,3,5,9,0,0;

在矩阵a1中搜索向量a2，返回值为6 非常感谢

【问题讨论】：

欢迎加入堆栈，规则很简单，您向我们展示您的努力，我们指出错误，这里没有人会为您解决整个问题

初始索引为 0，您的示例中的答案不是 5 吗？矩阵会一直排序吗？

是的，如果初始索引为 0，则答案为 5。这只是一个示例。第一列按升序排序进行二分搜索，第二列也根据第一列的值升序排序，依此类推

【参考方案1】：

您可以将 2D std::array 与 std::lower_bound 结合使用：

  const int V_SIZE = 10,H_SIZE = 7;
  std::array<std::array<int, H_SIZE>, V_SIZE> a1 
                                1,2,0,0,0,0,0,
                                1,3,0,0,0,0,0,
                                2,2,4,0,0,0,0,
                                2,2,6,0,0,0,0,
                                3,2,4,7,0,0,0,
                                4,1,3,5,9,0,0,
                                4,1,4,6,8,0,0,
                                4,2,3,4,7,0,0,
                                5,2,3,5,7,8,0,
                                6,1,3,4,5,7,10
                            ; // sorted

  std::array<int, H_SIZE> a2 4,1,3,5,9,0,0;

  int idx = std::lower_bound(std::begin(a1), std::end(a1), a2) - std::begin(a1);

LIVE DEMO

【参考方案2】：

如果矩阵按第一个数字排序，您可以使用二进制搜索来查找 近似 索引。然后，您必须返回直到找到以与向量中相同的数字开头的第一行，然后向前找到以相同数字开头的最后一行。然后您循环遍历向量，在您拥有的行范围内搜索第二个、第三个等数字的匹配项。

【参考方案3】：

使用 std::array 这样的东西怎么样？

template <int HSIZE>
bool operator<(const std::array<int, HSIZE> &lhs, const std::array<int, HSIZE> &rhs)

    for (int i = 0; i < HSIZE; i++)
        if (lhs[i] != rhs[i])
            return lhs[i] < rhs[i];
    return false;


std::array<int, 7> a1[] = 

     1, 2, 0, 0, 0, 0, 0 ,
     1, 3, 0, 0, 0, 0, 0 ,
     2, 2, 4, 0, 0, 0, 0 ,
     2, 2, 6, 0, 0, 0, 0 ,
     3, 2, 4, 7, 0, 0, 0 ,
     4, 1, 3, 5, 9, 0, 0 ,
     4, 1, 4, 6, 8, 0, 0 ,
     4, 2, 3, 4, 7, 0, 0 ,
     5, 2, 3, 5, 7, 8, 0 ,
     6, 1, 3, 4, 5, 7, 10  
;

void search(void)

    std::array<int, 7> a2 =  4, 1, 3, 5, 9, 0, 0 ;
    std::array<int, 7> *a1_end = a1 + sizeof(a1) / sizeof(std::array<int, 7>);
    std::array<int, 7> *it = std::lower_bound(a1, a1_end, a2);

【讨论】：

如果您使用的是std::array，为什么不用std::array 的std::array 对象作为矩阵呢？将使search 第二步中的尺寸计算更容易一些。 :)