在图像编码的算法中，需要将一个给定的方形矩阵进行Z字形扫描(Zigzag Scan)。给定一个n×n的矩阵，Z字形扫描的过程如下图所示：

　　对于下面的4×4的矩阵，
　　1 5 3 9
　　3 7 5 6
　　9 4 6 4
　　7 3 1 3
　　对其进行Z字形扫描后得到长度为16的序列：
　　1 5 3 9 7 3 9 5 4 7 3 6 6 4 1 3
　　请实现一个Z字形扫描的程序，给定一个n×n的矩阵，输出对这个矩阵进行Z字形扫描的结果。

　　输入的第一行包含一个整数n，表示矩阵的大小。
　　输入的第二行到第n+1行每行包含n个正整数，由空格分隔，表示给定的矩阵。

　　输出一行，包含n×n个整数，由空格分隔，表示输入的矩阵经过Z字形扫描后的结果。

　　1≤n≤500，矩阵元素为不超过1000的正整数。

题目的分析解答：

     这里提供两种解题思路，一种是纯找规律来进行实现的，还有一种是基于Z字形扫描的较常规处理办法，下面我们来详细介绍一下这两种解法。

其一：对矩阵的元素进行分析，发现扫描的路径大致是这样的:

0:  a[0][0]

1:  a[0][1]->a[1][0]

2:  a[2][0]->a[1][1]->a[0][2]

3:  a[0][3]->a[1][2]->a[2][1]->a[3][0]

4:  a[3][1]->a[2][2]->a[1][3]

5:  a[2][3]->a[3][2]

6:  a[3][3]

显然发现整个扫描过程是从0扫到2*（n-1）的，而且矩阵的两个下标之和等于扫描的顺序i，所以每一次只需要判断矩阵的扫描是从某一行开始还是从某一列开始，经过观察发现当扫面过程处于偶数时是在列开始的，因此整个过程就很好确定了。源代码如下所示：

#include<iostream>
#include<vector>
using namespace std;

int main()
{ int n;
cin>>n;
int a[500][500]={0};
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
cin>>a[i][j];
}
}
for(int i=0;i<=(2*(n-1));i++)
{
for(int k=0;k<n;k++ )
{
for(int j=0;j<n;j++)
{
if(k+j==i)
{
if(i%2==0)
{
cout<<a[j][k]<<” “;
}else{

cout<<a[k][j]<<” “;
}
}
}
}
}

return 0;
}

其二：

分析这类题，首先要找出扫描的规律，从题目中可以发现，扫描是成Z字形的。那么也就是说对于扫描输出有四种状态，每次输出要判定下一次的行走路线，走一步就输出一个。

四种状态为{right,leftDown,down,rightUp}。

开始我还怀疑，Z字形扫描矩阵是否能够遍历矩阵所有的元素。下面我们来分析一下：

1、前提是这个矩阵是一个n维方阵，假设为A_nxn.

2、从输出当前的元素A[i][j]，并根据当前的状态来判断下一步的扫描状态。该如何判断呢？可以发现每次在执行完当前状态后，行号i或者列号j都有可能发生改变，那么就可以结合当前状态和行，列号的取值来判定下一步的行走路线。

从上图中我们可以发现：

right状态始终在首行或者尾行上执行，并且执行right状态后列号j会增加1，即j = j+1。所以我们可以根据当前状态的下一步状态有两种：

当i == 0时，state = leftDown;

当i == n-1时，state = rightUp。

执行完leftDown状态后，i = i+1,j = j-1，其下一步状态有三种：

当 j == 0 && i != n-1时，state = down;

当 row == n-1时，state = right;

其它情况，state = leftDown（自身状态）。

对于rightUp和down状态，其分析方法和上面两种类似，就不再做分析。

综合上面分析来看，状态每次要发生改变的话，行号或者列号必须处于临界状态，即它们的取值为{0,n-1}。

#include <iostream>

using namespace std;

int A[501][501];
enum  Choice
{
    rightTowards,//向移动
    rightUp,//向右上移动
    down,//向下移动
    leftDown//向左下移动
};

void zigzagScan(int n)
{
    for (int i = 0; i < n; ++i)
    for (int j = 0; j < n; ++j)
        cin >> A[i][j];
    int row = 0, col = 0;
    Choice choice = rightTowards;
    //row = n-1&&col = n-1的情况在while循环结束后处理，防止出现越界的情况
    while (row != n - 1 || col != n - 1)
    {
        cout << A[row][col] << \' \';
        switch (choice)
        {
        case rightTowards:
            col++;
            if (row == 0)
                choice = leftDown;
            else
                choice = rightUp;
            break;
        case rightUp:
            row--;
            col++;
            if (row == 0 && col != n - 1)
                choice = rightTowards;
            else if (col == n - 1)
                choice = down;
            else
                choice = rightUp;
            break;
        case down:
            row++;
            if (col == 0)
                choice = rightUp;
            else
                choice = leftDown;
            break;
        case leftDown:
            row++;
            col--;
            if (col == 0 && row != n - 1)
                choice = down;
            else if (row == n - 1)
                choice = rightTowards;
            else
                choice = leftDown;
            break;
        }
    }
    cout << A[n - 1][n - 1];
}

void main(void)
{
    int n;
    while (cin >> n)
    {
        zigzagScan(n);
    }
}