3*3的方格里有1-8八个数字和一个空格，通过移动可以使其按时针排序。这种游戏的vb代码应怎么写

Posted 2023-04-23

移动数字排序
1．算法说明
在3*3的9个方格中，空出中间的格，其余八个格上任意填入数字1到8（注意：每个数字仅能填入一个点，不能重复）；1的位置固定不动，然后移动其余的数字，直至数字1到8按照顺时针从小到大排好序为止。
移动的规则是：只能将数字沿线移向空白的点。
3．功能要求
启动程序后，在“输入原始数字”下方的各文本框中任意输入数字1到8（空出中间的点）。单击“确定”按钮，开始按照自行设计的算法自动移动数字（注意：数字1的位置固定不动），直至按照要求排好序停止。
（1）在“数字移动过程”下方的列表框中显示每次移动后数字的排列情况，其中0表示空位（注意：只能将数字沿线移向空白的点）。
（2）移动完成后的结果显示在“移动后的结果”下方的个文本框中。
（3）移动次数显示在“移动次数”文本框中。

参考技术A #include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>
#include<iostream>
#include<iomanip>
#include<ctime>//调用时间种子
using namespace std;

#define M 1000 //数值范围
#define N 20 //待排序记录的个数

int R[N+1];
int i,j;
/*
typedef struct

int key; //关键字
AnyType other; //记录的其他数据域
RecType;
RecType R[N+1]; //R[0]不存放记录，留作它用
*/
/********* 输出函数***********/
void display()

for(i=1;i<=N;i++)

printf("%6d",R[i]);
if(0==i%10)
cout<<endl;

cout<<endl;

/*****************************************************/
//①------------直接插入排序--------------------
void StrInsSort(int R[],int n)

//本算法利用监视哨对R[]进行直接插入排序
int i,j;
for (i=2;i<=n;i++)//假定第一个有序

R[0]=R[i];//将待排序元素放进监视哨
j=i-1;//从后向前查找插入位置，同时后移以已记录数据
while (R[0]<R[j])

R[j+1]=R[j];//记录后移
j--;

R[j+1]=R[0];//将待排序插入合适位置


/*****************************************************///②------------折半查找排序--------------------
void BinSort(int R[],int n)

int i,j,low,high,m;
for (i=2;i<=n;i++) //假定第一个记录有序

R[0]=R[i]; //将待记录项暂存到R[0]中
low=1;high=i-1; //设置折半查找的位置
//在R[low,high]中折半查找
while (low<=high)

m=(low+high)/2; //折半
if(R[0]<R[m])
high=m-1; //插入点在低半区
else
low=m+1; //插入点在高半区

for(j=i-1;j>=high+1;j--)//记录后移
R[j+1]=R[j];
R[high+1]=R[0];//插入


/*****************************************************/
//③-------------希尔排序--------------------------
void ShellSort(int R[], int n)

int i,j,d;
//以步长Di/2分组的希尔排序，第一个步长取n/2，最后取
for (d=n/2;d>=1;d=d/2)
for (i=1+d;i<=n;i++) //将R[i]插入到合适的位置去

R[0]=R[i];
j=i-d;
while (j>0 && R[0]<R[j])

R[j+d]=R[j];
j=j-d;

R[j+d]=R[0]; //将第i个元素插在合适位置

// end of ShellSort
/*****************************************************/
//④----------冒泡排序------------------
void BubbleSort(int R[],int n)

int i,j,lastexchange;
//i指示无序序列最后一个记录的位置
for(i=1;i<n;i++)

lastexchange=1;
for (j=1;j<=n-i;j++)
if (R[j]>R[j+1])

R[0]=R[j];
R[j]=R[j+1];
R[j+1]=R[0];
lastexchange=0;

if(lastexchange)
break;


/*****************************************************/
//⑤--------------选择排序------------------
void SelectSort(int R[],int n)

int i,j,k;
for (i=1;i<n;i++)//选择第i小的数，并交换到位

k=i;//假定第i个因素最小
for(j=i+1;j<n;j++)
if (R[j]<R[k])
k=j;
if (i!=k)//交换

R[0]=R[i];
R[i]=R[k];
R[k]=R[0];



/*****************************************************/
//--------堆的调整技术(筛选)----------
void Shift(int R[],int i,int m)

// 已知R[i..m]中记录的关键字除R[i] 之外均满足堆的特征，
// 本函数自上而下调整R[i],使R[i..m] 也成为一个大顶堆
int j;
R[0]=R[i]; // 暂存“根”记录R[s]
for (j=i*2;j<=m;j*=2)

if(j<m&&R[j]<R[j+1])// 左/右“子树根”之间先进行相互比较
j++; // j 为关键字较大孩子记录的位置
if(R[0]<R[j])
// 再做“根”和“子树根”之间的比较
R[i]=R[j]; // 双亲小,将R[j]调整到其双亲位置i
i=j; // 尚需继续往下调整,指针后移
// j最终指向需与堆顶交换的结点的位置
else break; // 否则说明已找到堆顶记录R[0]的插入位置i,退出for循环

R[i]=R[0]; // 将调整前的堆顶记录放入正确位置i


//⑥------------堆排序---------------------
void HeapSort(int R[],int n)
//对记录R[1..n] 进行堆排序
int i;
for (i=n/2;i>0;i--) //把R[1..n]初始建成大顶堆
Shift(R,i,n);
for (i=n;i>1;i--)

R[0]=R[1]; //将堆顶记录和当前未经排序子序列
R[1]=R[i]; //R[1..i]中最后一个记录相互交换
R[i]=R[0];
Shift(R,1,i-1); //对R[1..i-1]进行筛选重新调整为大顶堆


/*****************************************************/
//------将两个有序子序列归并成一个较大的有序序列-------
void Merge(int R[],int R1[],int l,int m,int h)

//将有序序列R[l..m]R[m+1..h]归并成有序序列R[l..h]

int i,j,k,t;
for (i=l,j=m+1,k=l; i<=m && j<=h; k++)
//l为R[i..m]的位序,j为R[m+1..h]位序,k为R1[i..h]的位序
//将R中的记录从小到大并入R1
if(R[i]<=R[j])
R1[k]=R[i++];
else R1[k]=R[j++];

if(i<=m)
for(t=k;t<=h;t++)//将剩余的R[i..m]并入R1
R1[t]=R[i++];
if(j<=h)
for(t=k;t<=h;t++)//将剩余的R[j..h]并入R1
R1[t]=R[j++];

for(t=l;t<=h;t++) //R[l..h]=R1[l..h]
R[t]=R1[t];

//⑦--------------二路归并排序----------------
void MSort(int R[],int R1[],int s,int t)
//将R[s..t]进行二路归并排序为R[s..t]
int m;
if(s<t)


m=(s+t)/2;//将R[s..t]平均分为R[s..m]和R[m+1..t]两段
MSort(R,R1,s,m); //递归归并排序R[s..m]
MSort(R,R1,m+1,t);//递归归并排序R[m+1..t]
Merge(R,R1,s,m,t);

// return;

void MergeSort(int R[],int n)

MSort(R,R,1,n);

/*****************************************************/
//⑧----------递归选择排序------------------
void RecursiveSelectSort(int R[],int n)
int j,t,max,maxi;
if(n!=1)
max=R[1];maxi=1;
for(j=2;j<=n;j++)
if (R[j]>max) max=R[j];maxi=j;
// if (maxi!=n) t=R[n];R[n]=R[maxi];R[maxi]=t;
if (maxi!=n) R[maxi]=R[n];R[n]=max;
RecursiveSelectSort(R,n-1);
// cout<<"!! k="<<k<<" !!"<<endl;


/*****************************************************/
//⑨----------递归冒泡排序------------------
void RecursiveBubbleSort(int R[],int n)
int j,t;
if(n!=1)
for(j=1;j<n;j++)
if (R[j]>R[j+1]) t=R[j];R[j]=R[j+1];R[j+1]=t;
RecursiveBubbleSort(R,n-1);
// cout<<"!! k="<<k<<" !!"<<endl;


/*****************************************************/
//⑩-------------递归直接插入排序-------------------
void RecursiveInsSort(int R[],int n)
int j,t;
if(n!=1)
RecursiveInsSort(R,n-1);
t=R[n];
for(j=n-1;j>=1;j--)
if (t<R[j]) R[j+1]=R[j];
else break;
R[j+1]=t;
// cout<<"!! k="<<k<<" !!"<<endl;


/*****************************************************/
//--------------- 一次划分---------------
int Partition(int R[],int l,int h)

//交换记录子序列R[l...h]的记录，使枢轴记录到位，并返回其位置
//此时，在他之前的记录均不大于他
int i=l,j=h,x;//记录待排序的记录的首尾位置
R[0]=R[i];//以字表的第一个记录为枢轴，将其暂时存在R[0]中
x=R[i];
while (i<j)

//从表两端交替的向中间扫描
while (i<j && R[j]>=x)
j--;
R[i]=R[j];//将比枢轴小的移到低端
while(i<j && R[i]<=x)
i++;
R[j]=R[i];//将比枢轴大的移到高端

R[i]=R[0];
return i;//返回枢轴位置

//(11)-------------快速排序-------------------
void QuickSort(int R[],int s,int t)

//对记录序列R[s...t]进行快速排序
int k;
if(s<t)

k=Partition(R,s,t);
QuickSort(R,s,k-1);
QuickSort(R,k+1,t);



/***************** 主函数******************/
int main()

int select;
srand((unsigned)time(NULL)); //使用时间种子，让每次产生的随机数不相同
for(i=1;i<=N;i++)
R[i]=(rand()%M); //产生一组随机数

cout<<"【1】直接插入排序"<<endl;
cout<<"【2】折半查找排序"<<endl;
cout<<"【3】希尔排序"<<endl;
cout<<"【4】冒泡排序"<<endl;
cout<<"【5】选择排序"<<endl;
cout<<"【6】堆排序"<<endl;
cout<<"【7】二路归并排序"<<endl;
cout<<"【8】递归选择排序"<<endl;
cout<<"【9】快速冒泡排序"<<endl;
cout<<"【10】递归直接插入排序"<<endl;
cout<<"【11】快速排序"<<endl;
cout<<"================================"<<endl;
//cout<<"请选择：";
//cin>>select;
cout<<endl;
for(select=1;select<=8;select++)

switch(select)

case 1:
StrInsSort(R,N);
cout<<"【1】直接插入排序："<<endl;
display();
break;
case 2:
BinSort(R,N);
cout<<"【2】折半查找排序："<<endl;
display();
break;
case 3:
ShellSort(R,N);
cout<<"【3】希尔排序："<<endl;
display();
break;
case 4:
BubbleSort(R,N);
cout<<"【4】冒泡排序："<<endl;
display();
break;
case 5:
SelectSort(R,N);
cout<<"【5】选择排序："<<endl;
display();
break;
case 6:
HeapSort(R,N);
cout<<"【6】堆排序："<<endl;
display();
break;
case 7:
MergeSort(R,N);
cout<<"【7】二路归并排序："<<endl;
display();
break;
case 8:
RecursiveSelectSort(R,N);
cout<<"【8】递归选择排序："<<endl;
display();
case 9:
RecursiveBubbleSort(R,N);
cout<<"【9】快速冒泡排序："<<endl;
display();
case 10:
RecursiveInsSort(R,N);
cout<<"【10】递归直接插入排序："<<endl;
display();
case 11:
QuickSort(R,1,N);
cout<<"【11】快速排序："<<endl;
display();


return 0;
本回答被提问者和网友采纳 参考技术B 25

1605 迷宫

难度：普及-

题目类型：深搜

提交次数：1

涉及知识：深搜

题目背景

迷宫 【问题描述】

给定一个N*M方格的迷宫，迷宫里有T处障碍，障碍处不可通过。给定起点坐标和

终点坐标，问: 每个方格最多经过1次，有多少种从起点坐标到终点坐标的方案。在迷宫

中移动有上下左右四种方式，每次只能移动一个方格。数据保证起点上没有障碍。

输入样例 输出样例

【数据规模】

1≤N,M≤5

题目描述

输入输出格式

输入格式：

【输入】

第一行N、M和T，N为行，M为列，T为障碍总数。第二行起点坐标SX,SY，终点

坐标FX,FY。接下来T行，每行为障碍点的坐标。

 

输出格式： 

【输出】

给定起点坐标和终点坐标，问每个方格最多经过1次，从起点坐标到终点坐标的方

案总数。

代码：

 1 #include<iostream>
 2 using namespace std;
 3 int a[6][6];
 4 bool visited[6][6];
 5 int dir[2][4] = {{-1, 1, 0, 0}, {0, 0, 1, -1}};
 6 int sx, sy, fx, fy;
 7 int n, m, t;
 8 int ans;
 9 void dfs(int x, int y){
10     if(x == fx&&y == fy)
11         ans++;
12     else if(x<=0||x>n||y<=0||y>m) return;
13     else{
14         for(int i = 0; i < 4; i++){
15             if(!visited[x+dir[0][i]][y+dir[1][i]]&&a[x+dir[0][i]][y+dir[1][i]]!=1){
16                 visited[x+dir[0][i]][y+dir[1][i]]=true;
17                 dfs(x+dir[0][i], y+dir[1][i]);
18                 visited[x+dir[0][i]][y+dir[1][i]]=false;
19             }
20         }
21     }
22 }
23 int main(){
24     cin>>n>>m>>t;
25     cin>>sx>>sy>>fx>>fy;
26     int i;
27     for(i = 0; i < t; i++){
28         int x, y;
29         cin>>x>>y;
30         a[x][y]=1;
31     }
32     visited[sx][sy]=true;
33     dfs(sx, sy);
34     cout<<ans;
35     return 0;
36 } 

备注：

DFS水题。真感人，应该算是独立写DFS最顺利的一次了，必须得记录一下。唯一一个要注意的问题就是坐标都是从1开始的。