c++--暴力破解骑士周游

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <cmath>
#include <algorithm>
using namespace std;
int timess[1000];//储存骑士每个周期的行走的次数
int time1 = 0;//计算有多少个周期
int times = 0;//骑士每个周期的行走的次数
void check(int [8][8],const int[],const int[],int&,int&);
void moves(int [8][8],int [],int [],int,int&,int&);
int main()
{
    srand(time(0));
    int board[8][8] = {0};//定义一个棋盘
    const int horizontal[8] = {2,1,-1,-2,-2,-1,1,2};//定义棋子移动的类型
    const int vertical[8] = {-1,-2,-2,-1,1,2,2,1};
    int currentRow =rand()%8;//当前棋子的横坐标
    int currentColumn =rand()%8;//当前棋子的纵坐标
    int counter = 0;;//记录骑士在每一方格中移动的最近的计数
    board[currentRow][currentColumn] =1;
    for(int m=0; m<10000; m++)
    {
        for(int n=0; n<10000000; n++)
        {
            check(board,horizontal,vertical,currentRow,currentColumn);
        }
        for(int i=0; i<8; i++)
        {
            for(int j=0; j<8; j++)
            {
                cout<<board[i][j]<<" ";
            }
            cout<<endl;
        }
        cout<<endl<<endl;
        for(int p=0; p<8; p++)
        {
            for(int q=0; q<8; q++)
            {
                board[p][q]=0;
            }
        }
        currentRow =rand()%8;
        currentColumn =rand()%8;


        board[currentRow][currentColumn] =1;
        times = 0;
        time1++;
    }
    cout<<endl<<endl;
    sort(timess,timess+1000);
    cout<<timess[999];
    return 0;
}
void check(int board[8][8],const int horizontal[],const int vertical[],int&currentRow,int&currentColumn)
{
    int currentrow;
    int currentcolumn;
    int usefulrow[8]= {0}; //有效的移动类型行数
    int usefulcolumn[8]= {0}; //有效的移动类型列数
    int rcsize =0;//有效的移动类型数组的大小
    bool flag;//用于判断是否为有效的移动类型
    //此循环用于判断移动的类型
    for(int i=0; i<8; i++)
    {
        flag = true;
        //***********************
        if(horizontal[i]<0)//判断移动的方向
        {
            currentcolumn = -1;
        }
        else
        {
            currentcolumn = 1;
        }
        if(vertical[i]<0)
        {
            currentrow = -1;
        }
        else
        {
            currentrow = 1;
        }
        //***************************************************************
        //此while循环用于判断每移动一列是否已经走过
        if((currentColumn+horizontal[i]<0)||(currentColumn+horizontal[i]>7))//用于判断是否超过边界
        {
            flag = false;
            continue;
        }
        while(fabs(currentcolumn)!=(fabs(horizontal[i])+1))
        {
            if(board[currentRow][currentColumn+currentcolumn]!=0)
            {


                flag = false;
                break;
            }
            if(horizontal[i]<0)
            {
                currentcolumn--;
            }
            else
            {
                currentcolumn++;
            }
        }
        if(horizontal[i]<0)
        {
            currentcolumn++;
        }
        else
        {
            currentcolumn--;
        }
        //*****************************************************************
        //此while循环用于判断每移动一行是否已经走过
        if(!flag)
        {
            continue;
        }
        while(fabs(currentrow)!=(fabs(vertical[i])+1))
        {


            if((currentRow+vertical[i]<0)||(currentRow+vertical[i]>7))
            {


                flag = false;
                break;
            }
            if(board[currentRow+currentrow][currentColumn]!=0)
            {
                flag = false;
            }
            if(vertical[i]<0)
            {
                currentrow--;
            }
            else
            {
                currentrow++;
            }


        }
        if(vertical[i]<0)
        {
            currentrow++;
        }
        else if(vertical[i]>0)
        {
            currentrow--;
        }
        //**************************************************
        //用于记录每个有效的移动的类型并用usefulrow，usefulcolumn分别记录
        if(flag)
        {
            usefulrow[rcsize] = vertical[i];
            usefulcolumn[rcsize] = horizontal[i];
            rcsize++;
        }
    }
    //************************************************************
    if(rcsize!=0)
    {
        moves(board,usefulrow,usefulcolumn,rcsize,currentRow,currentColumn);
    }
    else
    {
        return;
    }
}
void moves(int board[8][8],int usefulrow[],int usefulcolumn[],int rcsize,int&currentRow,int&currentColumn)
{
    times++;
    timess[time1] = times;
    srand(time(0));
    int nums = rand()%rcsize;//随机获取一种有效的移动类型
    int row = usefulrow[nums];//获取到移动的行数
    int column = usefulcolumn[nums];//获取到的移动的列数
    int counterrow;
    int countercolumn;
    if(row>0)
    {
        counterrow = 1;
    }
    else
    {
        counterrow = -1;
    }
    if(column>0)
    {
        countercolumn = 1;
    }
    else
    {
        countercolumn = -1;
    }
    while(fabs(countercolumn)!=(fabs(column)+1))
    {
        board[currentRow][currentColumn+countercolumn] = 1;
        if(column>0)
        {
            countercolumn++;
        }
        else
        {
            countercolumn--;
        }


    }
    currentColumn+=column;//修改骑士的当前所在列数
    while(fabs(counterrow)!=(fabs(row)+1))
    {
        board[currentRow+counterrow][currentColumn] = 1;
        if(row>0)
        {
            counterrow++;
        }
        else
        {
            counterrow--;
        }
    }
    currentRow+=row;//修改骑士当前所在的行数
}