CodeForces-1249C2-Good Numbers (hard version) -巧妙进制/暴力

The only difference between easy and hard versions is the maximum value of n.

You are given a positive integer number nn. You really love good numbers so you want to find the smallest good number greater than or equal to n.

The positive integer is called good if it can be represented as a sum of distinct powers of 33 (i.e. no duplicates of powers of 33 are allowed).

For example:

• 3030 is a good number: 30=33+3130=33+31,
• 11 is a good number: 1=301=30,
• 1212 is a good number: 12=32+3112=32+31,
• but 22 is not a good number: you can't represent it as a sum of distinct powers of 33 (2=30+302=30+30),
• 1919 is not a good number: you can't represent it as a sum of distinct powers of 33 (for example, the representations 19=32+32+30=32+31+31+31+3019=32+32+30=32+31+31+31+30 are invalid),
• 2020 is also not a good number: you can't represent it as a sum of distinct powers of 33 (for example, the representation 20=32+32+30+3020=32+32+30+30 is invalid).

Note, that there exist other representations of 1919 and 2020 as sums of powers of 33 but none of them consists of distinct powers of 33.

For the given positive integer n find such smallest m (n≤m) that m is a good number.

You have to answer qq independent queries.

Input

The first line of the input contains one integer q(1≤q≤500) — the number of queries. Then qq queries follow.

The only line of the query contains one integer  n(1≤n≤10¹⁸).

Output

For each query, print such smallest integer m (where n≤m) that m is a good number.

Example

Input

8
1
2
6
13
14
3620
10000
1000000000000000000

Output

1
3
9
13
27
6561
19683
1350851717672992089

题意：
对于每组数据， 给出一个n，要求求出大于等于n的m，m需要满足的条件是：由3的次方相加组成，且每个3的次方最多只能出现一次。

注意：
对于次方问题，最好用快速幂进行运算，运用pow会造成奇怪错误。

法一：三进制
思路：
由于求的答案与3的次方有关，所以可以把每一个给出来的n转换成三进制存到数组里再去进行判断，
比如给出一个n=14，转换成三进制的话就是112，从高位往低位进行判断，
如果存放进制的数组里面只含有1和0的话，说明该数是3的次方，直接输出即可
否则可以进行判断，从低位往高位找，找到第一个2记录下标且break

 #include<stdio.h>
 #include<algorithm>
 #include<string.h>
 using namespace std;
 const int N=1e4+;
 typedef unsigned long long ull;

 ull a[N];

 ull ksm(ull x,ull n)
 {
     ull res=;
     while(n>)
     {
         if(n&)
             res=res*x;
         x=x*x;
         n>>=;
     }
     return res;
 }

 int main()
 {
     int t;
     ull n;
     scanf("%d",&t);
     while(t--)
     {
         memset(a,,sizeof(a));
         scanf("%llu",&n);
         int p=;
         ull ans=n;
         while(n)
         {
             a[p++]=n%;
             n=n/;

         }
 //        for(int i=0;i<p;i++)
 //            printf("%d",a[i]);
 //        printf("\n");//211
         //从低位往高位找，找到第一个2记录下标且break
         int k=-;
         for(int i=p-;i>=;i--)
         {
             if(a[i]==)
             {
                 k=i;
                 break;
             }
         }
         if(k==-)
         {
             printf("%llu\n",ans);
             continue;
         }
 //        printf("%d***\n",k);
         for(int i=k;i<p;i++)
         {
             if(a[i]==)
             {
               a[i]=;
               a[i+]++;
             //  break;
 //            printf("%d***%d\n",i+1,a[i+1]);
             }
         }

         if(a[p]!=)
             p++;
         ull sum=;
         for(int i=p-;i>=k;i--)
         {
              sum=sum+a[i]*ksm(,i);
         }
         printf("%llu\n",sum);

     }
     return ;
 }

法二：暴力

思路：

• 首先数据给出的范围是10¹⁸，所以可以通过打表计算出3的几次方会超过该范围，打表得出是38，所以数字开到40就ok

ll sum=;
int k;
for(int i=;i<N;i++)
{
    sum=sum*;
    if(sum>=1e18)
    {
        printf("%d\n",i);//i==38
        break;
    }
}

• 把3的次方存入a数组中。
• 再来，开始分析题意，题意要求求的是满足条件最小的m，所以如果将a数组从小往大遍历的话，找到的m不一定是最小的，所以需要将a数组从大往小遍历，再把小于等于n的第一个数减掉。
• 还需要知道的一点就是3⁰+3¹+3²+...+3^n-1<3ⁿ，所以最后再从前往后遍历，找到没有被标记过的数，注意3⁰需要特判。

 #include<stdio.h>
 #include<algorithm>
 #include<string.h>
 using namespace std;
 const int N=1e4+;
 typedef long long ll;

 ll a[];
 bool book[N];

 ll ksm(ll x,ll n)
 {
     ll res=;
     while(n>)
     {
         if(n&)
             res=res*x;
         x=x*x;
         n>>=;
     }
     return res;
 }

 int main()
 {
     for(int i=; i<=; i++)
         a[i]=ksm(,i);
     int t;
     ll n;
     scanf("%d",&t);
     while(t--)
     {
         memset(book,,sizeof(book));
         scanf("%lld",&n);
         ll sum=;
         while()
         {
             int flag=;
             for(int i=; i>=; i--)
             {
                 if(a[i]<=n&&book[i]==)//第一个找到的就是最大的
                 {
                     sum+=a[i];
                     flag=;
                     book[i]=;
                     n-=a[i];
                     break;
                 }
             }
             if(flag==)
                 break;
         }
         if(n==)
         {
             printf("%lld\n",sum);
             continue;
         }
         ll kk;
         int k;
         for(int i=;i<=;i++)
         {
             if(book[i]==)
             {
               kk=a[i];
               k=i;
               break;
             }
         }
         sum=sum+kk;
         for(int i=;i<k;i++)
             sum-=a[i];
         printf("%lld\n",sum);
     }
     return ;
 }