Problem:
Score : 400 points

Problem Statement

Snuke found N strange creatures.
Each creature has a fixed color and size. The color and size of the i-th creature are represented by i and A_i, respectively.

Every creature can absorb another creature whose size is at most twice the size of itself.
When a creature of size A and color B absorbs another creature of size C and color D (C \leq 2 \times A), they will merge into one creature of size A+C and color B.
Here, depending on the sizes of two creatures, it is possible that both of them can absorb the other.

Snuke has been watching these creatures merge over and over and ultimately become one creature.
Find the number of the possible colors of this creature.

Constraints

2 \leq N \leq 100000

1 \leq A_i \leq 10^9

A_i is an integer.

Input

The input is given from Standard Input in the following format:

N
A_1 A_2 … A_N

Output

Print the number of the possible colors of the last remaining creature after the N creatures repeatedly merge and ultimately become one creature.

Sample Input 1

3
3 1 4

Sample Output 1

2

The possible colors of the last remaining creature are colors 1 and 3.
For example, when the creature of color 3 absorbs the creature of color 2, then the creature of color 1 absorbs the creature of color 3, the color of the last remaining creature will be color 1.

Sample Input 2

5
1 1 1 1 1

Sample Output 2

5

There may be multiple creatures of the same size.

Sample Input 3

6
40 1 30 2 7 20

Sample Output 3

4

Solution in Rust (1.42.0) (judge verdict: Accepted)

#![allow(non_snake_case)]
#![allow(unused_imports)]
use ascii::AsciiChar;
use ascii::AsciiStr;
use itertools::Itertools as _;
use permutohedron::LexicalPermutation as _;
use petgraph::algo::dijkstra;
use petgraph::algo::min_spanning_tree;
use petgraph::data::FromElements;
use petgraph::graph::NodeIndex;
use petgraph::graph::UnGraph;
use petgraph::unionfind::UnionFind;
use proconio::fastout;
use proconio::input;
use proconio::marker::Chars;
use proconio::marker::Usize1;
use std::cmp::max;
use std::cmp::min;
use std::collections::HashMap;
use std::collections::HashSet;
use std::collections::VecDeque;
use superslice::Ext as _;

#[fastout]
fn main() {
    input! {
        orig_N: usize,
        mut As: [i64; orig_N],
    }

    // どこかに境界線があるはず。ある強さ以上のモンスターは生き残る可能性があり、
    // ある強さ未満のモンスターはどうやっても生き残れない

    // 2分探索しつつ、「このモンスター生き残れますか」のクエリをO(N)くらいで回答できればよさそう。

    // 2分探索でis_ngを持つために、絶対に絶滅するモンスターを便宜的に投入しておく。
    // 必ず死ぬので、答えの値が大きくなることは無い。
    As.push(0); // 0しか吸収できないが、他のモンスターは1以上なので必ず死ぬ
    let N = orig_N + 1;
    As.sort();

    // 自分より弱いモンスターを全て食ってその和の大きさになるので、累積和を使うと効率が良い
    let mut acc = vec![0i64; N + 1];
    for i in 0..N {
        acc[i + 1] = acc[i] + As[i];
    }

    let mut is_ok = N - 1;
    let mut is_ng = 0;

    while is_ok - is_ng > 1 {
        let mid = (is_ok + is_ng) / 2;

        // とりあえず次のモンスターを食えるなら、少なくともmidは境界ではない。ではどちら?
        if As[mid + 1] <= 2 * acc[mid + 1] {
            // eprintln!("{} can eat {} : {} <= 2 * {}", mid, mid+1, As[mid+1], acc[mid+1]);

            // 敵をiとしてループを回し、倒していく
            let mut can_win = true;
            for i in mid + 1..N {
                if As[i] > 2 * acc[i] {
                    can_win = false;
                }
            }

            if can_win {
                is_ok = mid;
            } else {
                is_ng = mid;
            }
        } else {
            // eprintln!("{} is ng", mid);
            is_ng = mid;
        }
    }

    // dbg!(&As);
    // dbg!(&acc);
    // dbg!(is_ok);
    // dbg!(is_ng);

    println!("{}", N - (is_ng + 1));
}