题目1543：无限完全二叉树的层次遍历

时间限制：1 秒

内存限制：128 兆

特殊判题：否

题目描述：: 有一棵无限完全二叉树，他的根节点是1/1,且任意一个节点p/q的左儿子节点和右儿子节点分别是，p/(p+q)和(p+q)/q。如下图：

它的层次遍历结果如下：
1/1, 1/2, 2/1, 1/3, 3/2, 2/3, 3/1,...
有如下两类问题：
1.找到层次遍历的第n个数字。如，n为2时，该数字为1/2;
2.给定一个数字p/q,输出它在层次遍历中的顺序，如p/q为1/2时，其顺序为2;

输入：: 输入包含多组测试用例，输入的第一行为一个整数T，代表共有的测试用例数。
接下去T行每行代表一个测试用例，每个测试用例有如下两种类型
1.1 n。输出层次遍历中，第n个数字。
2.2 p q。输出p/q在层次遍历中的顺序。
1 ≤ n, p, q ≤ 2^64-1

输出：: 对于每个测试用例，若其类型为1，输出两个整数p q，代表层次遍历中第n个数字为p/q。
若其类型为2，输出一个整数n，代表整数p/q在层次遍历的中的顺序n。
数据保证输出在[1,2^64-1]范围内。

样例输入：

样例输出：

1 2
2
3 2
5

递归的版本比较好懂一些。一定要注意细节，比如int随便替换LL就会RE。思想也就是从上到下，或者从下到上。

#include <iostream>
#include <stdio.h>
#include <queue>
#include <stdio.h>
#include <string.h>
#include <vector>
#include <queue>
#include <set>
#include <algorithm>
#include <map>
#include <stack>
#include <math.h>
#define Max(a,b) ((a)>(b)?(a):(b))
#define Min(a,b) ((a)<(b)?(a):(b))
using namespace std ;
typedef unsigned long long LL ;
struct Node{
   LL P ;
   LL Q ;
   Node(){} ;
   Node(LL p ,LL q):P(p),Q(q){} ;
};
stack<string>way;
void dfs(LL id){
      if(id<=1)
         return  ;
      if(id&1)
         way.push("R") ;
      else
         way.push("L") ;
      dfs(id>>1) ;
}
void gao_case1(LL N){
    while(!way.empty())
         way.pop() ;
    dfs(N)   ;
    Node now=Node((LL)1,(LL)1) ;
    LL p ,q ;
    while(!way.empty()){
        if(way.top()=="L"){
            p=now.P ;
            q=now.P+now.Q ;
        }
        else{
            p=now.P+now.Q ;
            q=now.Q ;
        }
        now=Node(p,q) ;
        way.pop() ;
    }
    cout<<now.P<<" "<<now.Q<<endl ;
}
void dfs2(Node now){
      if(now.P==1&&now.Q==1)
         return  ;
      LL p ,q  ;
      if(now.P<now.Q){
         p=now.P ;
         q=now.Q-now.P ;
         way.push("L") ;
      }
      else{
         p=now.P-now.Q ;
         q=now.Q ;
         way.push("R") ;
      }
      dfs2(Node(p,q)) ;
}
void gao_case2(LL p ,LL q){
    while(!way.empty())
         way.pop() ;
    dfs2(Node(p,q)) ;
    LL ans=1  ;
    while(!way.empty()){
         if(way.top()=="L")
            ans*=2 ;
         else
            ans=ans*2+1 ;
         way.pop() ;
    }
    cout<<ans<<endl ;
}
int main(){
    LL type  , N ,P ,Q ,T;
    cin>>T  ;
    while(T--){
        cin>>type ;
        if(type==1){
              cin>>N ;
              gao_case1(N)  ;
        }
        else{
            cin>>P>>Q  ;
            gao_case2(P,Q) ;
        }
    }
    return 0 ;
}

Long Long、__int64使用总结

　　在32位环境下，int占32位，unsigned int占16位，long/unsigned long占32位
何时需要使用：
　　long 和 int 范围是[-2^31,2^31)，即-2147483648~2147483647，

而unsigned范围是[0,2^32)，即0~4294967295，所以常规的32位整数只能够处理40亿左右，当遇到比40亿大的多的数就要用到64位。
64位使用范围：
　　不同的编译器对64位整数的扩展有所不同，VC使用__int64/unsigned __int64，范围是[-2^63, 2^63)和[0,2^64)，即-9223372036854775808~9223372036854775807与 0~18446744073709551615(约1800亿亿)。
注意点：
1、编译器不同导致使用64位的申明方式不同;
2、long long / unsigned long long 一般是Linux下申明方式、如：G++
3、__int64 /unsigned __int64一般是Windows下使用64位的申明方式，如:VS
4、在赋值时需要注意加上ll进行显式赋值;
5、当进行64位与 32位的混合运算时，32位整数会被隐式转换成64位整数。
6、输出printf("");,long long使用%lld输出，__int64使用%I64d，无符号使用u替代d即可。
7、测试下来编译器一般都支持2种操作，不必太过纠结，怎么使用看个人喜欢。