典型的递归算法

原题：一个完整的纸板有N*N个小纸板组成N×N (N = 2^K; 1 ≤ K ≤ 7; K =自然数)，纸板上一共有2种颜色，1----蓝色，0----白色

如下图所示：

 

需要按照如下的规则进行切割：

1.  如果一张完整的纸板的颜色完全相同了，就不用再进行切割，如果颜色一致：全是蓝色纸板的颜色，蓝色纸板总数加1，如果是白色的话，白色纸板的总数加1

2.  如果不是同一个颜色，则要按照中心对称的原则进行切割，切割后形成4个(N/2)×(N/2)的小纸板

如上图第一次切割后的图片如下：

求解，一个完整的纸片一共有多少个蓝色的纸片和多少白色的纸片。

例如本题：

输入矩阵的介数和矩阵的颜色，1----蓝色，0----白色：

8                    //8代表是8*8介的矩阵

1 1 0 0 0 0 1 1
1 1 0 0 0 0 1 1
0 0 0 0 1 1 0 0
0 0 0 0 1 1 0 0
1 0 0 0 1 1 1 1
0 1 0 0 1 1 1 1 
0 0 1 1 1 1 1 1
0 0 1 1 1 1 1 1

输出：

白色的纸片总数和蓝色的纸片总数

分析详见代码注释部分：

代码部分：

#include <iostream>

#define WHITE 0
#define BLUE 1

using namespace std;

void CuttingPaper(int, int, int);

int whiteNum;
int blueNum;
int array[128][128]={{0,0},};

int main(int argc, char** argv)
{

        whiteNum = 0;
        blueNum = 0;
        
        int N;
        int i = 0, j = 0;        
        cin >> N;
        for( i = 0; i < N; i++)
        {
            for(j = 0; j < N; j++)
            {
                cin >> array[i][j];
            }
        }
        
        CuttingPaper(N, 0, 0);   //第一次，纸板的边长为N,起点坐标为（0,0）    
        cout << whiteNum << " "<< blueNum << endl;
    
    return 0;
}

void CuttingPaper(int n, int X, int Y)
{
    if(n == 1)    //当边长为1时，无法进行递归调用了，统计最后的纸板颜色
    {
        if( WHITE == array[X][Y])
        {
            ++whiteNum;
        }
        else
        {
            ++blueNum;
        }                    
        return;
    }
    else     //如果边上不是1，就是还有继续继续切割的可能性
    {
        int i, j;
        bool flag = false;    //flag 为标记，是否为同一个颜色，同时还可以用该标记打断外层循环
        for( i = X; i < X+n; i++)
        {
            for( j = Y; j < Y+n; j++)
            {
                int tmpColor = array[X][Y];        //取出每个矩阵的顶点坐标，并记下颜色，此时不管白色和蓝色
                if(tmpColor == array[i][j])     //遍历整个N*N的矩阵，如果颜色和顶点的颜色一致就继续
                {
                    flag = true;
                }
                else     //如果颜色和顶点颜色不一致就打断循环，无需往下遍历，还要继续切割
                {
                    flag = false;
                    break;
                }                
            }
            if(flag == false)   //此处flag还打断了外层循环
            {
                break;
            }
        }
        if(flag)    //如果是同一个颜色，则判断到底是蓝色的还是白色的
        {
            if(array[X][Y] == WHITE)
            {
                ++whiteNum;
            }
            else
            {
                ++blueNum;
            }
            return;
        }
        else    //如果不是一个颜色的，则进行切割，而且算出切割后的边长为N/2,以及4个小纸板的顶点坐标，再进行递归
        {
            CuttingPaper( n/2,  X,  Y);
            CuttingPaper( n/2,  X+n/2,  Y);
            CuttingPaper( n/2,  X,  Y+n/2);
            CuttingPaper( n/2,  X+n/2,  Y+n/2);
        }
    }
}