Codeforces 373C Counting Kangaroos is Fun(双游标贪心)

最新推荐文章于 2020-07-08 11:59:30 发布

等我学会后缀自动机

最新推荐文章于 2020-07-08 11:59:30 发布

阅读量214

点赞数

CC 4.0 BY-SA版权

分类专栏： Codeforces习题集贪心策略/决策问题

本文链接：https://blog.youkuaiyun.com/qq_37451344/article/details/80833407

Codeforces习题集同时被 2 个专栏收录

218 篇文章

订阅专栏

贪心策略/决策问题

62 篇文章

订阅专栏

给定n只袋鼠，每只有大小。一只袋鼠可以放入另一只大小至少是其两倍的袋鼠口袋中。每个袋鼠最多能抱一只袋鼠，被抱的袋鼠无法再抱其他袋鼠。求一种抱袋鼠方案，使得最少有多少只袋鼠能从外部看到。输入为每只袋鼠的大小，输出为最少可见袋鼠数量。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

There are n kangaroos with pockets. Each kangaroo has a size (integer number). A kangaroo can go into another kangaroo's pocket if and only if the size of kangaroo who hold the kangaroo is at least twice as large as the size of kangaroo who is held.

Each kangaroo can hold at most one kangaroo, and the kangaroo who is held by another kangaroo cannot hold any kangaroos.

The kangaroo who is held by another kangaroo cannot be visible from outside. Please, find a plan of holding kangaroos with the minimal number of kangaroos who is visible.

Input

The first line contains a single integer — n (1 ≤ n ≤ 5·10⁵). Each of the next n lines contains an integer s_i — the size of the i-th kangaroo (1 ≤ s_i ≤ 10⁵).

Output

Output a single integer — the optimal number of visible kangaroos.

Examples

Input

8
2
5
7
6
9
8
4
2

Output

Input

8
9
1
6
2
6
5
8
3

Output

#include<algorithm>
#include<iostream>
#include<string>
#include<map>//int dx[4]={0,0,-1,1};int dy[4]={-1,1,0,0};
#include<set>//int gcd(int a,int b){return b?gcd(b,a%b):a;}
#include<vector>
#include<cmath>
#include<stack>
#include<string.h>
#include<stdlib.h>
#include<cstdio>
#define maxn (6*100000)
#define UB (maxn*64)
#define ll __int64
#define INF 10000000
using namespace std;
int seq[maxn],vis[maxn],n;
/*
题目大意：给n个袋鼠的大小，然后大袋鼠可以装小袋鼠（条件：大小至少是其二倍），
问最少的袋鼠可见数量（题目较水，，，每个袋鼠只能装一个，被装过的不能再装)

又TM复杂化了，，，
我原先的做法是降序排列然后顺序扫描，
对每个扫到的二倍数值用整个区间二分处理找最后一个大于这个数的位置，
如果没有则跳过。。。云云

看了网上的大佬，，，
原来这题简单的一批。。。。
正序排列，然后贪心思想体现在，，，最多可见n/2个，不如就从1~n/2区间找被装的袋鼠，
降序从n/2开始递减扫描，用依次用最大的去套。

正确性分析：该方法的正确性在于用这种方法一定可以找到最好的而且不存在更好的。
对于i和i+1个数，如果对应的j和j+1满足条件，那么如果存在一个更好的使
i对应j+1，i+1对应i，那么一定可以调整成不差的i对应j，和i+1对应j+1（所讨论的均是下标对应的数字）
这样分析的话，那任意乱序的方法都可以通过上述优化调整成有序的有规律的对应，
既然这样很明显让这个连续段余越靠后越好，
这就是该算法的正确性之妙了。
*/

/*
bool cmp(const int& x,const int& y)
{
    return x>y;
}

int binarysearch(int val)
{
    int l=0,r=n;
    while(l+1<r)
    {
        int mid=(l+r)>>1;
        if(seq[mid]>=val) l=mid;
        else r=mid;
    }
    if(seq[r]>=val) return r;
    if(seq[l]>=val) return l;
    return -1;
}
*/

int main()
{
     scanf("%d",&n);
    for(int i=1;i<=n;scanf("%d",&seq[i++]) );
    sort(seq+1,seq+n+1);

    int cnt=n,tp=0;
    for(int i=n/2;i>=1;i--)
    {
        if(seq[i]*2<=seq[cnt])
        {
            cnt--;
            tp++;
        }
    }
    //puts("");
    printf("%d\n",n-tp);
    return 0;
}