C++ 反向C+中的唯一数据+；

不知道如何用最好的方式来表达，但我希望得到相反的唯一数据。我举个例子会更好

如果我有数据

0 1
0 3
0 4
1 0
1 2
1 5
3 0

我怎样才能摆脱与自身相反的数据？例如：0 1和1 0，我想摆脱1 0，因为我已经看到0 1。另一个例子：03和30，我想去掉30，因为我已经看到03了

所以数据应该是这样的：

0 1
0 3
0 4
1 2
1 5

这是我的代码，用于说明数据是如何产生的

int temp;
    int tn;
    for (int i=0; i < n-1; i++)
    {
        for (int j=0; j< 4; j++)
        {
            temp = grid[i].neighbor[j];
            tn = get_neighbor(j);

            cout << i << " " << grid[i].neighbor[j] <<endl; //index

        }

    }

int-temp；
int tn；
对于（int i=0；i
2） 检查是否有重复项（正常，而不是相反）

3） 删除发现的任何重复项

4） 循环检查并对照每个项目的反面检查每个项目（两个循环）

步骤1/2 / 3可以合并到步骤4，以减少迭代，或者可以被分离成A。C++中的一个集合将自动删除步骤2和3的重复，以及对值进行排序，这是检查一些STL材料（标准模板库）的好机会。.
如果您可能不想更改原始向量元素的顺序，那么简单的方法如下

std::vector<std::vector<int>> v;

int a[][2] = { { 0, 1 }, { 0, 3 }, { 0, 4 }, { 1, 0 }, { 1, 2 }, { 1, 5 }, { 3, 0 } };

std::transform( std::begin( a ), std::end( a ), std::back_inserter( v ),
                []( const int ( &row )[2] ) 
                { 
                    return std::vector<int>( std::begin( row ), std::end( row ) );
                } );

for ( const std::vector<int> &row : v )
{
    for ( int x : row ) std::cout << x << ' ';
    std::cout << std::endl;
}

std::cout << std::endl;

std::function<bool( const std::vector<int> &, const std::vector<int> & )>  identical = 
[]( const std::vector<int> &v1, const std::vector<int> &v2 )
{
    return ( v1.size() == v2.size() && v1.size() == 2 &&
        ( v1[0] == v2[0] && v1[1] == v2[1] || v1[0] == v2[1] && v1[1] == v2[0] ) );
};

auto last = v.begin();

for ( auto first = v.begin(); first != v.end(); ++first )
{
    using namespace std::placeholders;
    if ( std::find_if( v.begin(), last, std::bind( identical, _1, *first ) ) == last )
    {
        if ( first != last ) *last = *first;
        ++last;
    }
}

v.erase( last, v.end() );

for ( const std::vector<int> &row : v )
{
    for ( int x : row ) std::cout << x << ' ';
    std::cout << std::endl;
}

我对如何实现这一点有一个想法，仅供分享，请不要否决我的答案

这里的关键点是如何识别两个反向对，当然我们可以对它们进行比较，但肯定有更优雅的方法来做到这一点

如果您的数字在某个固定范围整数中，例如
0..10
，那么您可以像这样定义一个素数数组
prime\u arr=[2,3,5,7,11,13,17,19,23,29,31]
，现在我们可以看到两对
和
是相同的还是相反的，我们只需比较
prime\u arr[x]*prime\u arr[y]
和
prime\u arr[a]*prime\u arr[b]

哦，这只是一个例子，如果你的数字不是固定的范围，但是所有的<强>非负整数< /强>，你可以考虑<代码> x^ 2 +y^ 2 < /代码>，如果两个对<代码> <代码>和<代码> <代码>是相同的或相反的，比较<代码> x^ 2 +y^ 2 < /C>和<代码> a^ 2 +b^ 2 < /Cord>
这里是一个演示实现，希望对您有用
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    vector<pair<int, int>> v = { { 0, 1 }, { 0, 3 }, { 0, 4 },
        { 1, 0 }, { 1, 2 }, { 1, 5 }, { 3, 0 }};
    vector<int> flagv;
    for (auto p : v) {
        int flag = p.first * p.first + p.second * p.second;
        if (find(flagv.begin(), flagv.end(), flag) == flagv.end()) {
            cout << p.first << " " << p.second << endl;
            flagv.push_back(flag);
        }
    }
    return 0;
}

#包括
#包括
#包括
使用名称空间std；
int main（）{
向量v={0,1}，{0,3}，{0,4}，
{ 1, 0 }, { 1, 2 }, { 1, 5 }, { 3, 0 }};
矢量flagv；
用于（自动p:v）{
int flag=p.first*p.first+p.second*p.second；
如果（查找（flagv.begin（），flagv.end（），flag）=flagv.end（））{
不能只需使用比较器使配对正常化：

typedef std::pair<int,int> ipair;
typedef std::vector<ipair> ipvector;

inline
ipair norm( const ipair &p )
{
    return ipair{ std::min( p.first, p.second ), std::max( p.first, p.second ) };
}

struct norm_cmp {
    bool operator()( const ipair &p1, const ipair &p2 )
    {
        return norm( p1 ) < norm( p2 );
    }
};

int main()
{
    ipvector v = { { 0, 1 }, { 0, 3 }, { 0, 4 },
                { 1, 0 }, { 1, 2 }, { 1, 5 }, { 3, 0 }};

    std::set<ipair, norm_cmp> s( v.begin(), v.end() );
    for( const ipair &p : s )
        std::cout << '{' << p.first << ',' << p.second << '}' << std::endl;
}

typedef std:：pair ipair；
typedef std：：向量ipvector；
内联
ipair标准（常数ipair&p）
{
返回ipair{std:：min（p.first，p.second），std:：max（p.first，p.second）}；
}
结构规范{
布尔运算符（）（常量ipair和p1、常量ipair和p2）
{
返回范数（p1）<范数（p2）；
}
};
int main（）
{
ipvector v={0,1}，{0,3}，{0,4}，
{ 1, 0 }, { 1, 2 }, { 1, 5 }, { 3, 0 }};
std:：set s（v.begin（），v.end（））；
适用于（const ipair&p:s）
std：：不能按升序对每一行进行排序并删除重复行吗？你能举个例子吗？我现在有点头脑呆滞：（排序的例子？当然：3，1，2=>1，2，3。我只是不知道如何实现。对不起，我对编码很陌生。你能告诉我是怎么做到的吗？
typedef std::pair<int,int> ipair;
typedef std::vector<ipair> ipvector;

inline
ipair norm( const ipair &p )
{
    return ipair{ std::min( p.first, p.second ), std::max( p.first, p.second ) };
}

struct norm_cmp {
    bool operator()( const ipair &p1, const ipair &p2 )
    {
        return norm( p1 ) < norm( p2 );
    }
};

int main()
{
    ipvector v = { { 0, 1 }, { 0, 3 }, { 0, 4 },
                { 1, 0 }, { 1, 2 }, { 1, 5 }, { 3, 0 }};

    std::set<ipair, norm_cmp> s( v.begin(), v.end() );
    for( const ipair &p : s )
        std::cout << '{' << p.first << ',' << p.second << '}' << std::endl;
}