Problem:
微生物実験(Bug Party)

あなたはJust Odd Inventions 社を知っているだろうか? この会社の業務は「ただ奇妙な発明(just odd inventions)」をすることである．ここでは略してJOI 社と呼ぶ．

JOI 社では多くの微生物を1 つのシャーレに生きたまま閉じ込める研究をしている．調査対象の微生物はN 匹存在し，1, 2, ... , N という番号がついている．各微生物はシャーレに閉じ込められると，foo (fatally odd object) と呼ばれる有害物質を一瞬のうちにシャーレ内に放出する．各微生物が放出するfoo の量は知られている．シャーレに閉じ込められた全微生物が放出したfoo はシャーレ内の各微生物が均等に摂取する．各微生物のfoo 許容量は知られており，この量を超えてfoo を摂取すると微生物は死んでしまう．

微生物i のfoo 放出量はai ミリグラム，foo 許容量はbi ミリグラムである．すなわち，シャーレに微生物i1, i2, ... , ik を閉じ込めたとき，シャーレ内の各微生物はそれぞれ(ai1 + ai2 + ... + aik)/k ミリグラムのfoo を摂取し，シャーレ内の微生物i は，この摂取量がbi より大きいと死んでしまう．

JOI 社からの委託により，あなたは出来るだけ多くの微生物をシャーレに生きたまま閉じ込めなければならない．ただし，微生物の死骸はシャーレ内の環境に悪影響を及ぼすため，シャーレ内のどの微生物もfoo の摂取で死んではならない．

なお，JOI 社が「ただ奇妙な発明」をすることでどうやって利益を得ているかは，今もって謎であり，JOI社内でも社長以外の誰も知らない．

課題

調査対象の微生物数と，各微生物のfoo 放出量とfoo 許容量が与えられたとき，1 つのシャーレに閉じ込めることができる微生物数の最大値を求めるプログラムを作成せよ．

制限

1 ≤ N ≤ 300000 = 3 × 105    調査対象の微生物の数

1 ≤ ai ≤ 100000 = 105    微生物i のfoo 放出量(ミリグラム)

1 ≤ bi ≤ 100000 = 105    微生物i のfoo 許容量(ミリグラム)

入力

標準入力から以下の入力を読み込め．

1 行目には整数N が書かれており，調査対象の微生物がN 匹存在することを表す．

続くN 行には各微生物の情報が書かれている．i + 1 行目(1 ≤ i ≤ N) には，正整数 ai, bi が空白を区切りとして書かれており，微生物i のfoo 放出量がai ミリグラムでfoo 許容量がbi ミリグラムであることを表す.

出力

標準出力に，1 つのシャーレに閉じ込めることができる微生物数の最大値を1 行で出力せよ．

注意

この問題では，扱う整数の範囲が32 ビットに収まらない可能性があることに注意せよ．

採点基準

採点用データのうち，配点の30% については，N ≤ 1000 を満たす．

入出力の例

入力例

6
12 8
5 9
2 4
10 12
6 7
13 9

出力例

3

この例では，微生物2, 4, 5 をシャーレに入れれば，放出されるfoo の合計量は5 + 10 + 6 = 21 ミリグラムとなり，それぞれの微生物が摂取するfoo の量は21/3 = 7 ミリグラムとなる．微生物2, 4, 5 のfoo 許容量はそれぞれ9, 12, 7 ミリグラムなので，シャーレ内のどの微生物も死なない．また，4 匹以上の微生物をどの微生物も死なないようにシャーレに入れることはできない．

問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。

Solution in C++14 (judge verdict: Wrong Answer)

//#include <bits/stdc++.h>
 
#include <iostream>
#include <algorithm>
 
#include <bitset>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <stack>
#include <queue>
#include <deque>
#include <cstring>
#include <string>
#include <utility>
#include <array>
#include <complex>
#include <valarray>
 
#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
#include <chrono>
#include <random>
#include <numeric>
 
 
using namespace std;
#define int long long
 
typedef long long ll;
typedef unsigned long long ull;
//typedef unsigned __int128 HASH;
typedef pair<int,int> pii;
typedef pair<ll, ll> pll;
typedef pair<ull, ull> pullull;
typedef pair<ll,int> plli;
typedef pair<double, int> pdbi;
typedef pair<int,pii> pipii;
typedef pair<ll,pll> plpll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<pii> vpii;
typedef vector<vector<int>> mat;
 
#define rep(i,n) for (int i=0;i<(n);i++)
#define rep2(i,a,b) for (int i=(a);i<(b);i++)
#define rrep(i,n) for (int i=(n);i>0;i--)
#define rrep2(i,a,b) for (int i=(a);i>b;i--)
#define pb push_back
#define fi first
#define se second
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
 
const ll hmod1 = 999999937;
const ll hmod2 = 1000000000 + 9;
const int INF = 1<<30;
const ll INFLL = 1LL<<62;
const double EPS = 1e-12;
const ll mod = 1000000000 + 7;
const int dx4[4] = {1, 0, -1, 0};
const int dy4[4] = {0, 1, 0, -1};
const int dx8[8] = {1, 1, 1, 0, 0, -1, -1, -1};
const int dy8[8] = {0, 1, -1, 1, -1, 0, 1, -1};
const double pi = 3.141592653589793;
 
#define addm(X, Y) (X) = ((X) + ((Y) % mod) + mod) % mod
#define inside(y, x, h, w) (0 <= (y) && (y) < (h) && 0 <= (x) && (x) < (w)) ? true : false

int n;
int a[100000 + 5], b[100000 + 5];
pair<int, int> sa[100000 + 5], sb[100000 + 5];

struct segtree {
    int size;
    vector<pair<long long, int>> node;

    segtree (int n) : size(1) {
        while (size < n) size *= 2;
        node.resize(2 * size - 1, make_pair(INFLL / 10, 100000 + 5));
		rep(i, n) node[i + size - 1].se = i;
    }

    void update(int k, int a) {
        k += size - 1;
        node[k].fi = a;
        while (k > 0){
            k = (k - 1) / 2;
			if (node[2 * k + 1] < node[2 * k + 2]) {
				node[k].fi = node[2 * k + 1].fi;
				node[k].se = node[2 * k + 1].se;
			}
			else {
				node[k].fi = node[2 * k + 2].fi;
				node[k].se = node[2 * k + 2].se;
			}
        }
    }
    //[queryL: queryR)
    pair<long long, int> get(int queryL, int queryR, int k = 0, int nodeL = 0, int nodeR = -1) {
        if (nodeR == -1) nodeR = size;
        if (nodeR <= queryL || queryR <= nodeL) return make_pair(INFLL / 10, -1);
        if (queryL <= nodeL && nodeR <= queryR) return make_pair(node[k].fi, node[k].se);
        else{
            int nodeM = (nodeL + nodeR) / 2;
            pair<long long, int> vl = get(queryL, queryR, 2 * k + 1, nodeL, nodeM);
            pair<long long, int> vr = get(queryL, queryR, 2 * k + 2, nodeM, nodeR);
			if (vl.fi < vr.fi) return make_pair(vl.fi, vl.se);
			else return make_pair(vr.fi, vr.se); 
        }
    }
};

signed main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
	cin >> n;
	rep(i, n) {
		cin >> a[i] >> b[i];
		sb[i].fi = b[i];
		sb[i].se = i;
		sa[i].fi = a[i];
		sa[i].se = i;

	}
	sort(sb, sb + n);
	sort(sa, sa + n);
	int l = 0, r = n + 1;
	while (r -  l > 1) {
		segtree seg(n);
		rep(i, n) seg.update(i, a[i]);
		int m = (r + l) / 2;
		int sum_a = 0;
		bool checked[n] = {};
		rep(i, m - 1) {
			int idx = sa[i].se;
			seg.update(idx, 1e12);
			checked[idx] = true;
			sum_a += sa[i].fi;
		}
		/*
		rep(i, n) cout << sa[i].fi << " " << sa[i].se << " ";
		cout << endl;
		cout << m << " " << sum_a << endl; 
		*/
		bool ok = false;
		rep(i, n) {
			int idx = sb[i].se;
			if (checked[idx]) {
				pair<int, int> p = seg.get(0, n);
				if (p.fi == 1e12) break;
				checked[p.se] = true;
				seg.update(p.se, 1e12);
				if (sum_a + p.fi <= m * b[idx]) {
					ok = true;
					break;
				}
				sum_a -= a[idx];
				sum_a += p.fi;
			}
			else {
				checked[idx] = true;
				seg.update(idx, 1e12);
				if (sum_a + a[idx] <= m * b[idx]) {
					ok = true;
					break;
				}
			}
		}
		if (ok) l = m;
		else r = m;
	}
	cout << l << endl;
}