POJ1030 Rating

题目来源：http://poj.org/problem?id=1030

题目大意：有100支队伍（编号1->100），有两场比赛。以下表的形式列出了两场比赛的名次。（有的队伍没有参赛或只参加了一场比赛。）

要求两场比赛的总排名。计算规则是：

1.如果某队两场都比另一队排名靠前（或一场赢一场平），则总排名靠前。

2.如果两队在两场比赛中各赢一场，则他们的排名取决于他们在两场比赛中的排名差。如上面的例子中1队在比赛1中赢了5队，名次差为3，在比赛2中输给5对，名次差为1，所以1队应排在5队前面。如果两个名次差相等，则两队的总排名相等。两队两场比赛都平局时总排名也相等。

3.对于只参加了一次比赛的队伍，他们的最终排名不一定能够确定。他们能否进入最终名单由下面的规则决定：

A) 如果存在某支队伍参加了两场比赛，与该队伍平局，那么这个队伍的排名与这支参加两场的排名一致。如果有多支这样的队伍，他们的排名应该完全相同，否则所有的队伍排名都不能决定。

B) 如果能为只参加了一场比赛c的一支队伍A找到一个位置，使得这个位置之前的队伍在c中都赢了A，该位置之后的队伍在c中都输给A，则可以把A插入到该位置，如果有多个队伍可以插到该位置，按他们在各自比赛中获得的名次决定先后顺序或并列。

对于上面图片所示的例子，分析过程如下：

Team 3 will occupy the first place in the overall list (rule B). 
The positions of teams 6 and 7 cannot be determined. 
Team 10 will share the overall rating with team 1 (rule A). 
Team 20 will share the overall rating with team 4 (rule A). 
Team 19 will occupy the position between teams 9, 5 and team 4 (rule B). 
Teams 8, 15, 17, 18, 21, and 31 will finish the overall list (rule B). But the first of them will be teams 15 and 8 (that took 6th place) followed by teams 31 and 18 (that took 8th place) and teams 17 and 21 (that took 10th place). 
程序的目标是由两场比赛的排名求总排名。

输入：两场比赛中表格中team's id部分。

输出：同样形式的总排名。

---

Sample Input

6
9
7 1 4
5
15 8
31 18
17

8
3
5
1 10
6
9
19
4 20
21

Sample Output

3
1 10
5 9
19
4 20
8 15
18 31
17 21

---

我的程序写得比较复杂了，按照每条规则为每个队伍找排名。一个处理是在计算时把排名设定为浮点数而不是整数，这样在进行插入的时候不会需要移动很多队伍的名次，最要最后整理的时候映射为整数即可。

//////////////////////////////////////////////////////////////////////////
//        POJ1030 Rating
//        Memory: 320K        Time: 94MS
//        Language: C++        Result: Accepted
//////////////////////////////////////////////////////////////////////////

#include <iostream>
#include <stdio.h>
#include <map>
#include <list>

using namespace std;

int cnt[101];
int rank1[101];
int rank2[101];
float rank[101];
float buff[101];
bool tag[101];
map<int, list<int>> record1;
map<int, list<int>> record2;
int k1, k2;

struct Rate {
    float rank;
    list<int> teams;
    Rate * next;
};
Rate * head = NULL;

float compRank(Rate * a, Rate * b) {
    return a->rank - b->rank;
}
bool cmp(const void * a, const void * b) {
    return *(int *)a > *(int *)b ? true : false; 
}
void exchangeRank(Rate *a, Rate * b) {
    float rank = a->rank;
    list<int> teams = a->teams;
    a->rank = b->rank;
    a->teams = b->teams;
    b->rank = rank;
    b->teams = teams;
}
void sortRank() {
    if (head == NULL || head->next == NULL) {
        return;
    }
    Rate * key = head->next;
    Rate * p = head;
    while (key != NULL) {
        while (p != key) {
            if (compRank(p, key) > 0) {
                exchangeRank(p, key);
            }
            p = p->next;
        }
        p = head;
        key = key->next;
    }
}
void readData() {
    char buf[10000];
    int teamId;
    int teamCnt;
    char * pCur;
    int rankSum = 0;
    int rankCur = 0;

    gets(buf);
    sscanf(buf, "%d", &k1);
    for (int i = 0; i < k1; ++i) {
        gets(buf);
        rankCur = rankSum + 1;
        pCur = strtok(buf, " ");
        list<int> ts;
        while (pCur) {
            ++rankSum;
            teamId = atoi(pCur);
            ++cnt[teamId];
            rank1[teamId] = rankCur;
            ts.push_back(teamId);
            pCur = strtok(NULL, " ");
        }
        record1[rankCur] = ts;
    }
    getchar();
    gets(buf);
    sscanf(buf, "%d", &k2);
    rankSum = rankCur = 0;
    for (int i = 0; i < k2; ++i) {
        gets(buf);
        rankCur = rankSum + 1;
        pCur = strtok(buf, " ");
        list<int> ts;
        while (pCur) {
            ++rankSum;
            teamId = atoi(pCur);
            ++cnt[teamId];
            rank2[teamId] = rankCur;
            ts.push_back(teamId);
            pCur = strtok(NULL, " ");
        }
        record2[rankCur] = ts;
    }
}

void cc2() {
    for (int i = 1; i <= 100; ++i) {
        if (cnt[i] == 2) {
            rank[i] = rank1[i] + rank2[i];
        }
    }
    for (int i = 1; i <= 200; ++i) {
        Rate * rate = new Rate;
        rate->rank = i;
        for (int j = 1; j <= 100; ++j) {
            if (rank[j] == i) {
                rate->teams.push_back(j);
            }
        }
        if (!rate->teams.empty()) {
            rate->next = head;
            head = rate;
        }
    }
}

void cc1() {
    for (int i = 1; i <= 100; ++i) {
        if (cnt[i] != 1) {
            continue;
        }
        int r;
        int p;
        if (rank1[i] != 0) {
            r = rank1[i];
            p = 1;
        } else {
            r = rank2[i];
            p = 2;
        }
        int count = 0;
        list<int> temp;
        if (p == 1) {
            temp = record1[r];
        } else {
            temp = record2[r];
        }
        list<int> eq;
        for (list<int>::iterator it = temp.begin(); it != temp.end(); ++it) {
            if (cnt[*it] == 2) {
                eq.push_back(*it);
            }    
        }
        if (!eq.empty()) {
            int rc = rank[eq.front()];
            bool flag = true;
            for (list<int>::iterator it = eq.begin(); it != eq.end(); ++it) {
                if (rank[*it] != rc) {
                    rank[i] = 0;
                    flag = false;
                    break;
                }
            }
            if (flag == true) {
                for (Rate * p = head; p != NULL; p = p->next) {
                    if (p->rank == rc) {
                        p->teams.push_back(i);
                        break;
                    }
                }
            }
        } else {
            tag[i] = true;
        }
    }
    for (int i = 1; i <= 100; ++i) {
        if (tag[i] != true) {
            continue;
        }
        int p; 
        int r;
        if (rank1[i] != 0) {
            r = rank1[i];
            p = 1;
        } else {
            r = rank2[i];
            p = 2;
        }
        int * temp = (p == 1) ? rank1 : rank2;
        int prior = -1;
        int next = 101;
        for (int j = 1; j <= 100; ++j) {
            if (temp[j] != 0 && temp[j] < r && rank[j] != 0) {
                if (rank[j] > prior) {
                    prior = rank[j];
                }
            }
            if (temp[j] != 0 && temp[j] > r && rank[j] != 0) {
                if (rank[j] < next) {
                    next = rank[j];
                }
            }

        }
        if (next > prior) {
            buff[i] = (next + prior) / 2.0;
        }
    }
}

void insertcc1() {
    for (int i = 1; i <= 100; ++i) {
        if (buff[i] == 0) {
            continue;
        }
        float fr = buff[i];
        Rate * p = head;
        Rate * rate = new Rate;
        rate->rank = fr;
        rate->teams.push_back(i);
        if (head == NULL || fr < head->rank) {
            rate->next = head;
            head = rate;
            continue;
        } else if (fr == head->rank) {
            int t1 = rank1[i] > 0 ? rank1[i] :rank2[i];
            int t2 = rank1[head->teams.front()] > 0 ?rank1[head->teams.front()] : rank2[head->teams.front()]; 
            if (t1 == t2) {
                head->teams.push_back(i);
                continue;
            } else if (t1 < t2) {
                rate->next = head;
                head = rate;
                continue;
            }
        }
        Rate * q = p->next;
        bool f = false;
        while(q != NULL) {
            if (fr < q->rank) {
                rate->next = q;
                p->next = rate;
                f = true;
                break;
            } else if (fr == q->rank) {
                int t1 = rank1[i] > 0 ? rank1[i] :rank2[i];
                int t2 = rank1[q->teams.front()] > 0 ?rank1[q->teams.front()] : rank2[q->teams.front()]; 
                if (t1 == t2) {
                    q->teams.push_back(i);
                } else if (t1 < t2) {
                    rate->next = q;
                    p->next = rate;
                } else {
                    if (q->next == NULL) {
                        rate->next = q->next;
                        q->next = rate;
                    } else{
                        int t3 = rank1[q->next->teams.front()] > 0 ? rank1[q->next->teams.front()] : rank2[q->next->teams.front()];
                        if (t3 > t1) {
                            rate->next = q->next;
                            q->next = rate;
                        } else {
                            p = p->next;
                            q = q->next;
                            continue;
                        }
                    }
                }
                f = true;
                break;
            }
            p = p->next;
            q = q->next;
        }
        if (f == true) {
            continue;
        }
        rate->next = NULL;
        p->next = rate;
    }
}
void output() {
    for (Rate * p = head; p != NULL; p = p->next) {
        p->teams.sort();
        for (list<int>::iterator it = p->teams.begin(); it != p->teams.end(); ++it) {
            if (*it != p->teams.back()) {
                cout << *it << " ";
            } else {
                cout << *it;
                if (p->next != NULL) {
                    cout << endl;
                }
            }
        }
    }
}
int main () {
    readData();
    cc2();
    sortRank();
    cc1();
    insertcc1();
    output();
    system("pause");
    return 0;
}

必须承认代码写得很拙劣,不过思路还是能看得比较清晰吧。