Problem:
Problem C: Online Quizu System

ICPC (Internet Contents Providing Company) is working on a killer game named Quiz Millionaire Attack.
It is a quiz system played over the Internet. You are joining ICPC as an engineer, and you are responsible
for designing a protocol between clients and the game server for this system. As bandwidth assigned for
the server is quite limited, data size exchanged between clients and the server should be reduced as much
as possible. In addition, all clients should be well synchronized during the quiz session for a simultaneous
play. In particular, much attention should be paid to the delay on receiving packets.

To verify that your protocol meets the above demands, you have decided to simulate the communication
between clients and the server and calculate the data size exchanged during one game.

A game has the following process. First, players participating and problems to be used are fixed. All
players are using the same client program and already have the problem statements downloaded, so you
don’t need to simulate this part. Then the game begins. The first problem is presented to the players,
and the players answer it within a fixed amount of time. After that, the second problem is presented,
and so forth. When all problems have been completed, the game ends. During each problem phase,
the players are notified of what other players have done. Before you submit your answer, you can know
who have already submitted their answers. After you have submitted your answer, you can know what
answers are submitted by other players.

When each problem phase starts, the server sends a synchronization packet for problem-start to all the
players, and begins a polling process. Every 1,000 milliseconds after the beginning of polling, the server
checks whether it received new answers from the players strictly before that moment, and if there are
any, sends a notification to all the players:

If a player hasn’t submitted an answer yet, the server sends it a notification packet type A describing
others’ answers about the newly received answers.

If a player is one of those who submitted the newly received answers, the server sends it a notification
packet type B describing others’ answers about all the answers submitted by other players (i.e.
excluding the player him/herself’s answer) strictly before that moment.

If a player has already submitted an answer, the server sends it a notification packet type B describing
others’ answers about the newly received answers.

Note that, in all above cases, notification packets (both types A and B) must contain information
about at least one player, and otherwise a notification packet will not be sent.

When 20,000 milliseconds have passed after sending the synchronization packet for problem-start, the
server sends notification packets of type A or B if needed, and then sends a synchronization packet for
problem-end to all the players, to terminate the problem.

On the other hand, players will be able to answer the problem after receiving the synchronization packet
for problem-start and before receiving the synchronization packet for problem-end. Answers will be sent
using an answer packet.

The packets referred above have the formats shown by the following tables.

Input

The input consists of multiple test cases. Each test case begins with a line consisting of two integers
M and N (1 ≤ M, N ≤ 100), denoting the number of players and problems, respectively. The next
line contains M non-negative integers D0 , D1 , . . . , DM - 1 , denoting the communication delay between
each players and the server (players are assigned ID’s ranging from 0 to M - 1, inclusive). Then follow
N blocks describing the submissions for each problem. Each block begins with a line containing an
integer L, denoting the number of players that submitted an answer for that problem. Each of the
following L lines gives the answer from one player, described by three fields P, T, and A separated by a
whitespace. Here P is an integer denoting the player ID, T is an integer denoting the time elapsed from the reception of synchronization packet for problem-start and the submission on the player’s side, and A
is an alphanumeric string denoting the player’s answer, whose length is between 1 and 9, inclusive. Those
L lines may be given in an arbitrary order. You may assume that all answer packets will be received by
the server within 19,999 milliseconds (inclusive) after sending synchronization packet for problem-start.

The input is terminated by a line containing two zeros.

Output

For each test case, you are to print M + 1 lines. In the first line, print the data size sent and received
by the server, separated by a whitespace. In the next M lines, print the data size sent and received by
each player, separated by a whitespace, in ascending order of player ID. Print a blank line between two
consecutive test cases.

Sample Input

3 2
1 2 10
3
0 3420 o
1 4589 o
2 4638 x
3
1 6577 SUZUMIYA
2 7644 SUZUMIYA
0 19979 YASUZUMI
4 2
150 150 150 150
4
0 1344 HOGEHOGE
1 1466 HOGEHOGE
2 1789 HOGEHOGE
3 19100 GEHO
2
2 1200 SETTEN
3 700 SETTEN
0 0

Output for the Sample Input

177 57
19 58
19 57
19 62

253 70
13 58
13 58
24 66
20 71

Solution in C++ (judge verdict: Accepted)

#include<iostream>
#include<string>
#include<vector>
#include<map>
using namespace std;

struct Answer{
  int player;
  int time_sent;
  int time_rec;
  string answer;
};

int main()
{
  int n, m;
  bool first = true;
  while( cin >> n >> m && n && m ){
    int delay[n];
    int server_sent = 0;
    int server_rec  = 0;
    int sent[n];
    int rec[n];

    if( !first ){
      cout << endl;
    }else first = false;
    
    for(int i = 0; i < n; ++i){
      cin >> delay[i];
      sent[i] = 0;
      rec[i] = 0;
    }

    for(int prob = 0; prob < m; ++prob){
      int L;
      map<int,vector<Answer> > all_ans;

      // problem-start
      server_sent += 3*n;
      for(int i = 0; i < n; ++i){
        rec[i] += 3;
      }
      
      cin >> L;
      for(int i = 0; i < L; ++i){
        Answer ans;
        cin >> ans.player >> ans.time_sent >> ans.answer;
        //cout << ans.player << ' ' << ans.time_sent << ' ' << ans.answer << endl;
        ans.time_rec = ans.time_sent + 2*delay[ans.player];
        all_ans[ ans.time_rec ].push_back( ans );
        
        server_rec += 3+1+1+ans.answer.length();
        sent[ans.player] += 3+1+1+ans.answer.length();
      }

      int time = 1000;
      bool old_submit[n];
      bool new_submit[n];
      Answer submit_answer[n];
      vector<Answer> old_ans;
      vector<Answer> new_ans;
      
      for(int i = 0; i < n; ++i){
        old_submit[i] = false;
        new_submit[i] = false;
      }

      while(time <= 20000 ){
        //cout << "TIME : <" << time << endl;
        for(int i = 0; i < (int)new_ans.size(); ++i){
          old_ans.push_back( new_ans[i] );
        }
        for(int i = 0; i < n; ++i){
          //cout << sent[i] << ' ' << rec[i] << endl;
          if( new_submit[i] ){
            old_submit[i] = new_submit[i];
          }
        }
        //cout << endl;

        new_ans.clear();
        for(int i = 0; i < n; ++i){
          new_submit[i] = false;
        }
  
        //cout << endl;

        map<int,vector<Answer> >::iterator it = all_ans.lower_bound(time - 1000);
        for(;it!=all_ans.end()&&it->first<time;++it){
          // for newly recieved
          //cout << it->first <<endl;
          for(int i = 0; i < (int)it->second.size(); ++i){
            new_ans.push_back( it->second[i] );
            new_submit[ it->second[i].player ] = true;
            submit_answer[ it->second[i].player ] = it->second[i];
          }
        }


        for(int i = 0; i < n; ++i){
          //cout << old_submit[i]  << ' ' << new_submit[i] << endl;
        }
        
        
        for(int i = 0; i < n; ++i){
          if( !old_submit[i] && !new_submit[i] ){
            // not yet submitted
            int sent_b = 3+1+new_ans.size();
            if( new_ans.size() > 0 ){
              server_sent += sent_b;
              rec[i] += sent_b;
            }
            //cout << new_ans.size() << ' ' << "not yet " << i << ' ' << sent_b << endl;
          }
          else if( old_submit[i] && !new_submit[i] ){
            // submitted but not newly
            int sent_b = 3+1;
            int cnt=0;
            for(int j = 0; j < (int)new_ans.size(); ++j){
              ++cnt;
              sent_b += 1+1+new_ans[j].answer.length();
            }
            if( cnt > 0 ){
              server_sent += sent_b;
              rec[i] += sent_b;
            }
            //cout << cnt << " old submit " << i << ' ' << sent_b << endl;
          }
          else if( new_submit[i] ){
            // submitted newly
            int sent_b = 3+1;
            int cnt = 0;
            for(int j = 0; j < (int)new_ans.size(); ++j){
              if( new_ans[j].player != i ){
                ++cnt;
                sent_b += 1+1+new_ans[j].answer.length();
              }
            }
            for(int j = 0; j < (int)old_ans.size(); ++j){
              if( old_ans[j].player != i ){
                ++cnt;
                sent_b += 1+1+old_ans[j].answer.length();
              }
            }
            
            if( cnt > 0 ){
              server_sent += sent_b;
              rec[i] += sent_b;
            }
            //cout << cnt << " newly " << i << ' ' << sent_b << endl;
          }
        }
 
        time += 1000;
      }
      // problem-end
      server_sent += 4*n;
      for(int i = 0; i < n; ++i){
        rec[i] += 4;
      }
      
    }


    cout << server_sent << ' ' << server_rec << endl;
    for(int i = 0; i < n; ++i){
      cout << sent[i] << ' ' << rec[i] << endl;
    }

  }
  return 0;
}