Problem:
マトリョーシカ
マトリョーシカとは女性像をかたどった木製の人形で、ロシアの代表的な民芸品です。マトリョーシカは、大きな人形の中にそれより小さな人形が入っている入れ子構造になっており、大きさの異なる複数の人形で構成されています。このような入れ子構造にするため、各人形の胴体は上下で分割できる筒状の構造になっています。マトリョーシカは職人の手で手作りされるため、一つ一つの人形は世界に一つしかない非常に貴重なものになります。
兄弟である一郎君と次郎君は、マトリョーシカで遊ぶのが大好きで、各自がそれぞれ1組のマトリョーシカを持っていました。一郎君のマトリョーシカは
n
個の人形から構成されており、次郎君のマトリョーシカは
m
個の人形から構成されています。
ある日、好奇心が旺盛な一郎君は、これら2組のマトリョーシカに含まれる人形たちを組み合わせて、より多くの人形を含む新たなマトリョーシカを作れないかと考えました。つまり、
n + m
個の人形を使い、
k
個の人形からなる１組のマトリョーシカを作ることを試みたのです。
n
と
m
の大きい方よりも
k
を大きくすることができれば、一郎君の目的は達成されます。
兄弟は2人仲良く、どのように人形を組み合わせれば
k
の値を最大にできるかを考えました。しかし、幼い2人にとってこの問題はあまりにも難しいので、年上のあなたはプログラムを作成して弟たちを助けることにしました。
一郎君と次郎君のマトリョーシカの人形の情報を入力とし、新たなマトリョーシカが含む人形の数
k
を出力するプログラムを作成して下さい。入力される人形に大きさが同じものは存在しません。また、人形を高さ
h
半径
r
の円柱とみなした場合、高さ
h
、半径
r
の人形が含むことのできる人形は
x < h
かつ
y < r
を満たす高さ
x
半径
y
の人形です。
Input
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。各データセットは以下の形式で与えられます。
n
h
1
r
1
h
2
r
2
:
h
n
r
n
m
h
1
r
1
h
2
r
2
:
h
m
r
m
１行目に一郎君のマトリョーシカの人形の数
n
(
n
≤ 100)、続く
n
行に一郎君の第
i
の人形の高さ
h
i
と半径
r
i
(
h
i
,
r
i
< 1000) が与えられます。
続く行に二郎君のマトリョーシカの人形の数
m
(
m
≤ 100)、続く
m
行に二郎君の第
i
の人形の高さ
h
i
と半径
r
i
(
h
i
,
r
i
< 1000) が与えられます。
データセットの数は 20 を越えない。
Output
入力データセットごとに新たなマトリョーシカが含む人形の数
k
を出力します。
Sample Input
6
1 1
4 3
6 5
8 6
10 10
14 14
5
2 2
5 4
6 6
9 8
15 10
4
1 1
4 3
6 5
8 6
3
2 2
5 4
6 6
4
1 1
4 3
6 5
8 6
4
10 10
12 11
18 15
24 20
0
Output for the Sample Input
9
6
8

Submitted solutions:

code_snippet: #include<string.h>
#include<stdio.h>


#define MAX_LEN 100
struct Node
{
	int r;
	int h;
	int id;
};

Node g_a[MAX_LEN];
Node g_b[MAX_LEN];
int g_dp[MAX_LEN+1][MAX_LEN+1][MAX_LEN *2 + 1];

int search(Node a[], int aidx, int alen, Node b[], int bidx, int blen, Node lastNode)
{
	if (aidx >= alen && bidx >= blen)
	{
		return 0;
	}
	

	if (g_dp[aidx][bidx][lastNode.id] != -1)
		return g_dp[aidx][bidx][lastNode.id];

	int cnt = 0;
	int tmp = 0;
	int ret1 = 0, ret2 = 0;
	if (aidx < alen)
	{

		//选择
		if (a[aidx].h > lastNode.h && a[aidx].r > lastNode.r)
		{
			tmp = search(a, aidx + 1, alen, b, bidx, blen, a[aidx]) + 1;
			if (ret1 < tmp)
				ret1 = tmp;
		}

		tmp = search(a, aidx + 1, alen, b, bidx, blen, lastNode);
		if (ret1 < tmp)
			ret1 = tmp;
	}

	if (bidx < blen)
	{
		if (b[bidx].h > lastNode.h && b[bidx].r > lastNode.r)
		{
			tmp = search(a, aidx, alen, b, bidx + 1, blen, b[bidx]) + 1;
			if (ret2 < tmp)
				ret2 = tmp;
		}
		tmp = search(a, aidx, alen, b, bidx + 1, blen, lastNode);
		if (ret2 < tmp)
			ret2 = tmp;
	}
	if (ret1 < ret2)
		ret1 = ret2;
	
	g_dp[aidx][bidx][lastNode.id] = ret1;
	return g_dp[aidx][bidx][lastNode.id];
}



int main()
{
	int n, m;

	while (1)
	{
		scanf("%d", &n);
		if (n == 0)
			break;
		memset(g_a, 0, sizeof(g_a));
		memset(g_b, 0, sizeof(g_b));
		memset(g_dp, -1, sizeof(g_dp));


		int id = 1;
		for (int i = 0; i < n; i++)
		{
			scanf("%d%d", &g_a[i].h, &g_a[i].r);
			g_a[i].id = id++;
		}
		scanf("%d", &m);
		for (int i = 0; i < m; i++)
		{
			scanf("%d%d", &g_b[i].h, &g_b[i].r);
			g_b[i].id = id++;
		}

		Node lastNode;
		lastNode.r = 0;
		lastNode.h = 0;
		lastNode.id = 0;
		int num = search(g_a, 0, n, g_b, 0, m, lastNode);
		printf("%d\n", num);
	}

}
accuracy: 1
time_ms: 40
memory_kb: 10640
final_rank: 17

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

#define FOR(i,a,b) for(int i= (a); i<((int)b); ++i)
#define RFOR(i,a) for(int i=(a); i >= 0; --i)
#define FOE(i,a) for(auto i : a)
#define ALL(c) (c).begin(), (c).end()
#define RALL(c) (c).rbegin(), (c).rend()
#define DUMP(x)  cerr << #x << " = " << (x) << endl;
#define SUM(x) std::accumulate(ALL(x), 0LL)
#define MIN(v) *std::min_element(v.begin(), v.end())
#define MAX(v) *std::max_element(v.begin(), v.end())
#define EXIST(v,x) (std::find(v.begin(), v.end(), x) != v.end())
#define BIT(n) (1LL<<(n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());

typedef long long LL;
template<typename T> using V = std::vector<T>;
template<typename T> using VV = std::vector<std::vector<T>>;
template<typename T> using VVV = std::vector<std::vector<std::vector<T>>>;

template<class T> inline T ceil(T a, T b) { return (a + b - 1) / b; }
template<class T> inline void print(T x) { std::cout << x << std::endl; }
template<class T> inline void print_vec(const std::vector<T> &v) { for (int i = 0; i < v.size(); ++i) {  if (i != 0) {std::cout << " ";} std::cout << v[i];} std::cout << "\n"; }
template<class T> inline bool inside(T y, T x, T H, T W) {return 0 <= y and y < H and 0 <= x and x < W; }
template<class T> inline double euclidean_distance(T y1, T x1, T y2, T x2) { return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)); }
template<class T> inline double manhattan_distance(T y1, T x1, T y2, T x2) { return abs(x1 - x2) + abs(y1 - y2); }

const int INF = 1L << 30;
const double EPS = 1e-9;
const std::string YES = "YES", Yes = "Yes", NO = "NO", No = "No";
const std::vector<int> dy4 = { 0, 1, 0, -1 }, dx4 = { 1, 0, -1, 0 };    // 4近傍（右, 下, 左, 上）
const std::vector<int> dy8 = { 0, -1, 0, 1, 1, -1, -1, 1 }, dx8 = { 1, 0, -1, 0, 1, 1, -1, -1 };

using namespace std;

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

	while (true) {
	    int N , M;
	    cin >> N;
	    if (N == 0) {
	        break;
	    }
	    vector<pair<int, int>> m;
	    FOR(i, 0, N) {
	        int h, r;
	        cin >> h >> r;
	        m.emplace_back(make_pair(h, r));
	    }
	    cin >> M;
        FOR(i, 0, M) {
            int h, r;
            cin >> h >> r;
            m.emplace_back(make_pair(h, r));
        }

        vector<vector<int>> dp(1001, vector<int>(1001, -1));
        dp[0][0] = 0;

        FOR(j, 0, dp.size()) {
            FOR(k, 0, dp[0].size()) {
                if (dp[j][k] == -1) {
                    continue;
                }
                FOR(i, 0, m.size()) {
                    int h = m[i].first;
                    int r = m[i].second;

                    if (j < h and k < r) {
                        dp[h][r] = max(dp[h][r], dp[j][k] + 1);
                    }
                }
            }
        }

        int ans = 0;
        FOR(j, 0, dp.size()) {
            FOR(k, 0, dp[0].size()) {
                ans = max(ans, dp[j][k]);
            }
        }

        print(ans);
	}

	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 6800
final_rank: 10

code_snippet: #include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
int n, m, ans;
pair<int, int> doll[200];
int dp[1000][1000];
int main()
{
	while(cin >> n && n)
	{
		memset(dp, -1, sizeof(dp));
		ans = 0;
		dp[0][0] = 0;
		for(int i = 0; i < n; i++)
			cin >> doll[i].F >> doll[i].S;
		cin >> m;
		for(int i = n; i < n + m; i++)
			cin >> doll[i].F >> doll[i].S;
		sort(doll, doll + n + m);
		for(int i = 0; i < n + m; i++)
			for(int j = 0; j < doll[i].F; j++)
				for(int k = 0; k < doll[i].S; k++)
					dp[doll[i].F][doll[i].S] = max(dp[doll[i].F][doll[i].S], dp[j][k] + 1);

		for(int i = 0; i < 1000; i++)
			for(int j = 0; j < 1000; j++)
				ans = max(ans, dp[i][j]);
			cout << ans << endl;
	}

}
accuracy: 1
time_ms: 50
memory_kb: 7000
final_rank: 20

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

struct doll{
    int h,r;
};

bool operator<(const doll& d1,const doll& d2){
    if(d1.h == d2.h){
        return d1.r > d2.r;
    }
    return d1.h < d2.h;
}

int dp[1001][1001] = {0};//h,r

int main() {

    while(1){

        for(int i=0;i<1001;i++){
            for(int j=0;j<1001;j++){
                dp[i][j] = 0;
            }
        }

        int n;

        cin >> n;

        if(n==0) break;

        int h,r;

        vector<doll> v;
        doll tmp;

        for(int i=0;i<n;i++){
            cin >> h >> r;
            tmp.h = h;
            tmp.r = r;
            dp[h][r] = 1;
            v.push_back(tmp);
        }

        int m;

        cin >> m;

        for(int i=0;i<m;i++){
            cin >> h >> r;
            tmp.h = h;
            tmp.r = r;
            dp[h][r] = 1;
            v.push_back(tmp);
        }

        /*for(int i=0;i<n+m;i++){
            cout << v[i].h << " " << v[i].r << endl;
        }*/

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



        for(int k=0;k<n+m;k++) {
            for (int i = 1; i < v[k].h; i++) {
                for (int j = 1; j < v[k].r; j++) {
                    if (dp[i][j] != 0) {
                        dp[v[k].h][v[k].r] = max(dp[v[k].h][v[k].r], dp[i][j] + 1);
                    }
                }
            }
        }

        /*for(int i=0;i<=n+m;i++){
            for(int j=0;j<=n+m;j++){
                cout << dp[i][j] << " ";
            }
            cout << endl;
        }*/

        int ans = 0;

        for(int i=0;i<n+m;i++){
            //cout << dp[i] << endl;
            ans = max(dp[v[i].h][v[i].r],ans);
        }

        cout << ans << endl;


    }

    return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 7008
final_rank: 14

code_snippet: #include <algorithm>
#include <iostream>
using namespace std;

int N, M, h[200], r[200];

int main() {
    while (true) {
        cin >> N;
        if (N == 0) break;
        for (int j = 0; j < N; ++j) {
            cin >> h[j] >> r[j];
        }
        cin >> M;
        for (int j = 0; j < M; ++j) {
            cin >> h[j+N] >> r[j+N];
        }

        int arr[1001][1001];
        for (int j = 0; j <= 1000; ++j) fill(arr[j], arr[j] + 1001, 0);

        for (int j = 0; j < N+M; ++j) {
            arr[h[j]][r[j]] = 1;
        }

        int dp[1001][1001];
        for (int j = 0; j <= 1000; ++j) fill(dp[j], dp[j] + 1001, 0);

        for (int j = 0; j <= 1000; ++j) {
            for (int k = 0; k <= 1000; ++k) {
                if (j > 0 && k > 0) {
                    dp[j][k] = max(dp[j-1][k-1] + arr[j][k], max(dp[j-1][k], dp[j][k-1]));
                } else if (j > 0) {
                    dp[j][k] = dp[j-1][k];
                } else if (k > 0) {
                    dp[j][k] = dp[j][k-1];
                }
            }
        }

        cout << dp[1000][1000] << endl;
    }
    return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 10892
final_rank: 18

code_snippet: #include<bits/stdc++.h>
#define mk make_pair
#define f first
#define s second
using namespace std;
int n,m,p1,p2;
map<pair<int,pair<int,int> >,int >m1;

vector<pair<int,int> >v;

int dfs(int d,int h,int w){
  int res=0;
  if(m1[mk(d,mk(h,w))])return m1[mk(d,mk(h,w))];
  if(d==v.size()) return 0;
  if(v[d].f<h&&v[d].s<w)
    res=max(res,dfs(d+1,v[d].f,v[d].s))+1;
  res=max(res,dfs(d+1,h,w));
  return m1[mk(d,mk(h,w))]=res;
}

main(){
  while(cin>>n,n){
    m1.clear();
    v.clear();
    for(int i=0;i<n;i++){
      cin>>p1>>p2;
      v.push_back(mk(p2,p1));
    }
    cin>>m;
    for(int i=0;i<m;i++){
      cin>>p1>>p2;
      v.push_back(mk(p2,p1));
    }
    stable_sort(v.begin(),v.end(),greater<pair<int,int> >());
    for(int i=0;i<v.size();i++)swap(v[i].f,v[i].s);
    stable_sort(v.begin(),v.end(),greater<pair<int,int> >());
    cout<<dfs(0,1001,1001)<<endl;
  }
}
accuracy: 1
time_ms: 10
memory_kb: 3872
final_rank: 5

code_snippet: #include<bits/stdc++.h>
#define mk make_pair
#define f first
#define s second
using namespace std;
int n,m,p1,p2,dp[201][1001][1001];
map<pair<int,pair<int,int> >,int >m1;

vector<pair<int,int> >v;

int dfs(int d,int h,int w){
  int res=0;
  if(m1[mk(d,mk(h,w))])return m1[mk(d,mk(h,w))];
  if(d==v.size()) return 1;
  if(v[d].f<h&&v[d].s<w)
    res=max(res,dfs(d+1,v[d].f,v[d].s))+1;
  res=max(res,dfs(d+1,h,w));
  return m1[mk(d,mk(h,w))]=res;
}

main(){
  while(cin>>n,n){
    m1.clear();
    v.clear();
    for(int i=0;i<n;i++){
      cin>>p1>>p2;
      v.push_back(mk(p2,p1));
    }
    cin>>m;
    for(int i=0;i<m;i++){
      cin>>p1>>p2;
      v.push_back(mk(p2,p1));
    }
    stable_sort(v.begin(),v.end(),greater<pair<int,int> >());
    for(int i=0;i<v.size();i++)swap(v[i].f,v[i].s);
    stable_sort(v.begin(),v.end(),greater<pair<int,int> >());
    cout<<dfs(0,1001,1001)-1<<endl;
  }
}
accuracy: 1
time_ms: 10
memory_kb: 3800
final_rank: 4

code_snippet: #include <stdio.h>
#include <cmath>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
typedef long long int ll;

#define BIG_NUM 2000000000

using namespace std;

struct Info{
	Info(){
		h = 0;
		r = 0;
		used = false;
		may_in_num = in_num = 0;
	}
	int h,r,may_in_num,in_num;
	bool used;
};

void func(int n){

	Info info[401];
	int m;

	for(int i = 0; i < n; i++){
		scanf("%d %d",&info[i].h,&info[i].r);
	}

	scanf("%d",&m);

	for(int i = 0; i < m; i++){
		scanf("%d %d",&info[n+i].h,&info[n+i].r);
	}

	int count,maximum = 0,limit = n+m;

	while(true){
		count = 0;

		for(int i = 0; i < limit; i++){
			if(info[i].used)continue;
			for(int k = 0; k < limit; k++){
				if(info[k].used == false && info[k].h < info[i].h && info[k].r < info[i].r){
					info[i].may_in_num++;
				}
			}
		}

		for(int i = 0; i < limit; i++){
			if(info[i].may_in_num == 0){
				info[i].used = true;

				for(int k = 0; k < limit; k++){
					if(info[k].h > info[i].h && info[k].r > info[i].r){
						if(info[k].in_num < info[i].in_num+1){
							count++;
							info[k].in_num = info[i].in_num+1;
							maximum = max(maximum,info[k].in_num);
						}
					}
				}
			}
		}

		for(int i = 0; i < limit; i++){
			if(info[i].used == false){
				info[i].may_in_num = 0;
			}
		}

		if(count == 0)break;
	}

	printf("%d\n",maximum+1);

}

int main(){

	int n;

	while(true){
		scanf("%d",&n);
		if(n == 0)break;

		func(n);
	}

    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 2624
final_rank: 3

code_snippet: #include<iostream>
#include<string>
#include<cstdio>
#include<algorithm>
#include<stack>
#include<queue>
#include<vector>
#include<cmath>
#include<utility>
#include<set>
#include<complex>
#include<map>
#define vi vector<int>
#define vvi vector<vector<int> >
#define ll long long int
#define vl vector<ll>
#define vvl vector<vector<ll>>
#define vb vector<bool>
#define vc vector<char>
#define vs vector<string>
#define ld long double
#define INF 1e9
#define EPS 0.0000000001
#define rep(i,n) for(int i=0;i<n;i++)
#define loop(i,s,n) for(int i=s;i<n;i++)
#define CC puts("-------ok--------");
#define all(in) in.begin(), in.end()
using namespace std;
typedef pair<int, int> pii;
#define MAX 99999999
int main(){
    int n;
    while(cin>>n,n){
        vvi d(1040,vi(1040,0));
        vvi dp(1040,vi(1040,0));
        rep(i,n){
            pii temp; cin>>temp.first>>temp.second;
            d[temp.first][temp.second]++;
        }
        int m;
        cin>>m;
        rep(i,m){
            pii temp;
            cin>>temp.first>>temp.second;
            d[temp.first][temp.second]++;
        }
        loop(i,1,1001){
            loop(j,1,1001){
                dp[i][j]=max(max(dp[i-1][j],dp[i][j-1]),dp[i-1][j-1]+d[i][j]);
        
            }
        }
        cout<<dp[999][999]<<endl;
    }
    
}
accuracy: 1
time_ms: 40
memory_kb: 11268
final_rank: 19

code_snippet: #include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <queue>

using namespace std;

bool exist[2000][2000];
int max_doll[2000][2000];

int main(){
	
	int n, m;
	
	while(true){
		
		cin >> n;
		
		if(n == 0){
			break;
		}
		
		for(int i = 0; i <= 1000; i++){
			for(int j = 0; j <= 1000; j++){
				exist[i][j] = false;
				max_doll[i][j] = 0;
			}
		}
		
		int h, r;
		
		for(int i = 0; i < n; i++){
			cin >> h >> r;
			exist[h][r] = true;
		}
		
		cin >> m;
		
		for(int i = 0; i < m; i++){
			cin >> h >> r;
			exist[h][r] = true;
		}
		
		for(int i = 1; i <= 1000; i++){
			for(int j = 1; j <= 1000; j++){
				if(exist[i][j]){
					max_doll[i][j] = max(max(max_doll[i - 1][j], max_doll[i][j - 1]), max_doll[i - 1][j - 1] + 1);
				}else{
					max_doll[i][j] = max(max_doll[i - 1][j], max_doll[i][j - 1]);
				}
			}
		}
		
		cout << max_doll[1000][1000] << endl;
		
	}
	return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 12824
final_rank: 16

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main()
{
    while (true)
    {
        int n;
        cin>>n;
        if (n==0)
            break;
        vector<int> h(n), r(n);
        for (int i=0; i<n; i++)
            cin>>h[i]>>r[i];
        int m;
        cin>>m;
        h.resize(n+m);
        r.resize(n+m);
        for (int i=n; i<n+m; i++)
            cin>>h[i]>>r[i];

        vector<int> c(n+m, 1);
        for (int i=0; i<n+m; i++)
        for (int j=0; j<n+m; j++)
        for (int k=0; k<n+m; k++)
            if (h[k]<h[j] && r[k]<r[j])
                c[j] = max(c[j], c[k]+1);
        cout<<*max_element(c.begin(), c.end())<<endl;
    }
}
accuracy: 1
time_ms: 20
memory_kb: 1220
final_rank: 7

code_snippet: # define _CRT_SECURE_NO_WARNINGS 1
# define _USE_MATH_DEFINES
# include <iostream>
# include <numeric>
# include <string>
# include <bitset>
# include <vector>
# include <algorithm>
# include <cstdlib>
# include <cstdio>
# include <cstring>
# include <cstdlib>
# include <iomanip>
# include <queue>
# include <sstream>
# include <climits>
# include <cmath>
# include <list>
# include <functional>
# include <string>
# include <ctime>
# include <set>
# include <forward_list>
# include <map>
# include <stack>
using namespace std;
# define INF ((int)(1<<25))
# define REP(i,n) for(int i=0;i<(int)n;i++)
# define FOR(i,n) REP(i,n)
# define TORAD 2.0*M_PI/360.0
# define INT(x) int x;cin>>x;
# define ALL(x) (x).begin(),(x).end()
# define RALL(x) (x).rbegin(),(x).rend()
# define DEBUG(x) cout<<#x<<" :"<<x<<endl;
# define EPS 1e-12
template<class T> void debug(T a) { for (auto i : a)cout << i << endl; }
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef pair<int, pii> piii;
int dx[4] = { 0,1,0,-1 }, dy[4] = { -1,0,1,0 };

int n;
vi h, r;
int memo[2000][2000];
int dp(int H, int R)
{
	if (memo[H][R] != -1)return memo[H][R];
	int ans=0;
	for (int i = 0; i < n; i++)
	{
		if (h[i] > H&&r[i] > R)
		{
			ans = max(ans, dp(h[i], r[i]));
		}
	}
	ans++;
	return memo[H][R] = ans;
}
int main()
{
	while (cin >> n&&n)
	{
		memset(memo, -1, sizeof memo);
		h.clear();
		r.clear();
		FOR(i, n)
		{
			INT(H); INT(R);
			h.push_back(H);
			r.push_back(R);
		}
		INT(m);
		n += m;
		FOR(i, m)
		{
			INT(H); INT(R);
			h.push_back(H);
			r.push_back(R);
		}
		cout << dp(0, 0)-1 << endl;
	}
}
accuracy: 1
time_ms: 10
memory_kb: 18756
final_rank: 13

code_snippet: #include<iostream>
#include<string>
#include<cstdio>
#include<algorithm>
#include<stack>
#include<queue>
#include<vector>
#include<cmath>
#include<utility>
#define ll long long int
#define ld long double
#define INF 1000000000
#define EPS 0.0000000001
#define rep(i,n) for(i=0;i<n;i++)
using namespace std;
typedef pair<int, int> P;

string str;

int main()
{
  int n,m;
  int i,j;
  int h,r;

  while(1){

    int doll[1005][1005]={};
    int dp[1005][1005]={};

    scanf("%d",&n);
    if(n==0)break;
    rep(i,n){
      scanf("%d %d",&h,&r);
      doll[h][r]=1;
    }

    scanf("%d",&m);
    rep(i,m){
      scanf("%d %d",&h,&r);
      doll[h][r]=1;
    }
  
    for(i=1;i<1001;i++){
      for(j=1;j<1001;j++){
	dp[i][j]=max(max(dp[i-1][j],dp[i][j-1]),dp[i-1][j-1]+doll[i][j]);
      }
    }
 
    cout<<dp[1000][1000]<<endl;
  }
}
accuracy: 1
time_ms: 30
memory_kb: 9112
final_rank: 12

code_snippet: #include<iostream>
#include<queue>
using namespace std;
#define MAX_N 1000
int x[MAX_N], y[MAX_N], X[MAX_N][MAX_N], dist[MAX_N];
int A, B, N;
int main() {
	while (true) {
		cin >> A; if (A == 0) { break; } 
		for (int i = 0; i < A; i++) { cin >> x[i] >> y[i]; }
		cin >> B; 
		for (int i = A; i < A + B; i++) { cin >> x[i] >> y[i]; }N = A + B;
		for (int i = 0; i < N; i++) { 
			for (int j = 0; j < N; j++) { 
				if (x[i] < x[j] && y[i] < y[j]) { X[i][j] = 1; }
				else { X[i][j] = 0; }
			} 
		}
		queue<int>Q; int res = 0; for (int i = 0; i < N; i++) { dist[i] = 1; Q.push(i); }
		while (!Q.empty()) {
			int a1 = Q.front(); Q.pop();
			for (int i = 0; i < N; i++) {
				if (X[a1][i] == 1 && dist[a1] + 1 > dist[i]) { dist[i] = dist[a1] + 1; Q.push(i); }
			}
		}
		for (int i = 0; i < N; i++) { if (res < dist[i]) { res = dist[i]; } }cout << res << endl;
	}
}
accuracy: 1
time_ms: 10
memory_kb: 1940
final_rank: 1

code_snippet: #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define all(a)  (a).begin(),(a).end()
#define pb push_back
#define INF 999999999

int main(){
    int n,m;
    bool data[1000][1000]={};
    
    while(cin>>n&&n){
        rep(i,1000)rep(j,1000)data[i][j]=false;
        rep(i,n){
            int a,b;
            cin>>a>>b;
            data[a][b]=true;
        }
        cin>>m;
        rep(i,m){
            int a,b;
            cin>>a>>b;
            data[a][b]=true;
        }
        
        
        int dp[1002][1002];
        rep(i,1002)rep(j,1002)dp[i][j]=0;
        
        
        int maxi = 0;
        for(int i=999;i>=0;i--){
            for(int j=999;j>=0;j--){
                dp[i][j] = max({dp[i][j+1],dp[i+1][j],dp[i+1][j+1]+data[i][j],dp[i][j]});
                //            cout<<dp[i][j]<<endl;
                maxi = max(maxi,dp[i][j]);
            }
        }
        cout<<maxi<<endl;
    }
}
accuracy: 1
time_ms: 40
memory_kb: 7980
final_rank: 15

code_snippet: #include <cstdio>
#include <iostream>
#include <cmath>
#include <ctype.h>
#include <string> 
#include <sstream>
#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <map>
#include <queue>
#include <utility>
#include <vector>
#include <set>
#include <iomanip>
  
using namespace std;

#define pi 3.141592653589793

int main()
{
	int n, m;
	while(1){
		cin >> n;
		if(n == 0) break;
		int h, r;
		int mato[1001][1001] = {};
		for(int i = 0; i < n; i++){
			cin >> h >> r;
			mato[h][r] = 1;
		}
		cin >> m;
		for(int i = 0; i < m; i++){
			cin >> h >> r;
			mato[h][r] = 1;
		}
		int result[1001][1001] = {};
		int ans = 0;
		for(int i = 1; i < 1001; i++){
			for(int j = 1; j < 1001; j++){
				result[i][j] = max(result[i - 1][j - 1] + mato[i][j], max(result[i - 1][j], result[i][j - 1]));
				ans = max(ans, result[i][j]);
			}
		}
		cout << ans << endl;
	}
	return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 8992
final_rank: 11

code_snippet: #include <iostream>
#include <vector>

using namespace std;

int main() {
	int n;
	while ( cin >> n, n ) {
		vector<int> h(n), r(n);
		for (int i = 0; i < n; ++i) {
			cin >> h[i] >> r[i];
		}
		int M; cin >> M;
		h.resize(n+M);
		r.resize(n+M);
		for (int i = 0; i < M; ++i) {
			cin >> h[n+i] >> r[n+i];
		}
		n += M;

		int m[200][200] = {0};
		for (int i = 0; i < n; ++i) {
			for (int j = 0; j < n; ++j) {
				if (h[i] < h[j] && r[i] < r[j]) {
					m[i][j] = -1;
				}
			}
		}
		int ans = 0;
		for (int k = 0; k < n; ++k) for (int i = 0; i < n; ++i) for (int j = 0; j < n; ++j) {
			if (m[i][k] && m[k][j]) {
				m[i][j] = min(m[i][j], m[i][k] + m[k][j]);
			}
			ans = min(ans, m[i][j]);
		}
		cout << (-ans + 1) << endl;
	}
}
accuracy: 1
time_ms: 20
memory_kb: 1376
final_rank: 9

code_snippet: #include <iostream>
#include <vector>
#include <string>
#include <map>
#include <algorithm>

#define REP(i,n) for(int i=0;i<(int)(n);i++)

using namespace std;

int main() {
  while(1){
    int n,m;
    vector<vector<int>> a(1000);
    cin >> n;
    if(!n) break;
    for (int i = 0; i < n; ++i) {
      int h,r;
      cin >> h >> r;
      a[h].emplace_back(r);
    }
    cin >> m;
    for (int i = 0; i < m; ++i) {
      int h,r;
      cin >> h >> r;
      a[h].emplace_back(r);
    }
    vector<vector<int>> dp(1000,vector<int>(1000));
    for (int i = 1; i < 1000; ++i) {
      for (int j = 0; j < 1000; ++j) {
        dp[i][j] = dp[i-1][j];
        for (int r : a[i]) {
          if (r > j) continue;
          dp[i][j] = max(dp[i][j],dp[i-1][r-1]+1);
        }
      }
    }
    cout << dp[999][999] << endl;
  }
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 5052
final_rank: 6

code_snippet: #include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<cstring>
#include<map>
using namespace std;
vector<pair<int,int> >data;
map<pair<int,int>,int> dp[201];

int check(int i,pair<int,int> last)
{
  //  cout<<i<<" "<<endl;
  if(i<0)
    return 0;

  if(dp[i].count(last)!=0)
    return dp[i][last];


  int ans=0;
  if(last.first>data[i].first &&
     last.second>data[i].second )
    ans=check(i-1,data[i])+1;

  ans=max(ans,check(i-1,last));
  dp[i][last]=ans;
  return ans;
}

int main()
{
  int n;
  for(;cin>>n,n;)
    {
      data.clear();
      for(int i=0;i<n;i++)
	{
	  int h,r;
	  cin>>h>>r;
	  data.push_back(make_pair(h,r));
	}
      int m;
      cin>>m;
      for(int i=0;i<m;i++)
	{
	  int h,r;
	  cin>>h>>r;
	  data.push_back(make_pair(h,r));
	}
      sort(data.begin(),data.end());
      // memset(dp,-1,sizeof(dp));
      //int ans=;
      for(int i=0;i<201;i++)
	dp[i].clear();

      cout<<check(data.size()-1,make_pair(9999,9999))<<endl;
    }

}
accuracy: 1
time_ms: 10
memory_kb: 2144
final_rank: 2

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
void print(vector<vector<int> > dp){
  cout << "---------------" << endl;
  for(int i = 0;i  < dp.size();i++){
	for(int j = 0;j < dp.size();j++){
	  cout << dp[i][j] << " ";
	}
	cout << endl;
  }
}
int cal(vector<pair<int,int> > vec){
  vector<vector<int> > dp(vec.size(),vector<int>(vec.size(),0));  
  for(int i = 0;i < vec.size()-1;i++){
	for(int j = 0;j < vec.size();j++){
	  for(int k = j+1;k < vec.size();k++){
		if(vec[j].first > vec[k].first && vec[j].second > vec[k].second){
		  dp[i+1][k] = max(dp[i][j]+1,dp[i+1][k]);

		}
	  }
	}
  }
  int ans = 0;
  for(int i = 0;i < vec.size();i++){
	ans = max(ans,dp[vec.size()-1][i]);
  }
  return ans;
}
void print2(vector<int> vec){
  for(int i = 0;i < vec.size();i++)
	cout << vec[i] << " ";
  cout << endl;

}
int cal2(vector<pair<int,int> > vec){
  vector<int> dp(vec.size(),0);
  for(int i = 0;i < vec.size();i++){
	for(int j =i+1;j < vec.size();j++){
	  if(vec[i].first > vec[j].first && vec[i].second > vec[j].second){
		dp[j] = max(dp[i]+1,dp[j]);
	  }
	}
//	print2(dp);
  }
  int ans = 0;
  for(int i = 0;i < dp.size();i++){
	ans = max(ans,dp[i]);
  }
  return ans;
}
int main(){
  int n;

  while(cin >> n && n!=0){
	vector<pair<int,int> > vec;
	vec.emplace_back(10000,10000);
	for(int i = 0;i < n;i++){
	  int h,r;
	  cin >> h >> r;
	  vec.emplace_back(h,r);  
	}
	cin >> n;
	for(int i = 0;i < n;i++){
	  int h,r;
	  cin >> h >> r;
	  vec.emplace_back(h,r);
	}
	sort(vec.begin(),vec.end(),greater<pair<int,int> >());
	cout << cal(vec) << endl;
//	cout << cnt << endl;
  }
  return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 1348
final_rank: 8