Z-scan方阵

Z-scan方阵

总时间限制: 1000ms 内存限制: 1024kB

描述

Z-scan方阵是一种边长为2n的方阵。例如，边长为2，4，8的Z-scan方阵为：

即按照类似于“之”字形的方式，将0到2n×2n-1依次放置到方阵中。类似地，按照此规律继续放置，可以产生出边长为16，32，…等的Z-scan方阵。

现在给定非负数n和m，请求出数m位于边长为2n的Z-scan方阵的行数和列数。例如当n=2,m=13时应当返回3和4，表示13位于方阵的第3行第4列。保证n不超过10，m小于2n×2n。

输入

输入包含多行，每行两个非负数n和m，中间用空格隔开
当n和m都为0时，表示输入结束，该组输入不用处理

输出

输出包含多行，每行两个整数，表示数m位于边长为2的n次方的Z-scan方阵的行数和列数，中间用空格隔开

样例输入

1 3
2 13
0 0

样例输出

2 2
3 4

我的

#include <stdio.h>
#include<math.h>
#include<string.h>

int main()
{
	int m, n;
	while (1)
	{
		scanf("%d%d", &n, &m);
		if (m == 0 && n == 0)return 0;
		if (m == 0)printf("1 1\n");//边界条件：因为pow(2,0)=1，所以需要补充一个small=0的情况（也就是没有更小的单元的情况）
		else
		{
			for (int i = 0; i <= n; i++)
			{
				int small = (int)pow(2, i);
				if (small * small <= m && m < small * small * 4)
				{
					int hang, lie;
					if (small * small <= m && m < small * small * 2)
					{
						int tmp = m - small * small + 1;
						hang = tmp / small + 1;
						lie = small + tmp % small;
						if (lie == small)lie = small * 2, hang--;
						printf("%d %d\n", hang, lie);
						break;
					}
					if (small * small * 2 <= m && m < small * small * 3)
					{
						int tmp = m - small * small * 2 + 1;
						hang = small + tmp / small + 1;
						lie = tmp % small;
						if (lie == 0)lie = small, hang--;
						printf("%d %d\n", hang, lie);
						break;
					}
					if (small * small * 3 <= m && m < small * small * 4)
					{
						int tmp = m - small * small * 3 + 1;
						hang = small + tmp / small + 1;
						lie = small + tmp % small;
						if (lie == small)lie = small * 2, hang--;
						printf("%d %d\n", hang, lie);
						break;
					}
				}
			}
		}
	}
}

正确输入输出

9 181–13 8
9 300–7 19
9 256–1 17
3 63–8 8
3 57–7 6
3 47–8 4
3 45–7 4

我的输入输出

9 181–15 6
9 300–3 29
9 256–1 17
3 63–8 8
3 57–7 6
3 47–8 4
3 45–8 2

我到现在才发现我还是看错题了，考试的时候看错了，之后重看又看错了，考完重做还是没发现出来，我死了啊啊啊啊啊啊啊啊

我还是直观太强：
考试的时候就以为是右上角小方阵+下方长方形阵的排列方式；
之后认为在8×8的矩阵的除开左上角以外的每个4×4的小方阵里面都是顺序排列，即

然而实际上却是

求你读题认真一点吧！！！

认真看一眼题之后：

这样的扫描方式显然会比之前自己想象中的排列方式更加复杂一点。
仔细一看是以边长为2的方形为最小单位的，在每个最小单位中，数字依大小按z的顺序排列；
但是需要注意的是，每个最小单位的排列也是z字形的，组成了边长为4的次级单位，而每个次级单位的排列也是按z字的顺序来的…依次推下去，可以想到需要用到递归（有一种分型的感jio）。

于是就有了标答里面的递归函数，从n开始不断缩小m在整个方阵里面的相对位置，而递归出口就是当缩小到2×2方阵（最小单位）的时候，直接根据m在最小单位中的相对位置得出最终的绝对位置，并离开递归。

标答

#include <stdio.h>
#include<math.h>
#include<string.h>

int hang, lie;
void f(int m, int n)
{
    if (n == 1) // 边界条件：边长为2，直接计算出其横纵坐标
    {    	
        hang += (m >> 1);
        lie += (m & 1);
        //m可能的取值其实只有0、1、2、3，二进制对应于0 1 10 11
        //感jio这样写有点没必要，但是理解一下也还行
        return;
    }
    int l = 1 << (n - 1); // 计算1/4子块的边长
    int s = l * l;
    switch (m / s)
    {
    case 0: hang += 0; lie += 0; break;
    case 1: hang += 0; lie += l; break;
    case 2: hang += l; lie += 0; break;
    case 3: hang += l; lie += l; break;
    }
    f(m % s, n - 1); // 调用子问题，继续在1/4子块计算坐标
}
// 本题直接生成方阵再查询会【超出内存限制】，因此直接推理是最好的方法
int main() {
    int m, n;
    while (scanf("%d%d", &n, &m) != EOF) {
        if (!n && !m) break;
        hang = lie = 1;//从（1，1）开始
        f(m, n);
        printf("%d %d\n", hang, lie);
    }
    return 0;
}

注意：>>指二进制小数点向左移动，而<<表明小数点向右移动，即

int l = 1 << (n - 1); 
//表示l=1*2^(n-1)，应该和l=(int)pow(2,n-1)差不多
//但是<<这样的写法简洁很多

（可以记成<<是往前面那个数里面“加”了很多位，而>>是“往外拿”）

    int l = 1 << (n - 1); // 计算1/4子块的边长
    int s = l * l;
    switch (m / s)
    {
    case 0: hang += 0; lie += 0; break;//用switch记得break！虽说我也不知道为啥一定要用switch不用if
    case 1: hang += 0; lie += l; break;
    case 2: hang += l; lie += 0; break;
    case 3: hang += l; lie += l; break;
    }
    f(m % s, n - 1); // 调用子问题，继续在1/4子块计算坐标

这一块就是精髓了！

1. 初始条件是：我们知道m在边长为2^n的大方阵里面
2. l代表的是大方阵的次级组成单位的边长，为2^(n-1)
3. 我现在不想知道m的确切位置，只想知道它在哪个次级单位中，所以坐标要么不加，要么加l
4. 那么，怎么知道m在哪个次级单位中呢？只需要看它除以l平方（即s）的商就行了，如果商为1，那么就说明s<=m<s×2，即s<m+1<=s×2（m+1表示m是第几个数，因为第一位是0）
5. 从（1,1）开始，每次坐标都会到达一个次级单位的左上角，然后再把这个次级单位当做是大方阵开始下一步，所以m%=s, n–
6. 当只剩4个数，即边长为2的时候，就退出递归，得到最终的坐标

其他

此外，排列数阵还有一个很烦的点在于，（针对我原来的理解）如果m被边长l整除，那么m/l会比它之前的那个数大，同时，m%l=0，这就需要一定的调整——简单来说，就是需要向上取整

有以下几种办法

//比较朴实的做法，但很有效
if (m % l == 0)hang = m / l + 1;
else hang = m / l;
//使用ceil()函数
ceil(x)返回的是大于x的最小整数。如：
ceil(2.5) = 3
ceil(-2.5) = -2
floor()是向负无穷大舍入，floor(-2.5) = -3
ceil()是向正无穷大舍入，ceil(-2.5) = -2

但需要注意的是ceil函数的参数和返回值都得是double类型的，所以其实朴实一点的做法也没什么不好的，起码都还是int不用强行改。