Problem:
Problem F: Cosmic Market
Cosmic market(コズミック・マーケット)、通称コズミケ、は全宇宙最大規模の同人即売会だ。
コズミケにはあらゆるジャンルの同人愛好家達が集う。
近年、コズミケへの来場者は増加傾向にある。
最初から全ての人が入場できると大変混雑して危険なので、開場直後は入場規制を行っている。
ある一定人数の人だけが開場と同時に入場することが出来るのだ。
それ以外の人たちはしばらく待ってからの入場となっている。
しかし先着順に会場に入ることにすると、徹夜で前日から並ぶ人が出てしまう。
コズミケの参加者には未成年も多く、治安上の問題もあるので先着順という決め方はとても良くない。
そういう理由があって、コズミケでは参加者の中である種のゲームを行い、そのゲームで勝ち残った人が最初に入場する権利を手にできる。
公平を期すために毎年ランダム性の高いゲームを採用している。
僕は今回もコズミケに参加する予定だ。
僕は今回のコズミケでどうしても手に入れたい同人誌がある。
とある人気サークルが頒布する同人誌で、今年の春に話題になった魔法少女のアニメを取り扱っている。
しかし、このサークルはとても人気で毎回すぐに頒布が終了してしまう。
開場と同時に入場できなかった場合に手に入れることはほぼ不可能だろう。
もちろん後日同人ショップなどでも手に入るようになるのは間違いない。しかしそれまで我慢することなど僕には出来ない。
僕はどんな手を使ってでもコズミケ当日に手に入れなくてはいけないのだ。
不幸なことに僕は今までのコズミケで最初に入場できたことは一度もない。
コズミケのカタログによると、今回は以下のようなゲームで最初に入場できる人を選ぶらしい。
まず参加者のうち先着
r
×
c
人の人が、
r
×
c
のグリッドのように配置された座席の好きな場所に座る。
先着順で場所を選べるので早く行った方が選択肢が沢山ある。
r
×
c
人の人が座ったらゲームが始まる。
このゲームはある一定の回数、ある1つの列（行）の座席にいる全ての人に対して、着席、あるいは起立が指示される。
すでに着席している人に着席の指示が出された場合はそのまま待機すれば。起立している人も同様である。
この指示が出される対象の列（行）と指示の内容はランダムにルーレットで決められる。
ある一定の回数の指示が終わった時点で起立している人だけが最初に開場に入れるのだ。
指示の回数は参加者には知らされていないので、いつゲームが終わるか分からない。
なのである時点で立っている人も座っている人も自分が最初に入場できるかは分からない。
だからスリルを味わうことが出来る、とカタログでは強調されている。
コズミケ前日の午後1時、僕は今年のゲームに関するデータをすべて手に入れた。
僕が手に入れた情報によると、この指示の回数、
q
はすでに決まっている。
それどころか
q
回の指示内容が全てがすでに決まっている。
ランダム性が高いなどといわれているがそれは嘘だったのだ。
どういう理由があって事前に決まっているのかは分からない。
しかしこの情報は僕にとっては天の恵みのようだ。
もしこのデータどおりにゲームが行われれるのであれば、最初に入場することが出来る座席の場所が全て分かる。
最悪の場合、僕以外の参加者全員がこの情報を得ていたとしてみよう。
そんな場合でも遅くとも何番目に開場に到着すれば最初に会場に入ることが出来るかわかるはずだ。
しかしこの指示内容を今から手計算で解析するのは量が多すぎるので無理そうだ。
どんなに頑張ってもコズミケには間に合わない。
そこで、僕は君にこの計算を任せることにした。
君はプログラミングコンテストによく参加しており、このようなの計算プログラムを書くのは得意なはずだ。
もちろんただでやってくれとは言わない。
カタログによると、今年のコズミケにはプログラミングコンテストに関する同人誌を出しているサークルが参加する予定のはずだ。
もし僕が開場と同時に入場できたら報酬としてその同人誌を手に入れて君にプレゼントするよ。
さて、僕はこれから5時間ぐらい仮眠をとることにしよう。その間に君ならきっと答えを出してくれると僕は信じている。
Input
入力は複数のケースからなる。
各ケースは以下のフォーマットで与えられる。
r
c
q
A
0
B
0
order
0
A
1
B
1
order
1
.
.
.
A
q-1
B
q-1
order
q-1
A
i
= 0 の時,
B
i
行目に対して
order
i
の指示が実行される。
A
i
= 1 の時,
B
i
列目に対して
order
i
の指示が実行される。
order
i
= 0の時は指定された行または列の人全員を座らせる。
order
i
= 1の時は指定された行または列を人全員を立たせる。
入力の終わりは
r
=0
c
=0
q
=0 で与えられる。
入力の値は以下の条件を満たす。
1 ≤
r
≤ 50,000
1 ≤
c
≤ 50,000
1 ≤
q
≤ 50,000
order
i
= 0 または 1
A
i
= 0 の時
0 ≤
B
i
<
r
A
i
= 1 の時
0 ≤
B
i
<
c
テストケースの数は100を超えない
Output
最悪の場合に、何番目までに到着すれば最初に会場に入れる権利を得ることが出来るかを一行で出力せよ。
Sample input
5 5 5
0 0 1
0 0 0
0 2 0
1 2 1
0 0 0
5 5 5
1 4 0
0 1 1
0 4 1
1 3 0
0 3 1
5 5 5
1 0 0
0 3 0
1 2 1
0 4 0
0 1 1
0 0 0
Sample output
4
13
8
The University of Aizu Programming Contest 2011 Summer
原案、問題文: Tomoya Sakai

Submitted solutions:

code_snippet: #include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;

#define fi first
#define se second
#define repl(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)
#define rep(i,n) repl(i,0,n)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define mmax(x,y) (x>y?x:y)
#define mmin(x,y) (x<y?x:y)
#define maxch(x,y) x=mmax(x,y)
#define minch(x,y) x=mmin(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt __builtin_popcountll

#define INF 1e16
#define mod 1000000007

int main(){
  cin.tie(0);
  ios::sync_with_stdio(false);

  while(1){
    ll R,C,Q;
    cin>>R>>C>>Q;
    if(R==0&&C==0&&Q==0){
      break;
    }

    vector<ll> A(Q),B(Q),Ca(Q);
    rep(i,Q){
      cin>>A[i]>>B[i]>>Ca[i];
    }

    vector<bool> usedR(R,false),usedC(C,false);
    ll cntr=0,cntc=0;
    ll cnt=0;
    for(ll i=Q-1;i>=0;i--){
      ll a,b,c;
      a=A[i]; b=B[i]; c=Ca[i];

      if(a==0){
        if(c==0){
          if(usedR[b])continue;
          usedR[b]=true;
          cntr++;
        }else{
          if(usedR[b])continue;
          usedR[b]=true;
          cnt+=(C-cntc);
          cntr++;
        }
      }else{
        if(c==0){
          if(usedC[b])continue;
          usedC[b]=true;
          cntc++;
        }else{
          if(usedC[b])continue;
          usedC[b]=true;
          cnt+=(R-cntr);
          cntc++;
        }
      }

    }
    cout<<cnt<<endl;
  }

  return 0;
}
accuracy: 1
time_ms: 130
memory_kb: 4208
final_rank: 6

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
using ld = long double;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define eb emplace_back
#define all(v) (v).begin(), (v).end()
#define siz(v) (ll)(v).size()
#define rep(i, a, n) for (ll i = a; i < (ll)(n); i++)
#define repr(i, a, n) for (ll i = n - 1; (ll)a <= i; i--)
#define lb lower_bound
#define ub upper_bound
typedef pair<int, int> P;
typedef pair<ll, ll> PL;
const ll mod = 1000000007;
const ll INF = 1000000099;
const ll LINF = (ll)(1e18 + 99);
vector<ll> dx = {-1, 1, 0, 0}, dy = {0, 0, -1, 1};
template <typename T>
T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template <typename T>
T mpow(T a, T n)
{
   T res = 1;
   for (; n; n >>= 1)
   {
      if (n & 1)
         res = res * a;
      a = a * a;
   }
   return res;
}

//cin.tie(0);ios::sync_with_stdio(false);

vector<vector<bool>> fl(2, vector<bool>());

signed main()
{

   while (1)
   {

      ll r, c, q, ans = 0;
      cin >> r >> c >> q;
      if (!r && !c && !q)
         return 0;

      
      fl[0] = vector<bool>(r, false);
      fl[1] = vector<bool>(c, false);

      vector<ll> a(q), b(q), o(q);
      rep(i, 0, q)
      {
         cin >> a[i] >> b[i] >> o[i];
      }

      for (int i = q - 1; 0 <= i; i--)
      {
         if (fl[a[i]][b[i]])
            continue; //指示済みは無視

         fl[a[i]][b[i]] = true;

         if (o[i])
         {
            if (!a[i])
            {
               ans += c;
               r--;
            }
            else
            {
               ans += r;
               c--;
            }
         }
         else
         {
            if (!a[i])
            {
               r--;
            }
            else
            {
               c--;
            }
         }
      }

      cout << ans << endl;
   }
}
accuracy: 1
time_ms: 410
memory_kb: 4156
final_rank: 10

code_snippet: #pragma GCC optimize("Ofast")
#define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
using namespace::std;
struct __INIT{__INIT(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(15);}} __init;
// random_device rd;
// mt19937 mt(rd());
// #include <boost/numeric/interval.hpp>
// #include <boost/numeric/interval/io.hpp>
// #include <boost/intrusive/rbtree.hpp>
// #include <boost/geometry.hpp>
// #include <boost/geometry/geometries/linestring.hpp>
// #include <boost/geometry/geometries/polygon.hpp>
// #include <boost/geometry/geometries/point_xy.hpp>
// #include <boost/multiprecision/cpp_dec_float.hpp>
// #include <boost/multiprecision/cpp_int.hpp>
// namespace mp = boost::multiprecision;
// typedef mp::number<mp::cpp_dec_float<0>> cfloat;
// typedef mp::cpp_int cint;

#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/priority_queue.hpp>
#include<ext/pb_ds/tag_and_trait.hpp>
using namespace __gnu_pbds;
template<typename T=long long>using pbds=tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
template<typename T=long long>using pqueue =__gnu_pbds::priority_queue<T, less<T>,rc_binomial_heap_tag>;
typedef long long lint;
typedef long long ll;
typedef long double ldouble;
typedef vector<lint> vec;
typedef vector<vector<lint>> mat;
typedef vector<vector<vector<lint>>> mat3;
typedef vector<double> dvec;
typedef vector<vector<double>> dmat;
typedef vector<vector<vector<double>>> dmat3;
typedef vector<string> svec;
typedef vector<vector<string>> smat;
typedef vector<vector<vector<string>>> smat3;
typedef vector<pair<lint,lint>> pvec;
typedef vector<vector<pair<lint,lint>>> pmat;
typedef vector<vector<vector<pair<lint,lint>>>> pmat3;
#define rep(i, n) for(lint i = 0; i < (lint)(n); i++)
#define irep(i) for(lint i = 0;; i++)
#define irep1(i) for(lint i = 1;; i++)
#define irep2(i) for(lint i = 2;; i++)
#define rrep(i, n) for(lint i = (lint)(n-1); i >-1; i--)
#define rrepi(i,a,b) for(lint i = (lint)(b-1); i >a-1; i--)
#define repi(i,a,b) for(lint i=lint(a);i<lint(b);i++)
#define rep2(i,a,b,c) for(lint i=lint(a);i>lint(b);i+=c)
#define all(x) (x).begin(),(x).end()
//#define PI 3.141592653589793
#define dist(x1,y1,x2,y2) (pow(pow(x2-x1,2)+pow(y2-y1,2),0.5))
#define output(v) do{bool f=0;for(auto i:v){cout<<(f?" ":"");if(i>INF/2)cout<<"INF";else cout<<i;f=1;}cout<<"\n";}while(0)
#define output2(v) for(auto j:v)output(j);
#define _output(v) do{bool f=0;rep(i,v.size()){cout<<(f?" ":"");if(v[i]>INF/2)cout<<"INF";else cout<<v[i];f=1;}cout<<"\n";}while(0)
#define _output2(v) rep(j,v.size()){_output(v[j]);}
#define input(a,n) lint n;cin>>n;vector<lint>a(n);rep(i,n)cin>>a[i];
#define SUM(v) accumulate(all(v),0LL)
#define INF (1LL<<60)
#define IINF (1<<30)
#define EPS (1e-10)
#define LINF 9223372036854775807
#define MOD 998244353
#define endl "\n"
template<typename T=lint>T in(){return *istream_iterator<T>(cin);}
inline lint gcd(lint a,lint b){return b?gcd(b,a%b):a;}
template<typename T=lint>inline T lcm(T a,T b){return a/gcd(a,b)*b;}
template<typename T=lint>inline T add(T a,T b){return a+b;}
template<typename T=lint>inline T minq(T a,T b){return min(a,b);}
inline bool chmin(auto& s,const auto& t){bool res=s>t;s=min(s,t);return res;}
inline bool chmax(auto& s,const auto& t){bool res=s<t;s=max(s,t);return res;}
vector<lint> dx={-1,1,0,0,1,1,-1,-1};
vector<lint> dy={0,0,-1,1,1,-1,1,-1};



int main(){
    while(1){
        lint r,c,q;
        cin>>r>>c>>q;
        if(r==0&&c==0&&q==0)break;
        vec a(q),b(q),o(q);
        rep(i,q){
            cin>>a[i]>>b[i]>>o[i];
        }
        reverse(all(a));
        reverse(all(b));
        reverse(all(o));
        set<lint>dr,dc;
        lint ans=0;
        rep(i,q){
            if(a[i]){
                if(dc.count(b[i]))continue;
                dc.insert(b[i]);
                if(o[i])ans+=r-dr.size();
            }else{
                if(dr.count(b[i]))continue;
                dr.insert(b[i]);
                if(o[i])ans+=c-dc.size();
            }
        }
        cout<<ans<<endl;
    }
}
accuracy: 1
time_ms: 450
memory_kb: 6316
final_rank: 17

code_snippet: #include <bits/stdc++.h>
using namespace std;

struct data {
  bool a, o;
  long long b;
};

long long r, c, q;
vector<data> query;

long long solve();

int main() {
  while(1) {
    cin >> r >> c >> q;
    if(r + c + q == 0) break;
    query.resize(q);
    for(int i = 0; i < q; ++i)
      cin >> query[q - 1 - i].a >> query[q - 1 - i].b >>
          query[q - 1 - i].o;
    cout << solve() << endl;
  }
  return 0;
}

long long solve() {
  long long ans = 0;
  set<long long> st[2];
  for(int i = 0; i < q; ++i) {
    data now = query[i];
    if(st[now.a].find(now.b) != st[now.a].end()) continue;
    if(now.o) {
      if(now.a)
        ans += r;
      else
        ans += c;
    }
    if(now.a)
      --c;
    else
      --r;
    st[now.a].insert(now.b);
  }
  return ans;
}
accuracy: 1
time_ms: 580
memory_kb: 6124
final_rank: 19

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}

int main(){
    int r,c,q;
    while(scanf(" %d %d %d", &r, &c, &q),r){
        vector<int> a(q),b(q),o(q);
        rep(i,q) scanf(" %d %d %d", &a[i], &b[i], &o[i]);

        ll ans = 0;
        int R = r, C = c;
        vector<int> y(r,-1), x(c,-1);
        for(int i=q-1; i>=0; --i){
            if(a[i]==0){
                if(y[b[i]] != -1) continue;
                if(o[i]==1) ans += C;
                --R;
                y[b[i]] = o[i];
            }
            else{
                if(x[b[i]] != -1) continue;
                if(o[i]==1) ans += R;
                --C;
                x[b[i]] = o[i];
            }
        }
        printf("%lld\n", ans);
    }
    return 0;
}
accuracy: 1
time_ms: 140
memory_kb: 3872
final_rank: 5

code_snippet: #include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
#include <set>
#include <map>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;

enum Type{
	sit_down,
	stand_up,
};

struct Info{
	bool operator<(const Info &arg) const{
		return time > arg.time;
	}
	int row_or_col,loc,time;
	Type order;
};

int Q;
ll R,C;
Info order_row[50000],order_col[50000];

void func(){

	for(int i = 0; i < R; i++){
		order_row[i].row_or_col = -1;
	}
	for(int i = 0; i < C; i++){
		order_col[i].row_or_col = -1;
	}

	int row_or_col,loc,order;

	for(int loop = 0; loop < Q; loop++){
		scanf("%d %d %d",&row_or_col,&loc,&order);
		if(row_or_col == 0){
			order_row[loc].row_or_col = 0;
			order_row[loc].loc = loc;
			order_row[loc].time = loop;
			if(order == 0){
				order_row[loc].order = sit_down;
			}else{
				order_row[loc].order = stand_up;
			}
		}else{
			order_col[loc].row_or_col = 1;
			order_col[loc].loc = loc;
			order_col[loc].time = loop;
			if(order == 0){
				order_col[loc].order = sit_down;
			}else{
				order_col[loc].order = stand_up;
			}
		}
	}

	vector<Info> V;

	for(int i = 0; i < R; i++){
		if(order_row[i].row_or_col != -1){
			V.push_back(order_row[i]);
		}
	}

	for(int i = 0; i < C; i++){
		if(order_col[i].row_or_col != -1){
			V.push_back(order_col[i]);
		}
	}

	sort(V.begin(),V.end());

	ll ans = 0;
	ll sit_row_num = 0,sit_col_num = 0,stand_row_num = 0,stand_col_num = 0;

	for(int i = 0; i < V.size(); i++){

		if(V[i].row_or_col == 0){
			if(V[i].order == stand_up){
				ans += C-(sit_col_num+stand_col_num);
				stand_row_num++;
			}else{
				sit_row_num++;
			}
		}else{
			if(V[i].order == stand_up){
				ans += R-(sit_row_num+stand_row_num);
				stand_col_num++;
			}else{
				sit_col_num++;
			}
		}
	}

	printf("%lld\n",ans);
}

int main(){

	while(true){
		scanf("%lld %lld %d",&R,&C,&Q);
		if(R == 0 && C == 0 && Q == 0)break;

		func();
	}

	return 0;
}
accuracy: 1
time_ms: 200
memory_kb: 6360
final_rank: 11

code_snippet: #include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <sstream>

using namespace std;

int order[100000][3];

bool check_r[100000];
bool check_c[100000];

int main(){
	
	int r, c, q;
	
	while(true){
		
		cin >> r >> c >> q;
		
		if(r == 0 && c == 0 && q == 0){
			break;
		}
		
		for(int i = 0; i < 100000; i++){
			check_r[i] = false;
			check_c[i] = false;
		}
		
		for(int i = 0; i < q; i++){
			cin >> order[i][0] >> order[i][1] >> order[i][2];
		}
		
		long long int r_rest = c;
		long long int c_rest = r;
		
		long long int ans = 0;
		
		for(int i = q - 1; i >= 0; i--){
			if(order[i][0] == 0){
				if(!check_c[order[i][1]]){
					if(order[i][2] == 1){
						ans += r_rest;
					}
					check_c[order[i][1]] = true;
					c_rest--;
				}
			}else{
				if(!check_r[order[i][1]]){
					if(order[i][2] == 1){
						ans += c_rest;
					}
					check_r[order[i][1]] = true;
					r_rest--;
				}
			}
		}
		
		cout << ans << endl;
	}
	
	return 0;
}
accuracy: 1
time_ms: 410
memory_kb: 3828
final_rank: 8

code_snippet: #include <cstdio>
#include <algorithm>
using namespace std;
int H, W, Q, a[50009], b[50009], x[50009]; bool used1[50009], used2[50009];
int main() {
	while (scanf("%d%d%d", &H, &W, &Q), H) {
		for (int i = 0; i < Q; i++) scanf("%d%d%d", &a[i], &b[i], &x[i]);
		fill(used1, used1 + H, false);
		fill(used2, used2 + W, false);
		int cnt1 = H, cnt2 = W;
		long long ret = 0;
		while (Q--) {
			if (a[Q] == 0 && !used1[b[Q]]) {
				used1[b[Q]] = true; cnt1--;
				if (x[Q] == 1) ret += cnt2;
			}
			if (a[Q] == 1 && !used2[b[Q]]) {
				used2[b[Q]] = true; cnt2--;
				if (x[Q] == 1) ret += cnt1;
			}
		}
		printf("%lld\n", ret);
	}
	return 0;
}
accuracy: 1
time_ms: 130
memory_kb: 3332
final_rank: 3

code_snippet: #include<iostream>
#include<algorithm>
#include<vector>
#include<tuple>
using namespace std;
#pragma warning(disable:4996)
int H, W, Q, a[60000], b[60000], c[60000], d[60000], e, f, g;
int main() {
	while (true) {
		cin >> H >> W >> Q; if (H == 0)break;
		for (int i = 0; i < H; i++) { a[i] = -1; c[i] = 0; }
		for (int i = 0; i < W; i++) { b[i] = -1; d[i] = 0; }
		for (int i = 0; i < Q; i++) {
			scanf("%d%d%d", &e, &f, &g);
			if (e == 0) { a[f] = i; c[f] = g; }
			if (e == 1) { b[f] = i; d[f] = g; }
		}
		long long R1 = 0, R2 = 0, M = 0, cnt = 0;
		vector<tuple<int, int, int>>tup;
		for (int i = 0; i < H; i++)tup.push_back(make_tuple(a[i], 0, c[i]));
		for (int i = 0; i < W; i++)tup.push_back(make_tuple(b[i], 1, d[i]));
		sort(tup.begin(), tup.end());
		for (int i = 0; i < tup.size(); i++) {
			int a1 = get<0>(tup[i]), a2 = get<1>(tup[i]), a3 = get<2>(tup[i]);
			if (a2 == 0)R1++; if (a2 == 1)R2++;
			if (a3 == 1)cnt += R1*R2 - M; M = R1*R2;
		}
		cout << cnt << endl;
	}
	return 0;
}
accuracy: 1
time_ms: 230
memory_kb: 6324
final_rank: 12

code_snippet: #include<iostream>
#include<vector>
#include<string>
#include<algorithm>	
#include<map>
#include<set>
#include<utility>
#include<cmath>
#include<cstring>
#include<queue>
#include<stack>
#include<cstdio>
#include<sstream>
#include<iomanip>
#define loop(i,a,b) for(int i=a;i<b;i++) 
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
using namespace std;
//kaewasuretyuui
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef vector<string> vs;
typedef vector<double> vd;
typedef pair<int,pii> pip;
typedef vector<pip>vip;
const double PI=acos(-1);
const double EPS=1e-8;
const int inf=1e8;
int main(){
	int n,m,q;
	while(cin>>n>>m>>q,n+m+q){
		vi h(n),w(m);
		int coh=0,cow=0;
		vvi in(q,vi(3));
		rep(i,q)rep(j,3)cin>>in[q-1-i][j];
		int out=0;
		rep(i,q){
			if(in[i][0]&&w[in[i][1]]==0){
				if(in[i][2])out+=n-coh;
				cow++;
				w[in[i][1]]=true;
			}else if(in[i][0]==0&&h[in[i][1]]==0){
				if(in[i][2])out+=m-cow;
				coh++;
				h[in[i][1]]=true;
			}
		}
		cout<<out<<endl;
	}
}
accuracy: 1
time_ms: 670
memory_kb: 5936
final_rank: 20

code_snippet: #include "bits/stdc++.h"
using namespace std;

struct query{
	int a;
	int b;
	int o;
};

int main() {
	while (1) {
		int R, C, Q; cin >> R >> C >> Q;
		if (!R)break;
		vector<query>qs;
		for (int i = 0; i < Q; ++i) {
			int a, b, o; cin >> a >> b >> o;
			qs.push_back(query{ a,b,o });
		}
		vector<int>rstatus(R), cstatus(C);
		int rvalid = R, cvalid = C;
		int ans = 0;
		for (int i = Q - 1; i >= 0;--i) {
			query q(qs[i]);
			if (q.o == 1) {
				if (q.a == 0) {
					if (!rstatus[q.b]) {
						rstatus[q.b] = 1;
						ans += cvalid;
						rvalid--;
					}
				}
				else {
					if (!cstatus[q.b]) {
						cstatus[q.b] = 1;
						ans += rvalid;
						cvalid--;
					}
				}
			}
			else {
				if (q.a == 0) {
					if (!rstatus[q.b]) {
						rstatus[q.b] = -1;
						rvalid--;
					}
				}
				else {
					if (!cstatus[q.b]) {
						cstatus[q.b] = -1;
						cvalid--;
					}
				}
			}
		}
		cout << ans << endl;
	}
	return 0;
}
accuracy: 1
time_ms: 570
memory_kb: 4060
final_rank: 16

code_snippet: #include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
const ld eps = 1e-9;

//// < "d:\d_download\visual studio 2015\projects\programing_contest_c++\debug\a.txt" > "d:\d_download\visual studio 2015\projects\programing_contest_c++\debug\b.txt"

struct query{
	int a;
	int b;
	int o;
};

int main() {
	while (1) {
		int R, C, Q; cin >> R >> C >> Q;
		if (!R)break;
		vector<query>qs;
		for (int i = 0; i < Q; ++i) {
			int a, b, o; cin >> a >> b >> o;
			qs.push_back(query{ a,b,o });
		}
		reverse(qs.begin(), qs.end());
		vector<int>rstatus(R), cstatus(C);
		int rvalid = R, cvalid = C;
		int ans = 0;
		for (int i = 0; i < Q; ++i) {
			query q(qs[i]);
			if (q.o == 1) {
				if (q.a == 0) {
					if (!rstatus[q.b]) {
						rstatus[q.b] = 1;
						ans += cvalid;
						rvalid--;
					}
				}
				else {
					if (!cstatus[q.b]) {
						cstatus[q.b] = 1;
						ans += rvalid;
						cvalid--;
					}
				}
			}
			else {
				if (q.a == 0) {
					if (!rstatus[q.b]) {
						rstatus[q.b] = -1;
						rvalid--;
					}
				}
				else {
					if (!cstatus[q.b]) {
						cstatus[q.b] = -1;
						cvalid--;
					}
				}
			}

		}
		cout << ans << endl;
	}
	return 0;
}
accuracy: 1
time_ms: 510
memory_kb: 4204
final_rank: 15

code_snippet: #include <bits/stdc++.h>

using namespace std;

#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) { cout << #a << " = " << a << endl; }
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }

typedef long long ll;
int const inf = 1<<29;

int A[50001], B[50001], O[50001];

int main() {

  for(int R, C, Q; cin >> R >> C >> Q && R && C && Q;) {
    rep(i, Q) {
      cin >> A[i] >> B[i] >> O[i];
    }

    set<int> vis[2];
    int rcnt = 0, ccnt = 0;
    ll sum = 0;

    for(int i=Q-1; i>=0; i--) {
      if(vis[A[i]].count(B[i])) continue;
      vis[A[i]].insert(B[i]);
      if(O[i]) {
        if(A[i]) sum += R - rcnt;
        else sum += C - ccnt;
      }
      if(A[i]) ccnt ++;
      else rcnt ++;
    }
    cout << sum << endl;
  }

  return 0;
}
accuracy: 1
time_ms: 590
memory_kb: 5908
final_rank: 18

code_snippet: #include <bits/stdc++.h>
#define N 50001
using namespace std;
typedef long long ll;

int main(){
  while(1){
    ll r,c,q;
    cin>>r>>c>>q;
    if(!r&&!c&&!q)return 0;

    ll A[N],B[N],O[N];
    for(int i=0;i<q;i++)cin>>A[i]>>B[i]>>O[i];
    
    ll ans=0,cnt[2]={},rc[]={r,c},used[2][N]={};
    for(int i=q-1;i>=0;i--){
      bool f=A[i];
      if(used[f][B[i]]++)continue;
      cnt[f]++;
      ans+=(rc[!f]-cnt[!f])*O[i];
    }
    cout <<ans<<endl;
  }
  
  return 0;
}
accuracy: 1
time_ms: 410
memory_kb: 4904
final_rank: 14

code_snippet: #include <bits/stdc++.h>
#define N 50001
using namespace std;
typedef long long ll;

int main(){
  while(1){
    ll r,c,q;
    cin>>r>>c>>q;
    if(!r&&!c&&!q)return 0;

    ll A[N],B[N],O[N];
    for(int i=0;i<q;i++)cin>>A[i]>>B[i]>>O[i];
    
    ll ans=0,cnt[2]={},rc[]={r,c},used[2][N]={};
    for(int i=q-1;i>=0;i--){
      ll f=A[i],RC=B[i];
      if(used[f][RC]++)continue;
      cnt[f]++;
      ans+=(rc[!f]-cnt[!f])*O[i];
    }
    cout <<ans<<endl;
  }
  
  return 0;
}
accuracy: 1
time_ms: 400
memory_kb: 4932
final_rank: 13

code_snippet: #include <bits/stdc++.h>

using namespace std;

typedef long long ll;

int main()
{
    ll R, C, Q;
    while (cin >> R >> C >> Q, R) {
        vector<ll> a(Q), b(Q), order(Q);
        for (int i = 0; i < Q; i++) {
            cin >> a[i] >> b[i] >> order[i];
        }
        vector<bool> used_a(R, 0), used_b(C, 0);
        ll r = 0, c = 0, res = 0;
        for (int i = Q-1; i >= 0; i--) {
            if (a[i] == 0) { // ???
                if (!used_a[b[i]]) {
                    used_a[b[i]] = 1;
                    r++;
                    if (order[i] == 1) {
                        res += C - c;
                    }
                }
            } else {         // ???
                if (!used_b[b[i]]) {
                    used_b[b[i]] = 1;
                    c++;
                    if (order[i] == 1) {
                        res += R - r;
                    }
                }
            }
        }
        cout << res << endl;
    }
    return 0;
}
accuracy: 1
time_ms: 420
memory_kb: 4056
final_rank: 9

code_snippet: #include <bits/stdc++.h>

using namespace std;

typedef long long ll;

int main()
{
    ll R, C, Q;
    while (cin >> R >> C >> Q, R) {
        vector<ll> a(Q), b(Q), order(Q);
        for (int i = 0; i < Q; i++) {
            cin >> a[i] >> b[i] >> order[i];
        }
        vector<bool> used_a(R, 0), used_b(C, 0);
        ll r = 0, c = 0, res = 0;
        for (int i = Q-1; i >= 0; i--) {
            if (a[i] == 0) { // ティツ。ツ?
                if (!used_a[b[i]]) {
                    used_a[b[i]] = 1;
                    r++;
                    if (order[i] == 1) {
                        res += C - c;
                    }
                }
            } else {         // テ・ツ按?
                if (!used_b[b[i]]) {
                    used_b[b[i]] = 1;
                    c++;
                    if (order[i] == 1) {
                        res += R - r;
                    }
                }
            }
        }
        cout << res << endl;
    }
    return 0;
}
accuracy: 1
time_ms: 540
memory_kb: 2368
final_rank: 7

code_snippet: #include<stdio.h>
#include<algorithm>
using namespace std;
int d[51000];
int e[51000];
int f[51000];
int row[51000];
int col[51000];
int main(){
	int a,b,c;
	while(scanf("%d%d%d",&a,&b,&c),a){
		for(int i=0;i<a;i++)row[i]=1;
		for(int j=0;j<b;j++)col[j]=1;
		for(int i=0;i<c;i++)scanf("%d%d%d",d+i,e+i,f+i);
		int R=a;
		int C=b;
		long long ret=0;
		for(int i=c-1;i>=0;i--){
			if(d[i]){
				if(!col[e[i]])continue;
				col[e[i]]=0;
				C--;
				if(f[i])ret+=R;
			}else{
				if(!row[e[i]])continue;
				row[e[i]]=0;
				R--;
				if(f[i])ret+=C;
			}
		}
		printf("%lld\n",ret);
	}
}
accuracy: 1
time_ms: 230
memory_kb: 2020
final_rank: 2

code_snippet: #define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
 
using namespace std;
 
typedef long long ll;
typedef pair <int,int> P;
 
static const double EPS = 1e-8;

struct Order{
  int type;
  int pos;
  int action;
  Order(int _t,int _p,int _a) : type(_t),pos(_p),action(_a) {}
};

bool is_used_row[50001];
bool is_used_col[50001];

int main(){
  int total_rows,total_cols,total_queries;

  while(~scanf("%d %d %d",&total_rows,&total_cols,&total_queries)){
    if(total_rows == 0 && total_cols == 0 && total_queries == 0) break;

    vector<Order> orders;
    memset(is_used_row,false,sizeof(is_used_row));
    memset(is_used_col,false,sizeof(is_used_col));

    ll remaining_row = total_rows;
    ll remaining_col = total_cols;

    for(int query_idx = 0; query_idx < total_queries; query_idx++){

      int order_type;
      int pos;
      int action;
      scanf("%d %d %d",&order_type,&pos,&action);
      orders.push_back(Order(order_type,pos,action));
    }

    ll occupied_seats = 0;
    for(int query_idx = total_queries -1; query_idx >= 0; query_idx--){
      
      //row
      if(orders[query_idx].type == 0){
        if(is_used_row[orders[query_idx].pos]) continue;

        is_used_row[orders[query_idx].pos] = true;

        //0:sit 1:stand up
        if(orders[query_idx].action == 1) {
          occupied_seats += remaining_col;
        }
        remaining_row--;
      }

      //col
      else if(orders[query_idx].type == 1){
        if(is_used_col[orders[query_idx].pos]) continue;

        is_used_col[orders[query_idx].pos] = true;

        //0:sit 1:stand up
        if(orders[query_idx].action == 1) {
          occupied_seats += remaining_row;
        }
        remaining_col--;
      }
    }
    printf("%lld\n",occupied_seats);
  }
}
accuracy: 1
time_ms: 260
memory_kb: 2448
final_rank: 4

code_snippet: #include <cstdio>

using namespace std;

int main()
{
    for (;;) {
        int r, c, q;

        scanf("%d %d %d", &r, &c, &q);
        if (r == 0 && c == 0 && q == 0)
            break;

        int a[50000], b[50000], o[50000];
        for (int i = 0; i < q; ++i)
            scanf("%d %d %d", &a[i], &b[i], &o[i]);

        int e = 0, nr = r, nc = c;
        bool f[2][50000] = {};
        for (int i = q - 1; i >= 0; --i) {
            if (!f[a[i]][b[i]]) {
                f[a[i]][b[i]] = true;

                if (a[i] == 0) {
                    --nr;
                    if (o[i] == 1)
                        e += nc;
                } else {
                    --nc;
                    if (o[i] == 1)
                        e += nr;
                }
            }
        }

        printf("%d\n", e);
    }

    return 0;
}
accuracy: 1
time_ms: 230
memory_kb: 1716
final_rank: 1