Codeforces 722D Generating Sets【优先队列+贪心】

最新推荐文章于 2024-12-01 03:34:23 发布

最新推荐文章于 2024-12-01 03:34:23 发布 · 402 阅读

文章标签：

#Codeforces 722D

贪心同时被 2 个专栏收录

186 篇文章

订阅专栏

队列和栈

43 篇文章

订阅专栏

本文介绍了一个算法问题，即如何构造一个最小最大值的整数集合X，通过特定操作能生成给定的整数集合Y。文章详细阐述了解决方案，包括问题分析、核心思路和AC代码实现。

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

You are given a set Y of n distinct positive integers y₁, y₂, ..., y_n.

Set X of n distinct positive integers x₁, x₂, ..., x_n is said to generate set Y if one can transform X to Y by applying some number of the following two operation to integers in X:

Take any integer x_i and multiply it by two, i.e. replace x_i with 2·x_i.
Take any integer x_i, multiply it by two and add one, i.e. replace x_i with 2·x_i + 1.

Note that integers in X are not required to be distinct after each operation.

Two sets of distinct integers X and Y are equal if they are equal as sets. In other words, if we write elements of the sets in the array in the increasing order, these arrays would be equal.

Note, that any set of integers (or its permutation) generates itself.

You are given a set Y and have to find a set X that generates Y and the maximum element of X is mininum possible.

Input

The first line of the input contains a single integer n (1 ≤ n ≤ 50 000) — the number of elements in Y.

The second line contains n integers y₁, ..., y_n (1 ≤ y_i ≤ 10⁹), that are guaranteed to be distinct.

Output

Print n integers — set of distinct integers that generate Y and the maximum element of which is minimum possible. If there are several such sets, print any of them.

Examples

Input

5
1 2 3 4 5

Output

4 5 2 3 1

Input

6
15 14 3 13 1 12

Output

12 13 14 7 3 1

Input

6
9 7 13 17 5 11

Output

4 5 2 6 3 1

题目大意：

让你构造一个长度为N的数组X【】，使得其能够通过两种操作得到数组Y【】；

现在给你一个数组Y【】，让你构造一个可行X【】，使得其中最大值尽可能的小。

两种操作：

选择x【i】，使得其变成X【i】*2或者是X【i】*2+1.....

保证Y【】是一个不包含重复元素的数组，要求X【】也不能包含重复元素。而且所有元素大于0.

思路：

1、考虑问题本质，其实我们最开始可以设定ans【】（X【】）就是Y【】；

然后尽可能的缩小最大值，来寻找一个最终序列，使得X【】中最大元素尽可能的小。

2、那么首先我们将数组Y【】从大到小排序，然后全部塞到一个优先队列中，每次我们拿出最大值，肯定想要做到的就是将这个数变小，变成一个和此时队列中所有元素不相同的小值。

那么我们每一次取队头元素，将其尽可能的变小，如果可以变小，再将变小的值塞进队列，继续取队头，循环往复。

直到不能变小为止，停止操作即可。

Ac代码：

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<map>
#include<queue>
using namespace std;
struct node
{
    int val;
    friend bool operator <(node a,node b)
    {
        return a.val<b.val;
    }
}nod;
int a[50050];
int ans[50050];
int b[500];
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        for(int i=0;i<n;i++)scanf("%d",&a[i]);
        sort(a,a+n);reverse(a,a+n);
        priority_queue<node>s;
        map<int ,int >ss;
        for(int i=0;i<n;i++)
        {
            nod.val=a[i];
            ss[a[i]]=1;
            s.push(nod);
        }
        while(1)
        {
            int flag=0;
            nod=s.top();
            while(nod.val)
            {
                nod.val/=2;
                if(ss[nod.val]==0&&nod.val!=0)
                {
                    flag=1;
                    ss[nod.val]=1;
                    s.pop();
                    s.push(nod);
                    break;
                }
            }
            if(flag==0)break;
        }
        while(!s.empty())
        {
            nod=s.top();
            s.pop();
            printf("%d ",nod.val);
        }
        printf("\n");
    }
}