按块比较两个向量时如何避免重复

Question

我正在尝试比较两个大小为 4 的倍数的向量，并且数据以块（4 个元素）表示。每个向量块都有一个唯一的编号，例如 {0,0,0,0}, {0,0,0,1}, {0,0,0,2} 或 {0,0,0,0,0, 0,0,1,0,0,0,2} 和 {0,0,0,2,0,0,0,1} 等等。我正在使用每次递增 i+=4 的迭代器。我写了一个小函数来完成这项工作，但块往往会重复。我不确定如何 t0 删除这些块的重复。例如 vector_A {0,0,0,0,0,0,0,1} vector_B {0,0,0,1,0,0,0,0,0,0,0,2} 它应该给出 local_vector1 { 0,0,0,2} 而不是我得到本地 vector_1 {0,0,0,1,0,0,0,2,0,0,0,0,0,0,0,2}

void comparing_vectors_by_block(std::vector<int> vector_A, std::vector<int> 
vector_B)
{
const int blockSize = 4;
std::vector<int> local_vector1;
std::cout << "size of the vector_A: " << vector_A.size() << std::endl;
std::cout << "size of the vector_B: " << vector_B.size() << std::endl;

for (auto it_A = std::begin(vector_A); it_A != std::end(vector_A); it_A+=4)
{
    for (auto it_B = std::begin(vector_B); it_B != std::end(vector_B); it_B += 4)
    {
        bool match = equal(it_A, it_A + blockSize, it_B, it_B + blockSize);
        if (!match)
        {
            std::cout << "match :" << std::endl;
            local_vector1.insert(local_vector1.end(), it_B, it_B + blockSize);
        }
        else
        {
            std::cout << "not matched :" << std::endl;
        }
    }
}

Answer 1

使用由四个整数组成的数组向量来表示数据。 std::vector<std::array<int,4>> vect1;

如果这个数据有其他含义。最好使用OOP方式并创建 一个结构或一个类来表示这四个数字数据。然后为结构/类实现运算符== 和其他有用的方法。

struct foo{
    int a;
    int b;
    int c;
    ind d;
};
bool foo::operator==(const X& lhs, const X& rhs){ /* do actual comparison */ }

然后只需迭代向量并使用 == 比较元素，就像向量类型为 int 时所做的那样。

for(auto& x : vector_A)
{
    if(std::find(vector_B.begin(), vector_B.end(), x) != vector_B.end()) {
         local_vector1.append(x);
    }
}

Answer 2

如果我没听错，你想得到两个块向量的对称差。 IE。对于 A = {0,0,0,3,0,0,0,0,0,0,0,1} 和 B = {0,0,0,1,0,0,0,0,0, 0,0,2} 你想要 local_vector1 = {0,0,0,3,0,0,0,2}。

在您的实现中，您将向量 A 的每个块与向量 B 的每个块进行比较——当然，您会得到额外的不匹配。我的（也是未优化的）解决方案：

std::vector<int> get_blocked_vectors_diff( const std::vector<int>& vector_A, const std::vector<int>& vector_B )
{
    const int blockSize = 4;
    std::vector<int> local_vector;
    for ( auto it_A = std::begin( vector_A ); it_A != std::end( vector_A ); it_A += 4 )
    {
        bool found_in_B = false;
        for ( auto it_B = std::begin( vector_B ); !found_in_B && it_B != std::end( vector_B ); it_B += 4 )
        {
            found_in_B = std::equal( it_A, it_A + blockSize, it_B, it_B + blockSize );
        }
        if ( !found_in_B )
        {
            local_vector.insert( local_vector.end( ), it_A, it_A + blockSize );
        }
    }

    return local_vector;
}

void comparing_vectors_by_block(std::vector<int> vector_A, std::vector<int> vector_B)
{
    auto A_mines_B = get_blocked_vectors_diff( vector_A, vector_B );
    auto B_mines_A = get_blocked_vectors_diff( vector_B, vector_A );
    auto local_vector1( A_mines_B );
    local_vector1.insert( local_vector1.end(), B_mines_A.begin( ), B_mines_A.end( ) );

    for ( auto a : local_vector1 )
    {
         std::cout << a << " ";
    }
    std::cout << std::endl;
}

注意，我们需要答案的两部分：A\B 和 B\A，所以 get_blocked_vectors_diff 被调用了两次。

如果您像 Petar Velev 建议的那样更改数据结构，您将能够缩短 get_blocked_vectors_diff 函数：

std::vector<int> get_blocked_vectors_diff( const std::vector<Block>& vector_A, const std::vector<Block>& vector_B )
{
    std::vector<Block> local_vector;
    for ( auto& x : vector_A )
    {
        if ( std::find( vector_B.begin( ), vector_B.end( ), x ) == vector_B.end( ) )
        {
            local_vector.push_back( x );
        }
    }

    return local_vector;
}

如果首先对块向量进行排序，可以获得更好的解决方案。