今天给各位分享八数码c语言的知识,其中也会对o八进制c语言进行解释,如果能碰巧解决你现在面临的问题,别忘了关注本站,现在开始吧!
本文目录一览:
1、八数码用盲目搜索或启发式搜索 C语言r如何 实现2、人工智能的八数码问题,过程化的c语言编程方法,求解,好的话要多少分给多少分!!!3、求8数码A或A*算法(用C语言)4、八数码问题用C语言编程,注意C语言!!!5、八数码问题 C语言 广度优先 其他也OK6、八数码问题·C语言写了个·输出可以·但为什么只输出一个过程·求高手解答·
八数码用盲目搜索或启发式搜索 C语言r如何 实现
相帮你,可是也是力不从心,还是上网上去查查吧。。。可能会有收获的。。
人工智能的八数码问题,过程化的c语言编程方法,求解,好的话要多少分给多少分!!!
#include stdio.h
#include stdlib.h
#define TIME 50 //限定只搜索前50步,50步以后如果仍然没有搜索到结果,认为无解。
#define MAXSIZE 200
int n=1;
int result[9]={1,2,3,8,0,4,7,6,5};//所要达到的最终状态,0代表空格。
typedef struct{
int num[9];
char expension; //记录是否可以扩展,Y代表可以扩展,N代表不可以。
char banOperate; //表示不可以执行的操作,’L’代表不能左移,’R’代表不能右移,
//’U’代表不能上移,’D’代表不能下移,’C’代表可以任意移动。
int father; //记录父节点的下标。
}Node;
Node store[MAXSIZE]; //将搜索过的状态存储于该数组中。
int same(int temp) //判断是否达到了目标状态。
{
for(int j=0;j9;j++)
if(store[temp].num[j]!=result[j])
return 0;
return 1;
}
void printResult() //输出搜索结果。
{
for(int j=1;j=n;j++)
{
printf(“第%d步搜索后:\n”,j);
printf(“\t%d\t%d\t%d\n”,store[j].num[0],store[j].num[1],store[j].num[2]);
printf(“\t%d\t%d\t%d\n”,store[j].num[3],store[j].num[4],store[j].num[5]);
printf(“\t%d\t%d\t%d\n”,store[j].num[6],store[j].num[7],store[j].num[8]);
printf(“\n\n”);
}
}
int left(int temp) //将空格进行左移操作。
{
for(int j=0;j9;j++) //判断空格的位置。
if(store[temp].num[j]==0)
break;
if(j==0||j==3||j==6)
return 0;
for(int k=0;k9;k++)
store[n].num[k]=store[temp].num[k];
int tempNum=store[n].num[j-1]; //将移动后的状态赋给store[n]
store[n].num[j-1]=0;
store[n].num[j]=tempNum;
store[temp].expension=’N’;
store[n].banOperate=’R’;
store[n].expension=’Y’;
store[n].father=temp;
if(same(n)) //判断store[n]是否为最终想得到的状态。
{
printResult();
exit(1);
}
n++;
return 1;
}
int right(int temp) //将空格进行右移操作。
{
for(int j=0;j9;j++)
if(store[temp].num[j]==0)
break;
if(j==2||j==5||j==8)
return 0;
for(int k=0;k9;k++)
store[n].num[k]=store[temp].num[k];
int tempNum=store[n].num[j+1];
store[n].num[j+1]=0;
store[n].num[j]=tempNum;
store[temp].expension=’N’;
store[n].banOperate=’L’;
store[n].expension=’Y’;
store[n].father=temp;
if(same(n))
{
printResult();
exit(1);
}
n++;
return 1;
}
int up(int temp) //将空格进行上移操作。
{
for(int j=0;j9;j++)
if(store[temp].num[j]==0)
break;
if(j==0||j==1||j==2)
return 0;
for(int k=0;k9;k++)
store[n].num[k]=store[temp].num[k];
int tempNum=store[n].num[j-3];
store[n].num[j-3]=0;
store[n].num[j]=tempNum;
store[temp].expension=’N’;
store[n].banOperate=’D’;
store[n].expension=’Y’;
store[n].father=temp;
if(same(n))
{
printResult();
exit(1);
}
n++;
return 1;
}
int down(int temp) //将空格进行下移操作。
{
for(int j=0;j9;j++)
if(store[temp].num[j]==0)
break;
if(j==6||j==7||j==8)
return 0;
for(int k=0;k9;k++)
store[n].num[k]=store[temp].num[k];
int tempNum=store[n].num[j+3];
store[n].num[j+3]=0;
store[n].num[j]=tempNum;
store[temp].expension=’N’;
store[n].banOperate=’U’;
store[n].expension=’Y’;
store[n].father=temp;
if(same(n))
{
printResult();
exit(1);
}
n++;
return 1;
}
void init()
{
Node start;
printf(“请输入初始状态,用空格分开,0代表空格:\n”);//输入初始的状态。
for(int i=0;i9;i++)
scanf(“%d”,start.num[i]);
for(int k=0;k9;k++)
if(start.num[k]==0)
break;
start.banOperate=’C’;
start.expension=’Y’;
start.father=-1;
store[0]=start; //将初始状态赋于store[0]。
}
void main(){
init();
if(same(0))
{
printf(“没有必要进行搜索,初始状态即为最终状态!”);
exit(1);
}
for(int i=0;iTIME;i++) //开始进行宽度搜索,限定搜索上限为50步。
{
if(store[i].expension=’Y’)
{
if(store[i].banOperate==’L’)
{
up(i);
right(i);
down(i);
}
if(store[i].banOperate==’R’)
{
left(i);
up(i);
down(i);
}
if(store[i].banOperate==’U’)
{
left(i);
right(i);
down(i);
}
if(store[i].banOperate==’D’)
{
left(i);
up(i);
right(i);
}
if(store[i].banOperate==’C’)
{
left(i);
up(i);
right(i);
down(i);
}
}
if(n=TIME) //50步以后仍然没有达到所要求的状态,认为无解。
{
n–;
printResult();
printf(“Sorry,在所在搜索范围内没有搜索到结果!”);
exit(1);
}
}
}
求8数码A或A*算法(用C语言)
题目地址:
BFS:
#include iostream
using namespace std;
int fac[10]={1,1};
bool tflag[9];
struct bbit{
unsigned int val:4;
};
struct bbbit
{
unsigned int val:2;
};
struct Node
{
bbit s[9],pos;
int step;
bbbit path[21],tag;
int hashval()
{
int ret=0,i,j,tmp;
memset(tflag,false,sizeof(tflag));
for(i=0;i8;i++)
{
tmp=0;
for(j=0;js[i].val;j++)
if(!tflag[j])
tmp++;
ret+=tmp*fac[8-i];
tflag[s[i].val]=true;
}
return ret;
}
bool up()
{
if(pos.val=2)return false;
s[pos.val].val^=s[pos.val-3].val;
s[pos.val-3].val^=s[pos.val].val;
s[pos.val].val^=s[pos.val-3].val;
path[step].val=0;
pos.val-=3;
return true;
}
bool down()
{
if(pos.val=6)return false;
s[pos.val].val^=s[pos.val+3].val;
s[pos.val+3].val^=s[pos.val].val;
s[pos.val].val^=s[pos.val+3].val;
path[step].val=1;
pos.val+=3;
return true;
}
bool left()
{
if(pos.val==0||pos.val==3||pos.val==6)return false;
s[pos.val].val^=s[pos.val-1].val;
s[pos.val-1].val^=s[pos.val].val;
s[pos.val].val^=s[pos.val-1].val;
path[step].val=2;
pos.val–;
return true;
}
bool right()
{
if(pos.val==2||pos.val==5||pos.val==8)return false;
s[pos.val].val^=s[pos.val+1].val;
s[pos.val+1].val^=s[pos.val].val;
s[pos.val].val^=s[pos.val+1].val;
path[step].val=3;
pos.val++;
return true;
}
bool operator==(const Nodex)const
{
int i;
for(i=0;i9;i++)if(s[i].val!=x.s[i].val)return false;
return true;
}
}Q[362880],S,A,tmp,top;
struct Hash
{
bool d1,d2;
Node D;
}hash[362880];
inline void mkfac(){int i;for(i=2;i=9;i++)fac[i]=fac[i-1]*i;}
inline int eval(char c){return c==’x’?0:c-‘0’;}
void o(Node x,Node y)
{
int i;
for(i=1;i=x.step;i++)
{
switch(x.path[i].val)
{
case 0:putchar(‘u’);break;
case 1:putchar(‘d’);break;
case 2:putchar(‘l’);break;
case 3:putchar(‘r’);break;
}
}
for(i=y.step;i=1;i–)
switch(y.path[i].val){
case 0:putchar(‘d’);break;
case 1:putchar(‘u’);break;
case 2:putchar(‘r’);break;
case 3:putchar(‘l’);break;
}
puts(“”);
}
int main()
{
char buf[11];
int i,t,l,r;
bool flag;
mkfac();
while(NULL!=gets(buf))
{
t=0;
for(i=0;i=7;i++)A.s[i].val=i+1;A.s[8].val=0;A.pos.val=8;
for(i=0;buf[i];i++)
{
if(buf[i]==’ ‘)continue;
S.s[t].val=eval(buf[i]);
if(S.s[t].val==0)
S.pos.val=t;
t++;
}
l=r=0;
flag=false;
for(i=0;i362880;i++)hash[i].d1=hash[i].d2=false;
S.step=0;S.tag.val=1;
A.step=0;A.tag.val=2;
Q[r++]=S;//tag.val:1
Q[r++]=A;//tag.val:2
while(l=r)
{
top=Q[l++];
top.step++;
tmp=top;
if(tmp.up())
{
if(tmp.tag.val==1)
{
if(!hash[t=tmp.hashval()].d1)
{
hash[t].d1=true;
Q[r++]=tmp;
if(hash[t].d2hash[t].D==tmp)
{
//find ans…
o(tmp,hash[t].D);
goto AA;
}
if(!hash[t].d2)hash[t].D=tmp;
}
}
else
{
if(!hash[t=tmp.hashval()].d2)
{
hash[t].d2=true;
Q[r++]=tmp;
if(hash[t].d1hash[t].D==tmp)
{
//find ans…
o(hash[t].D,tmp);
goto AA;
}
if(!hash[t].d1)hash[t].D=tmp;
}
}
}
tmp=top;
if(tmp.down())
{
if(tmp.tag.val==1)
{
if(!hash[t=tmp.hashval()].d1)
{
hash[t].d1=true;
Q[r++]=tmp;
if(hash[t].d2hash[t].D==tmp)
{
//find ans…
o(tmp,hash[t].D);
goto AA;
}
if(!hash[t].d2)hash[t].D=tmp;
}
}
else
{
if(!hash[t=tmp.hashval()].d2)
{
hash[t].d2=true;
Q[r++]=tmp;
if(hash[t].d1hash[t].D==tmp)
{
//find ans…
o(hash[t].D,tmp);
goto AA;
}
if(!hash[t].d1)hash[t].D=tmp;
}
}
}
tmp=top;
if(tmp.left())
{
if(tmp.tag.val==1)
{
if(!hash[t=tmp.hashval()].d1)
{
hash[t].d1=true;
Q[r++]=tmp;
if(hash[t].d2hash[t].D==tmp)
{
//find ans…
o(tmp,hash[t].D);
goto AA;
}
if(!hash[t].d2)hash[t].D=tmp;
}
}
else
{
if(!hash[t=tmp.hashval()].d2)
{
hash[t].d2=true;
Q[r++]=tmp;
if(hash[t].d1hash[t].D==tmp)
{
//find ans…
o(hash[t].D,tmp);
goto AA;
}
if(!hash[t].d1)hash[t].D=tmp;
}
}
}
tmp=top;
if(tmp.right())
{
if(tmp.tag.val==1)
{
if(!hash[t=tmp.hashval()].d1)
{
hash[t].d1=true;
Q[r++]=tmp;
if(hash[t].d2hash[t].D==tmp)
{
//find ans…
o(tmp,hash[t].D);
goto AA;
}
if(!hash[t].d2)hash[t].D=tmp;
}
}
else
{
if(!hash[t=tmp.hashval()].d2)
{
hash[t].d2=true;
Q[r++]=tmp;
if(hash[t].d1hash[t].D==tmp)
{
//find ans…
o(hash[t].D,tmp);
goto AA;
}
if(!hash[t].d1)hash[t].D=tmp;
}
}
}
}
AA:flag=true;
if(!flag)
puts(“unsolvable”);
}
return 0;
}
A*:
#include iostream
#include queue
using namespace std;
int fac[10]={1,1};
struct Node
{
int s[9],step,pos;
char path[501];
int hashval()
{
int ret=0,i,j,tmp;
bool flag[9];
memset(flag,false,sizeof(flag));
for(i=0;i8;i++)
{
tmp=0;
for(j=0;js[i];j++)
if(!flag[j])
tmp++;
ret+=tmp*fac[8-i];
flag[s[i]]=true;
}
return ret;
}
bool up()
{
if(pos=2)return false;
s[pos]^=s[pos-3];
s[pos-3]^=s[pos];
s[pos]^=s[pos-3];
path[step]=’u’;
pos-=3;
return true;
}
bool down()
{
if(pos=6)return false;
s[pos]^=s[pos+3];
s[pos+3]^=s[pos];
s[pos]^=s[pos+3];
path[step]=’d’;
pos+=3;
return true;
}
bool left()
{
if(pos==0||pos==3||pos==6)return false;
s[pos]^=s[pos-1];
s[pos-1]^=s[pos];
s[pos]^=s[pos-1];
path[step]=’l’;
pos–;
return true;
}
bool right()
{
if(pos==2||pos==5||pos==8)return false;
s[pos]^=s[pos+1];
s[pos+1]^=s[pos];
s[pos]^=s[pos+1];
path[step]=’r’;
pos++;
return true;
}
bool operator==(const Nodex)const
{
int i;
for(i=0;i9;i++)if(s[i]!=x.s[i])return false;
return true;
}
void show()
{
int i,j;
for(i=0;i=6;i+=3,coutendl)
for(j=i;j=i+2;j++)
couts[j];
}
bool operator(const Nodex)const
{
int la=0,lb=0,i;
for(i=0;i8;i++)if(s[i]!=i+1)la++;la+=(s[8]!=0);
for(i=0;i8;i++)if(x.s[i]!=i+1)lb++;lb+=(x.s[8]!=0);
return lalb;
}
}S,A,tmp,top;
priority_queueNode Q;
bool hash[362880];
void mkfac(){int i;for(i=2;i=9;i++)fac[i]=fac[i-1]*i;}
int eval(char c){return c==’x’?0:c-‘0’;}
void output(Node x)
{
int i;
for(i=1;i=x.step;i++)
putchar(x.path[i]);
puts(“”);
}
int main()
{
char buf[11];
int i,t,l,r;
bool flag;
mkfac();
while(NULL!=gets(buf))
{
t=0;
for(i=0;i=7;i++)A.s[i]=i+1;A.s[8]=0;A.pos=8;
for(i=0;buf[i];i++)
{
if(buf[i]==’ ‘)continue;
S.s[t]=eval(buf[i]);
if(S.s[t]==0)
S.pos=t;
t++;
}
l=r=0;
flag=false;
memset(hash,false,sizeof(hash));
S.step=0;
while(!Q.empty())Q.pop();
Q.push(S);
while(!Q.empty())
{
top=Q.top();
Q.pop();
top.step++;
tmp=top;
if(tmp.up())
{
if(!hash[t=tmp.hashval()])
{
hash[t]=true;
Q.push(tmp);
if(tmp==A)
{
//find ans…
output(tmp);
goto AA;
}
}
}
tmp=top;
if(tmp.down())
{
if(!hash[t=tmp.hashval()])
{
hash[t]=true;
Q.push(tmp);
if(tmp==A)
{
//find ans…
output(tmp);
goto AA;
}
}
}
tmp=top;
if(tmp.left())
{
if(!hash[t=tmp.hashval()])
{
hash[t]=true;
Q.push(tmp);
if(tmp==A)
{
//find ans…
output(tmp);
goto AA;
}
}
}
tmp=top;
if(tmp.right())
{
if(!hash[t=tmp.hashval()])
{
hash[t]=true;
Q.push(tmp);
if(tmp==A)
{
//find ans…
output(tmp);
goto AA;
}
}
}
}
AA:flag=true;
if(!flag)
puts(“unsolvable”);
}
return 0;
}
八数码问题用C语言编程,注意C语言!!!
基于51的程序:
#include reg52.h
sbit sda=P0^5;
sbit scl=P0^6;
code char led_code[19]={0x11,0xd7,0x32,0x92,0xd4, // 0,1,2,3,4
0x98,0x18,0xd3,0x10,0x90, // 5,6,7,8,9
0x50,0x1c,0x39,0x16,0x38, // a,b,c,d,e,
0x78,0xfe,0xef,0xff}; // f – dot dark
void seperate(unsigned char second,minute,hour); //1调用拆分函数
void display(unsigned char second,minute,hour); // 2调用显示函数 一定要在各处强调unsignde吗?
void shift(unsigned char); //3调用移位函数
void delay_1s(unsigned int x); //4调用延时函数
unsigned char second,minute,hour;
unsigned char second0,second1,
minute0,minute1,
hour0,hour1; // 这三行表示了时、分、秒所占数码管的个数和位置。 叫形参?
void main()
{
while(1)
{
for(hour=0;hour24;hour++) //三个for语句的安排妙啊! 我们看到的钟表时分秒的变化
!
{
for(minute=0;minute60;minute++)
{
for(second=0;second60;second++)
{
display(second,minute,hour);
delay_1s(65535);
}
}
}
}
}
void display(unsigned char second,minute,hour) //2对显示函数的说明
{
seperate(second,minute,hour);
shift(second0);
shift(second1);
shift(16);
shift(minute0);
shift(minute1);
shift(16);
shift(hour0);
shift(hour1);
}
void seperate(unsigned char second,minute,hour) //1对拆分函数的说明
{
second0=second%10;
second1=second/10;
minute0=minute%10;
minute1=minute/10;
hour0=hour%10;
hour1=hour/10;
}
void shift(unsigned char n) //3对移位函数的说明
{
unsigned char dat,minute;
dat=led_code[n];
scl=0;
for(minute=0;minute8;minute++)
{
if (dat0x80) sda=1;
else sda=0;
scl=1;
scl=0;
dat=1;
}
}
void delay_1s(unsigned int a) //4对延时函数的说明
{
while(a–);
}
八数码问题 C语言 广度优先 其他也OK
nclude “stdio.h”
typedef int datatype; /*假定线性表元素的类型为整型*/
#define maxsize 1024 /*假定线性表的最大长度为1024*/
# define n 100 /* 图的顶点最大个数 */
typedef char VEXTYPE; /* 顶点的数据类型 */
typedef float ADJTYPE; /* 权值类型 */
typedef struct
{ VEXTYPE vexs[n] ; /* 顶点信息数组 */
ADJTYPE arcs[n][n] ; /* 边权数组 */
int num ; /* 顶点的实际个数 */
}GRAPH;
/***********************1。置空图**********************/
void GraphInit(GRAPH *L)
{
L-num=0;
}
/***********************2。求结点数**********************/
int GraphVexs(GRAPH *L)
{
return(L-num);
}
/***********************3。创建图**********************/
void GraphCreate(GRAPH *L)
{
int i,j;
GraphInit(L);
printf(“请输入顶点数目:”);
scanf(“%d”,L-num);
printf(“请输入各顶点的信息(单个符号):”);
for(i=0;iL-num;i++)
{
fflush(stdin);
scanf(“%c”,L-vexs[i]);
}
printf(“请输入边权矩阵的信息:”);
for(i=0;iL-num;i++)
{
for(j=0;jL-num;j++)
{
scanf(“%f”,L-arcs[i][j]);
}
}
printf(“图已经创建完毕!”);
}
/***********************4。图的输出**********************/
void GraphOut(GRAPH L)
{
int i,j;
printf(“\n图的顶点数目为:%d”,L.num);
printf(“\n图的各顶点的信息为:\n”);
for(i=0;iL.num;i++)
printf(“%c “,L.vexs[i]);
printf(“\n图的边权矩阵的信息为:\n”);
for(i=0;iL.num;i++)
{
for(j=0;jL.num;j++)
{
printf(“%6.2f “,L.arcs[i][j]);
}
printf(“\n”);
}
printf(“图已经输出完毕!”);
}
/***********************5。图的深度周游**********************/
void DFS(GRAPH g,int qidian,int mark[])
//从第qidian个点出发深度优先周游图g中能访问的各个顶点
{
int v1;
mark[qidian]=1;
printf(“%c “,g.vexs[qidian]);
for(v1=0;v1g.num;v1++)
{
if(g.arcs[qidian][v1]!=0mark[v1]==0)
DFS(g,v1,mark);
}
}
/***********************6。图的深度周游**********************/
void GraphDFS(GRAPH g)
//深度优先周游图g中能访问的各个顶点
{
int qidian,v,v1,mark[maxsize];
printf(“\n深度周游:”);
printf(“\n请输入起点的下标:”);
scanf(“%d”,qidian);
for(v=0;vg.num;v++)
{
mark[v]=0;
}
for(v=qidian;vg.num+qidian;v++)
{
//printf(“v=%d “,v);
v1=v%g.num;
if(mark[v1]==0)
DFS(g,v1,mark);
}
}
typedef int DATATYPE; //队列元素的数据类型
typedef struct
{
DATATYPE data[maxsize]; //队中元素
int front,rear; //队头元素下标、队尾元素后面位置的下标
} SEQQUEUE;
/*****************************************************************************/
void QueueInit(SEQQUEUE *sq)
//将顺序循环队列sq置空(初始化)
{
sq-front=0;
sq-rear=0;
}
/*****************************************************************************/
int QueueIsEmpty(SEQQUEUE sq)
//如果顺序循环队列sq为空,成功返回1,否则返回0
{
if (sq.rear==sq.front)
return(1);
else
return(0);
}
/*****************************************************************************/
int QueueFront(SEQQUEUE sq,DATATYPE *e)
//将顺序循环队列sq的队头元素保存到e所指地址,成功返回1,失败返回0
{
if (QueueIsEmpty(sq))
else
}
/*****************************************************************************/
int QueueIn (SEQQUEUE *sq,DATATYPE x)
//将元素x入队列sq的队尾,成功返回1,失败返回0
{
if (sq-front==(sq-rear+1)%maxsize)
{
printf(“queue is full!\n”);
return 0;
}
else
{
sq-data[sq-rear]=x;
sq-rear=(sq-rear+1)%maxsize;
return(1);
}
}
/*****************************************************************************/
int QueueOut(SEQQUEUE *sq)
//将队列sq队首元素出队列,成功返回1,失败返回0
{
if (QueueIsEmpty(*sq))
{
printf(“queue is empty!\n”);
return 0;
}
else
{
sq-front=(sq-front+1)%maxsize;
return 1;
}
}
/***********************7。图的广度周游**********************/
void BFS(GRAPH g,int v,int mark[])
//从v出发广度优先周游图g中能访问的各个顶点
{
int v1,v2;
SEQQUEUE q;
QueueInit(q);
QueueIn(q,v);
mark[v]=1;
printf(“%c “,g.vexs[v]);
while(QueueIsEmpty(q)==0)
{
QueueFront(q,v1);
QueueOut(q);
for(v2=0;v2g.num;v2++)
{
if(g.arcs[v1][v2]!=0mark[v2]==0)
{
QueueIn(q,v2);
mark[v2]=1;
printf(“%c “,g.vexs[v2]);
}
}
}
}
/***********************8。图的广度周游**********************/
void GraphBFS(GRAPH g)
//深度优先周游图g中能访问的各个顶点
{
int qidian,v,v1,mark[maxsize];
printf(“\n广度周游:”);
printf(“\n请输入起点的下标:”);
scanf(“%d”,qidian);
for(v=0;vg.num;v++)
{
mark[v]=0;
}
for(v=qidian;vg.num+qidian;v++)
{
v1=v%g.num;
if(mark[v1]==0)
BFS(g,v1,mark);
}
}
/***********************主函数**********************/
void main()
{
GRAPH tu;
GraphCreate(tu);
GraphOut(tu);
GraphDFS(tu);
GraphBFS(tu);
}
另外,虚机团上产品团购,超级便宜
八数码问题·C语言写了个·输出可以·但为什么只输出一个过程·求高手解答·
不知道你的程序是要实现什么功能,你在这个程序中到底遇到的是什么问题。有的函数看过去就有逻辑问题。
关于八数码c语言和o八进制c语言的介绍到此就结束了,不知道你从中找到你需要的信息了吗 ?如果你还想了解更多这方面的信息,记得收藏关注本站。