URAL 1736 Chinese Hockey（网络最大流）

Description

Sergey and Denis closely followed the Chinese Football Championship, which has just come to an end. They supported the Katraps andKomolotiv teams, but, unfortunately, these teams tied for last place in the championship. Sergey was so disappointed that he suggested Denis that they change to hockey fans.

There are n teams competing in the Chinese Ice Hockey Championship. During the season, each team must play with each other team exactly one game. If a team wins in the regulation time, it gets 3 points and the losing team gets 0 points. If the regulation time is ended in a draw, then the overtime is played. The team that wins in the overtime gets 2 points and the team that loses gets 1 point. A game can't end in a draw in ice hockey.

Denis wants to determine which team he will support. In order to make the choice, he has found a table on the Web in which it is shown for each team how many points it scored in the last year's season. Sergey suspects that there is a mistake in this table because no all-play-all tournament could end with such results. Is Sergey right?

Input

The first line contains the integer n (2 ≤ n ≤ 200). The second line contains n space-separated non-negative integers; they are the scores of the teams in the previous championship. The scores are given in the non-increasing order. The sum of all the scores is 3n(n–1)/2. None of the teams scored more than 3(n–1) points.

Output

If Sergey is right and there is a mistake in the table, output “INCORRECT” in the only line. Otherwise, in the first line output “CORRECT” and in the following n(n–1)/2 lines output the results of the games. Each result must have the form “i ? j”, where i and j are the numbers of the teams that played the game and ? can be <, <=, >=, or >, which means that the first team lost in the regulation time, lost in the overtime, won in the overtime, and won in the regulation time, respectively. The teams are numbered from 1 to n in the order in which they are given in the input.

题目大意：有n支队，每两队之间进行一场比赛，胜者得3分，败者0分。若为加时赛胜利者2分，败者1分。现在给所有队伍比完赛的得分，问有没有可能构造出这个得分，并输出得到这个得分的每一场比赛的结果。

思路：构建网络流。新开源点S汇点T，从源点到每一场比赛连一条容量为3的边，从每一场比赛到这场比赛的双方连一条边，容量为无穷大（大于等于3就行），从每一支队到汇点连一条边，容量为这个队伍的最终得分。若满流，则有解。每场比赛到比赛双方的边的流量，就是这场比赛某方的得分。

代码（31MS）：

 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #include <queue>
 using namespace std;

 const int MAXN =  * ;
 const int MAXE = MAXN * ;
 const int INF = 0x3fff3fff;

 struct SAP {
     int head[MAXN], pre[MAXN], dis[MAXN], cur[MAXN], gap[MAXN];
     int next[MAXE], to[MAXE], cap[MAXE], flow[MAXE];
     int n, ecnt, st, ed;

     void init() {
         memset(head, , sizeof(head));
         ecnt = ;
     }

     void add_edge(int u, int v, int c) {
         to[ecnt] = v; cap[ecnt] = c; flow[ecnt] = ; next[ecnt] = head[u]; head[u] = ecnt++;
         to[ecnt] = u; cap[ecnt] = ; flow[ecnt] = ; next[ecnt] = head[v]; head[v] = ecnt++;
     }

     void bfs() {
         memset(dis, 0x3f, sizeof(dis));
         queue<int> que; que.push(ed);
         dis[ed] = ;
         while(!que.empty()) {
             int u = que.front(); que.pop();
             ++gap[dis[u]];
             for(int p = head[u]; p; p = next[p]) {
                 int &v = to[p];
                 if(cap[p ^ ] && dis[v] > n) {
                     dis[v] = dis[u] + ;
                     que.push(v);
                 }
             }
         }
     }

     int Max_flow(int ss, int tt, int nn) {
         st = ss, ed = tt, n = nn;
         int ans = , minFlow = INF, u;
         for(int i = ; i <= n; ++i) {
             cur[i] = head[i];
             gap[i] = ;
         }
         bfs();
         u = pre[st] = st;
         while(dis[st] < n) {
             bool flag = false;
             for(int &p = cur[u]; p; p = next[p]) {
                 int &v = to[p];
                 if(cap[p] > flow[p] && dis[u] == dis[v] + ) {
                     flag = true;
                     minFlow = min(minFlow, cap[p] - flow[p]);
                     pre[v] = u;
                     u = v;
                     if(u == ed) {
                         ans += minFlow;
                         while(u != st) {
                             u = pre[u];
                             flow[cur[u]] += minFlow;
                             flow[cur[u] ^ ] -= minFlow;
                         }
                         minFlow = INF;
                     }
                     break;
                 }
             }
             if(flag) continue;
             int minDis = n - ;
             for(int p = head[u]; p; p = next[p]) {
                 int &v = to[p];
                 if(cap[p] > flow[p] && dis[v] < minDis) {
                     minDis = dis[v];
                     cur[u] = p;
                 }
             }
             if(--gap[dis[u]] == ) break;
             ++gap[dis[u] = minDis + ];
             u = pre[u];
         }
         return ans;
     }
 } G;

 int n, a[];
 int game_id[][];

 int main() {
     scanf("%d", &n);
     for(int i = ; i <= n; ++i) scanf("%d", &a[i]);
     G.init();
     int ss = n + n * (n - ) /  + , tt = ss + ;
     int cnt = n + ;
     for(int i = ; i <= n; ++i) {
         G.add_edge(i, tt, a[i]);
         for(int j = i + ; j <= n; ++j) {
             game_id[i][j] = G.ecnt;
             G.add_edge(cnt, i, );
             G.add_edge(cnt, j, );
             G.add_edge(ss, cnt, );
             ++cnt;
         }
     }
     if(G.Max_flow(ss, tt, tt) !=  * n * (n - ) / ) puts("INCORRECT");
     else {
         puts("CORRECT");
         for(int i = ; i <= n; ++i) {
             for(int j = i + ; j <= n; ++j) {
                 switch(G.flow[game_id[i][j]]) {
                     case :printf("%d < %d\n", i, j);break;
                     case :printf("%d <= %d\n", i, j);break;
                     case :printf("%d >= %d\n", i, j);break;
                     case :printf("%d > %d\n", i, j);break;
                 }
             }
         }
     }
 }