C++ 传递性比较的优化（A>；B，B>；C=>；A>；C）

这个问题我已经解决了将近一个星期了，我想我需要一些帮助来解决它。我得到了一组这种格式的比较：

5 2 1 2 2 3 3 4 5 4 6 5 5. 2. 1 2 2 3 3 4 5 4 6 5 第一行表示有5个元素可以比较（1-5）
第二行表示将有多少比较语句
从第三行开始是比较语句。第一个元素比第二个元素好。在这种情况下，1>2，2>3，3>4，依此类推

我应该输出比每个元素更好和更差的元素数。 所以没有一个数比元素1好，还有三个数比1（2，3，4）差。我想你明白了。输出应为：

1: better: 0 worse: 3 2: better: 1 worse: 2 3: better: 2 worse: 1 4: better: 5 worse: 0 5: better: 1 worse: 1 6: better: 0 worse: 2 1:较好：0:较差：3 2:较好：1:较差：2 3:较好：2:较差：1 4:较好：5:较差：0 5:较好：1:较差：1 6:更好：0:更差：2 这是我到目前为止对它的实现

class Student{
public:
vector<int> better;
vector<int> worse;
};

void addComp(Student* student, int a, int b){

//push all worse elements into their better elements (there will be    duplicate)
student[a].worse.push_back(b);
vector<int>::iterator bIter = student[b].worse.begin();
vector<int>::iterator aIter = student[a].better.begin();

while (aIter != student[a].better.end())
{
    student[*aIter].worse.push_back(b);
    aIter++;
}

while (bIter != student[b].worse.end())
{
    student[a].worse.push_back(*bIter);

    aIter = student[a].better.begin();
    while (aIter != student[a].better.end())
    {
        student[*aIter].worse.push_back(*bIter);
        aIter++;
    }
    bIter++;
}

//push all better elements into their worse elements (there will be duplicate)
student[b].better.push_back(a);
bIter = student[b].worse.begin();
aIter = student[a].better.begin();

while (bIter != student[b].worse.end())
{
    student[*bIter].better.push_back(a);
    bIter++;
}

while (aIter != student[a].better.end())
{
    student[b].better.push_back(*aIter);

    bIter = student[b].worse.begin();
    while (bIter != student[b].worse.end())
    {
        student[*bIter].better.push_back(*aIter);
        bIter++;
    }
    aIter++;
 }
}

int main()
{
int studentCount, inputCount, testCase;
int a, b;
Student* student;

cin >> testCase;
while (testCase > 0)
{
    //The number of student that will be compared
    cin >> studentCount;

    student = new Student[studentCount + 1];

    //The number of comparison input
    cin >> inputCount;

    while (inputCount > 0)
    {
        cin >> a >> b;
        addComp(student, a, b);
        inputCount--;
    }

    //Start counting the number of better and worse student for each student
    for (int i = 1; i <= studentCount; i++)
    {
        //Remove duplicate from worse array
        sort(student[i].worse.begin(), student[i].worse.end());
        vector<int>::iterator last = std::unique(student[i].worse.begin(), student[i].worse.end());
        student[i].worse.erase(last, student[i].worse.end());

        //Remove duplicate from better array
        sort(student[i].better.begin(), student[i].better.end());
        vector<int>::iterator last2 = std::unique(student[i].better.begin(), student[i].better.end());
        student[i].better.erase(last2, student[i].better.end());

        cout << i " better: " << student[i].better.size() << " worse: " << student[i].worse.size() << endl;
    }
    delete [] student;
    testCase--;
 }
}

班级学生{
公众：
载体较好；
病媒恶化；
};
void addComp（学生*学生，内部a，内部b）{
//将所有较差的元素推入其较好的元素（将出现重复）
学生[a]。更糟。推回（b）；
向量：：迭代器位=学生[b]。更糟。开始（）；
向量：：迭代器aIter=student[a]。更好。开始（）；
while（aIter！=student[a].better.end（）
{
学生[*aIter]。更糟。推回（b）；
aIter++；
}
while（bIter！=student[b]。更糟。end（）
{
学生[a]。更糟。向后推（*bIter）；
aIter=student[a]。更好。begin（）；
while（aIter！=student[a].better.end（）
{
学生[*aIter]。更糟。推回（*bIter）；
aIter++；
}
比特++；
}
//将所有较好的元素推入较差的元素（将有重复）
学生[b]。更好。推回（a）；
bIter=student[b]。更糟。begin（）；
aIter=student[a]。更好。begin（）；
while（bIter！=student[b]。更糟。end（）
{
学生[*咬].更好。推回（a）；
比特++；
}
while（aIter！=student[a].better.end（）
{
学生[b]。更好。推回（*aIter）；
bIter=student[b]。更糟。begin（）；
while（bIter！=student[b]。更糟。end（）
{
学生[*bIter]。更好。推回（*aIter）；
比特++；
}
aIter++；
}
}
int main（）
{
int studentCount、inputCount、testCase；
INTA，b；
学生*学生；
cin>>测试用例；
while（testCase>0）
{
//将被比较的学生人数
cin>>学生人数；
学生=新学生[studentCount+1]；
//比较输入的数量
cin>>输入计数；
而（输入计数>0）
{
cin>>a>>b；
addComp（学生，a，b）；
输入计数--；
}
//开始计算每个学生中好学生和坏学生的数量
对于（inti=1；i如何在addComp中消除重复的元素？
此外，您可以在addComp时对它们进行排序

我建议您使用集合而不是向量，因为集合可能是唯一的。
步骤1.用集合替换向量
步骤2.用插入件替换推回
步骤3.卸下分拣部件

#include <set>
#include <algorithm>
#include <iostream>
using namespace std;

class Student{
public:
set<int> better;
set<int> worse;
};

void addComp(Student* student, int a, int b){

//push all worse elements into their better elements (there will be    duplicate)
student[a].worse.insert(b);
set<int>::iterator bIter = student[b].worse.begin();
set<int>::iterator aIter = student[a].better.begin();

while (aIter != student[a].better.end())
{
    student[*aIter].worse.insert(b);
    aIter++;
}

while (bIter != student[b].worse.end())
{
    student[a].worse.insert(*bIter);

    aIter = student[a].better.begin();
    while (aIter != student[a].better.end())
    {
        student[*aIter].worse.insert(*bIter);
        aIter++;
    }
    bIter++;
}

//push all better elements into their worse elements (there will be duplicate)
student[b].better.insert(a);
bIter = student[b].worse.begin();
aIter = student[a].better.begin();

while (bIter != student[b].worse.end())
{
    student[*bIter].better.insert(a);
    bIter++;
}

while (aIter != student[a].better.end())
{
    student[b].better.insert(*aIter);

    bIter = student[b].worse.begin();
    while (bIter != student[b].worse.end())
    {
        student[*bIter].better.insert(*aIter);
        bIter++;
    }
    aIter++;
 }
}

int main()
{
int studentCount, inputCount, testCase;
int a, b;
Student* student;

cin >> testCase;
while (testCase > 0)
{
    //The number of student that will be compared
    cin >> studentCount;

    student = new Student[studentCount + 1];

    //The number of comparison input
    cin >> inputCount;

    while (inputCount > 0)
    {
        cin >> a >> b;
        addComp(student, a, b);
        inputCount--;
    }

    //Start counting the number of better and worse student for each student
    for (int i = 1; i <= studentCount; i++)
    {
        cout << i << " better: " << student[i].better.size() << " worse: " << student[i].worse.size() << endl;
    }
    delete [] student;
    testCase--;
 }
}

#包括
#包括
#包括
使用名称空间std；
班级学生{
公众：
设置得更好；
环境恶化；
};
void addComp（学生*学生，内部a，内部b）{
//将所有较差的元素推入其较好的元素（将出现重复）
学生[a]。更糟。插入（b）；
set:：iterator bIter=student[b]。更糟。begin（）；
set:：iterator aIter=student[a]。更好。begin（）；
while（aIter！=student[a].better.end（）
{
学生[*aIter]。更糟。插入（b）；
aIter++；
}
while（bIter！=student[b]。更糟。end（）
{
学生[a]。更糟。插入（*比特）；
aIter=student[a]。更好。begin（）；
while（aIter！=student[a].better.end（）
{
学生[*aIter]。更糟。插入（*bIter）；
aIter++；
}
比特++；
}
//将所有较好的元素推入较差的元素（将有重复）
学生[b]。更好。插入（a）；
bIter=student[b]。更糟。begin（）；
aIter=student[a]。更好。begin（）；
while（bIter！=student[b]。更糟。end（）
{
学生[*咬].更好。插入（a）；
比特++；
}
while（aIter！=student[a].better.end（）
{
学生[b]。更好。插入（*aIter）；
bIter=student[b]。更糟。begin（）；
while（bIter！=student[b]。更糟。end（）
{
学生[*bIter]。更好。插入（*aIter）；
比特++；
}
aIter++；
}
}
int main（）
{
int studentCount、inputCount、testCase；
INTA，b；
学生*学生；
cin>>测试用例；
while（testCase>0）
{
//将被比较的学生人数
cin>>学生人数；
学生=新学生[studentCount+1]；
//比较输入的数量
cin>>输入计数；
而（输入计数>0）
{
cin>>a>>b；
addComp（学生，a，b）；
输入计数--；
}
//开始计算每个学生中好学生和坏学生的数量
对于（int i=1；谢谢你的回答。我完全忘记了std:：set。但是它显然还不够快。我在我的机器上测试了它，它在48秒内运行了1000个测试用例。我应该在3以下。我想我必须从一个完全不同的角度来解决它。