HDU5573 Binary Tree

Binary Tree

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 985    Accepted Submission(s): 579
Special Judge

Problem Description

The Old Frog King lives on the root of an infinite tree. According to the law, each node should connect to exactly two nodes on the next level, forming a full binary tree.

Since the king is professional in math, he sets a number to each node. Specifically, the root of the tree, where the King lives, is  1 . Say  froot=1 .

And for each node  u , labels as  fu , the left child is  fu×2  and right child is  fu×2+1 . The king looks at his tree kingdom, and feels satisfied.

Time flies, and the frog king gets sick. According to the old dark magic, there is a way for the king to live for another  N  years, only if he could collect exactly  N soul gems.

Initially the king has zero soul gems, and he is now at the root. He will walk down, choosing left or right child to continue. Each time at node  x , the number at the node is  fx  (remember  froot=1 ), he can choose to increase his number of soul gem by  fx , or decrease it by  fx .

He will walk from the root, visit exactly  K  nodes (including the root), and do the increasement or decreasement as told. If at last the number is  N , then he will succeed.

Noting as the soul gem is some kind of magic, the number of soul gems the king has could be negative.

Given  N ,  K , help the King find a way to collect exactly  N  soul gems by visiting exactly  K  nodes.

 

Input

First line contains an integer  T , which indicates the number of test cases.

Every test case contains two integers  N  and  K , which indicates soul gems the frog king want to collect and number of nodes he can visit.

⋅   1≤T≤100 .

⋅   1≤N≤109 .

⋅   N≤2K≤260 .

 

Output

For every test case, you should output " Case #x:" first, where  x  indicates the case number and counts from  1 .

Then  K  lines follows, each line is formated as 'a b', where  a  is node label of the node the frog visited, and  b  is either '+' or '-' which means he increases / decreases his number by  a .

It's guaranteed that there are at least one solution and if there are more than one solutions, you can output any of them.

 

Sample Input

  
  

   
   2
5 3
10 4
  
  

 

Sample Output

  
  

   
   Case #1:
1 +
3 -
7 +
Case #2:
1 +
3 +
6 -
12 +
  
  

 

Source

2015ACM/ICPC亚洲区上海站-重现赛（感谢华东理工）

题意：对于给定的 n,k，有一颗满二叉树，起点是1，初始拥有的值sum为0，n是要最终要求得的值，k是可以进行几次操作，每次可以从当前位置向左右孩子节点前进，然后sum可以进行加减当前结点的值操作，最终输出具体操作内容。

思路：直接搜索肯定是不行，对于当前每步都有4种选择，最多可以进行60次迭代，4^60，感觉应该和二进制有关，但是没有想到该怎么做，看了一眼别人的思路突然就明白了。先全部选择二进制数，1,2,4,8,。。。。然后开始调整。举个栗子，n=6,k=4,那么需要选择4次，sum=1+2+4+8=15，对于目标n=6，多出来d=15-6=9，下面我们的目标就是，进行4次操作，加加减减，要想办法把多出来的9给消除掉，要达到15需要经历4次操作，那么就没有剩下的步骤可以用来减去9，如果对于所有做加操作的数，我们可以让他们的和达到多于d的一半，然后对于减法操作也同样达到d的一半，合起来的时候就可以很容易的使加减操作的最终结果等于n了。但是也会出现d=9是奇数的情况，为了方便操作，一开始就把sum的值增加一，即最后一个二进制数选择右孩子，d就会变成偶数。

#include <iostream>
#include <stdio.h>
#include <string>
#include <cstring>
#include <algorithm>
#include <cmath>
#define ll __int64
using namespace std;
int n,k;
int s[100][2];
int flag;
int vis[100];
ll a[100];

//void dfs(int x,int cnt,int t)  //直接爆搜
//{
//    if(flag)return;
//    if(cnt==k)
//    {
//        if(x==n)
//        {
//            flag=1;
//            return;
//        }
//        return;
//    }
//    s[cnt][0]=1;
//    s[cnt][1]=t;
//    dfs(x+t,cnt+1,t*2);
//    if(flag)return;
//
//    s[cnt][0]=0;
//    s[cnt][1]=t;
//    dfs(x-t,cnt+1,t*2);
//    if(flag)return;
//
//    s[cnt][0]=1;
//    s[cnt][1]=t;
//    dfs(x+t,cnt+1,t*2+1);
//    if(flag)return;
//
//    s[cnt][0]=0;
//    s[cnt][1]=t;
//    dfs(x-t,cnt+1,t*2+1);
//    if(flag)return;
//
//}

int main()
{
    int T;
    a[0]=1LL;
    for(int i=1;i<=60;i++)
    {
        a[i]=a[i-1]*2;
    }

    scanf("%d",&T);
    int ca=1;
    while(T--)
    {
        scanf("%d%d",&n,&k);

        memset(vis,0,sizeof vis);
        ll sum=0;
        flag=0;
        for(int i=0;i<k;i++)
        {
            sum+=a[i];
        }
        ll d=sum-n;

        if(d%2)  //如果d是奇数，就加一，并且标记最后选择右孩子
        {
            flag=1;
            d++;
        }
        ll x=d/2;

       for(int i=k-1;i>=0;i--)
       {
           if(x>=a[i])
           {
               x-=a[i];
               vis[i]=1;  //标记一下哪些是减法
           }
       }
       printf("Case #%d:\n",ca++);

       for(int i=0;i<k-1;i++)
       {
           printf("%I64d ",a[i]);
           if(vis[i])
            puts("-");
           else
            puts("+");
       }
       if(flag) //若标记则最后选择右孩子
       {
            printf("%I64d ",a[k-1]+1);
       }
       else
       {
            printf("%I64d ",a[k-1]);
       }

        if(vis[k-1])
            puts("-");
           else
            puts("+");

    }
    return 0;
}