HDU-5573 Binary Tree(构造/二进制)

Binary Tree

Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 65536/65536K (Java/Other)

Total Submission(s) : 3   Accepted Submission(s) : 3

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 $f_{root} = 1$.

And for each node $u$, labels as $f_u$, the left child is $f_u \times 2$ and right child is $f_u \times 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 $f_x$ (remember $f_{root} = 1$), he can choose to increase his number of soul gem by $f_x$, or decrease it by $f_x$.

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. $\cdot$ $1 \leq T \leq 100$. $\cdot$ $1 \leq N \leq 10^9$. $\cdot$ $N \leq 2^K \leq 2^{60}$.

 

Output

For every test case, you should output "[b]Case #x:[/b]" 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亚洲区上海站-重现赛（感谢华东理工）

再次深刻理解了二进制的原理,,,,,,,
题意:给你一个二叉树，根节点为1，子节点为父节点的2倍和2倍+1，从根节点开始依次向下走k层，问如何走使得将路径上的数进行加减最终结果得到n
题解:构造/二进制,可以发现2^0,2^1,...,2^(k-1)可以构成任意一个小于2^k的数,并且2^0+2^1+...2^(k-1)=2^k-1,由于n<=2^k,所以我们可以一直沿着树的最左边向下走,
设mx=(2^k-1-n)/2,那么mx就是向下走的时候,要减去的数的总和(因为要把所有节点加起来才能等于2^k-1,如果还需要减去某些数才能等于n,那么mx一定是这些数总和的一半)
如果n是偶数,先让n--,然后在取最下面那个节点时取右边的

#include<cstdio>
typedef long long LL;
LL pow(LL a,int b){
    LL ret=1;
    while(b){
        if(b&1) ret=ret*a;
        a=a*a;
        b>>=1;
    }
    return ret;
}
int main(){
    int T,k;
    LL n;
   // freopen("in.txt","r",stdin);
    scanf("%d",&T);
    for(int cas=1;cas<=T;cas++){
        scanf("%I64d%d",&n,&k);
        bool flag=0;
        if(n%2==0) flag=1,n--;
        LL mx=(pow(2ll,k)-1-n)/2;   //不但没有加上mx还要减去mx,所以是2^k-1-n的一半
        printf("Case #%d:\n",cas);
        //printf("%I64d\n",mx);
        for(int i=0;i<k-1;i++){
            if((mx>>i)&1) printf("%I64d -\n",pow(2,i));
            else printf("%I64d +\n",pow(2,i));
        }
        printf("%I64d %c\n",pow(2,k-1)+(flag?1:0),((mx>>(k-1))&1)?'-':'+');
    }
}