学步园

有一棵无限完全二叉树，他的根节点是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]范围内。

4
1 2
2 1 2
1 5
2 3 2

1 2
2
3 2
5

刚开始一直在想有什么规律，结果想半天看不出有什么规律，最后看别人提示，突破口在与隐含的完全二叉树这个条件。。。

对于给定的N或在 p/q，都能找到它到根的这么一条路径，有了这条路径就好做了。

所以复杂度是O(logN)的。

#include<iostream>
#include<cstdio>
#include<vector>
#include<string>
#include<cstring>
#include<climits>
#include<algorithm>
using namespace std;
void calNth(int n,int& p,int& q)
{
	vector<int> path;
	while(n!=1)
	{
		path.push_back(n%2);
		n>>=1;
	}
	p=1,q=1;
	for(int i=path.size()-1;i>=0;i--)
	{
		int t=p+q;
		if(path[i])
			p=t;
		else
			q=t;
	}
}
int solve(int p,int q)
{
	vector<int> path;
	while(p!=1||q!=1)
	{
		if(p>q)
		{
			path.push_back(1);
			p=p-q;
		}
		else
		{
			path.push_back(0);
			q=q-p;
		}
	}
	int cnt=0;
	int k=1,n=1;
	for(int i=path.size()-1;i>=0;i--)
	{
		cnt+=n;
		n<<=1;
		k=(k-1)*2+1+path[i];
	}
	cnt+=k;
	return cnt;
}

int main()
{
	int t;
	while(scanf("%d",&t)!=EOF)
	{
		int type=0;
		scanf("%d",&type);
		if(type==1)
		{
			int n;
			scanf("%d",&n);
			int p,q;
			calNth(n,p,q);
			printf("%d %d\n",p,q);
		}
		else
		{
			int p,q;
			scanf("%d%d",&p,&q);
			int n=solve(p,q);
			printf("%d\n",n);
		}
	}
}