九宫格程序代码 共享并希望大家多提意见

九宫格程序代码 共享并希望大家多提意见

以下是该程序的题目要求，如下：编程题：Android手机9宫格有多少种可能的手势？如果是16宫格呢？ 规则：4个点或以上的手势才算；一个手势中，每个点最多只能被算作经过一次；只有已经经过的点才能直接越过，也就是说，如果你想连接的两个点中间还有其他点，那这些点必须是已经被之前经过的。

解题思路：1、本题从数学角度也可以解出来，但是比较复杂。若程序实现，可以从遍历树结构或者动态规划的角度实现，但是在保存现场中可以用到栈或者队列。2、本人从三个模块入手，第一个模块是初始化模块，用于初始化初始的连接矩阵，构造一个可连接矩阵，1表示可连接，0表示不可连接。第二个模块用于计算新的连接矩阵，根据之前遍历过得节点修改连接矩阵。第三个模块用于递归遍历树。

程序代码如下：

代码块

include “stdio.h”

define FALSE 0

define TRUE 1

//commonset
int mode;//0 equal to 9GongGe,1 equal to 16Gongge
int level = 0;
int layer = 4;
long int count=0;
int stat[9]={FALSE};
int C_List[9]={0};
int StarterDirection[9][9]=
    {
   //1,2,3,4,5,6,7,8,9 node
    {0,1,0,1,1,1,0,1,0},
    {1,0,1,1,1,1,1,0,1},
    {0,1,0,1,1,1,0,1,0},
    {1,1,1,0,1,0,1,1,1},
    {1,1,1,1,0,1,1,1,1},
    {1,1,1,0,1,0,1,1,1},
    {0,1,0,1,1,1,0,1,0},
    {1,0,1,1,1,1,1,0,1},
    {0,1,0,1,1,1,0,1,0},
    };
int direction[9][9]=
    {
   //1,2,3,4,5,6,7,8,9 node
    {0,1,0,1,1,1,0,1,0},
    {1,0,1,1,1,1,1,0,1},
    {0,1,0,1,1,1,0,1,0},
    {1,1,1,0,1,0,1,1,1},
    {1,1,1,1,0,1,1,1,1},
    {1,1,1,0,1,0,1,1,1},
    {0,1,0,1,1,1,0,1,0},
    {1,0,1,1,1,1,1,0,1},
    {0,1,0,1,1,1,0,1,0},
    };


//
int CaculateRouter(int stat[9])
{
    //caculate the node direction
    int i,j;
    for(i=0;i<9;i++)
    {
        for(j=0;j<9&&direction[i][j]==0;j++)
        {
            if((i+j)/2.0-int((i+j)/2.0) == 0.0 && stat[(i+j)/2]==TRUE&&i!=j)//
                direction[i][j]=1;
        }
    }
    for(i=0;i<9;i++)
    {
        if(stat[i]==TRUE)//fix the matrix of CanGet,cut the havelinked node
            for(j=0;j<9;j++)
                direction[j][i]=0;
    }

    return 1;
}
int Build(int node,int level)//level start from 0
{
    if(level== layer-1)
    {   
        count++;
        //printf("Find One!----%ld\n",count);
        return 1;
    }
        for(int k=0;k<9;k++)
        {   
            if(direction[node][k]==1)
            {
                int i,j;
                //临时存储现场
                int temp1[9][9];
                int stat1[9];
                for(i=0;i<9;i++)
                    stat1[i]=stat[i];
                for(i=0;i<9;i++)
                    for(j=0;j<9;j++)
                        temp1[i][j]=direction[i][j];    
                stat[node]=TRUE;
                level ++;
                //以上为保存现场

                CaculateRouter(stat);
                Build(k,level);


                //恢复现场
                stat[node]=FALSE;
                level--;
                node++;
                for(i=0;i<9;i++)
                    for(j=0;j<9;j++)
                        direction[i][j]=temp1[i][j];
                for(i=0;i<9;i++)
                    stat[i]=stat1[i];
            }
        }

}
        /*
    if (level == layer)
    {   
        count++;
        level--;
        printf("\n Find One!!!\n");
        int i,j;
        for(i=0;i<9;i++)
            for(j=0;j<9;j++)
                directionPoint[i][j]=direction[i][j];
        return 1;
    }

    while(node<9)
    {   
        if(stat[node]==TRUE)
            return 0;
        int j=0;
        stat[node]=TRUE;
        printf("%d-->",node);
        while(j<9 )
        {
            if(directionPoint[node][j] == 1)
            {   
                CaculateRouter(stat,directionPoint);
                level++;
                DFS9GongGe(stat,j,level,directionPoint);
            }
            j++;
        }
        stat[node]=FALSE;
        node++;
        return 1;
    }
    return 1;
    */



int main()
{
    int Pointdirection[9][9]=
    {
   //1,2,3,4,5,6,7,8,9 node
    {0,1,0,1,1,1,0,1,0},
    {1,0,1,1,1,1,1,0,1},
    {0,1,0,1,1,1,0,1,0},
    {1,1,1,0,1,0,1,1,1},
    {1,1,1,1,0,1,1,1,1},
    {1,1,1,0,1,0,1,1,1},
    {0,1,0,1,1,1,0,1,0},
    {1,0,1,1,1,1,1,0,1},
    {0,1,0,1,1,1,0,1,0},
    };

    int num=4;
    while(num<=9)
    {
        layer =num;
        num++;
        Build(0,0);
    }
    printf("Total = %ld",count);
}

脚注

对代码几点解释：
1、代码有部分冗余，但是完全可以运行
2、矩阵为连接矩阵，每次递归需要修改
3、通过全局变量实现对程序的控制。
4、程序结果可以妙出，但是对于16个点的四乘四矩阵运算时间较长，下次发文会对4X4矩阵的算法。
5、通过该程序对递归程序的有了一定了解，在编译器阶段，将程序不是debug版本，直接出exe可执行文件。利用IDA反编译程序，发现程序在编译阶段进行了一定的优化。下一步准备改造程序，利用栈和队列构造生成树，不采用递归算法。

程序生成结果