隐式图的搜索问题 代码实现以及实验截图

最新推荐文章于 2022-03-12 19:37:52 发布
最新推荐文章于 2022-03-12 19:37:52 发布
阅读量59 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46817152/article/details/114682335
版权 
3.1 结点类
public class Node {
    //存储当前状态的情况
    int [][]nowState=new int[3][3];
    Node parent=null;
    Node child1=null,child2=null,child3=null,child4=null;
    private int f;//价值
    int h=0;//层数
    public Node(int [][]a,Node p,Node c1,Node c2,Node c3,Node c4,int h){
        for(int i=0;i<3;i++){
            for(int j=0;j<3;j++)
                nowState[i][j]=a[i][j];
        }
        child1=c1;
        child2=c2;
        child3=c3;
        child4=c4;
        this.h=h;
    }
    public void setF(int g)
    {
        f=g+h;
    }
    public int getF(){
        return f;
    }
}
3.2 A*算法实现类

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Doit {
    Node start;
    Node target;
    List<Node> list=new ArrayList<>();
    List<Node> path=new ArrayList<>();
    Scanner scanner=new Scanner(System.in);
    public Doit(){
        System.out.println("起始位置：");
        int [][]origin=new int[3][3];
        int [][]purpose=new int[3][3];
        for(int i=0;i<3;i++)
            for(int j=0;j<3;j++)
                origin[i][j]=scanner.nextInt();
        start=new Node(origin,null,null,null,null,null,0);
        System.out.println("目标位置：");
        for(int i=0;i<3;i++)
            for (int j = 0; j < 3; j++)
                purpose[i][j]=scanner.nextInt();
        target=new Node(purpose,null,null,null,null,null,0);
    }
    //判断是否可行
    public boolean isExist(Node a1,Node a2){
        int []b1=new int[9];
        int []b2=new int[9];
        int pd1=0,pd2=0,n1=0,n2=0;
        int i,j;
        for(i=0;i<3;i++) {
            for(j=0;j<3;j++){
                b1[n1++]=a1.nowState[i][j];
                b2[n2++]=a2.nowState[i][j];
            }
        }
        for(i=0;i<9;i++){
            for(j=0;j<i;j++){
                if(b1[j]>b1[i]&&b1[j]!=0&&b1[i]!=0)
                    pd1++;
            }
        }
        for(i=0;i<9;i++){
            for(j=0;j<i;j++){
                if(b2[j]>b2[i]&&b2[j]!=0&&b2[i]!=0)
                    pd2++;
            }
        }
        if(pd1%2==pd2%2)
            return true;
        else
            return false;
    }
    public boolean isEqual(Node a1,Node a2){
        for(int i=0;i<3;i++) {
            for(int j=0;j<3;j++){
                if(a1.nowState[i][j]!=a2.nowState[i][j])
                    return false;
            }
        }
        return true;
    }
    public void show(){
        System.out.println("移动步骤如下：");
        for(int k=path.size()-1;k>=0;k--)
        {
            System.out.println(path.size()-k+"：");
            for(int i=0;i<3;i++) {
                for(int j=0;j<3;j++){
                    System.out.print(path.get(k).nowState[i][j]+" ");
                }
                System.out.println();
            }
        }
    }
    public void add(Node leaf){
        int tmp;
        Node p;
        int [][]a=new int[3][3];
        int [][]b=new int[3][3];
        int [][]c=new int[3][3];
        int [][]d=new int[3][3];
        for(int i=0;i<3;i++) {
            for(int j=0;j<3;j++){
                a[i][j]=leaf.nowState[i][j];
                b[i][j]=leaf.nowState[i][j];
                c[i][j]=leaf.nowState[i][j];
                d[i][j]=leaf.nowState[i][j];
            }
        }
        int x=0,y=0;
        for(int i=0;i<3;i++) {
            for(int j=0;j<3;j++){
                if(a[i][j]==0)
                {
                    x=i;
                    y=j;
                }
            }
        }
        if ((x - 1) >= 0)
        {
            tmp=a[x][y];
            a[x][y]=a[x-1][y];
            a[x-1][y]=tmp;
            p = new Node(a,null,null,null,null,null,0);
            if (!compare(start, p))
            {
                leaf.child1=p;p.parent=leaf;
                p.h=leaf.h+1;
                int count=differentNum(p,target);
                p.setF(count);
                list.add(p);
            }
        }
        if (x + 1 <= 2)
        {
            tmp=b[x][y];
            b[x][y]=b[x+1][y];
            b[x+1][y]=tmp;
            p = new Node(b,null,null,null,null,null,0);
            if (!compare(start, p))
            {
                leaf.child2=p;p.parent=leaf;
                p.h=leaf.h+1;
                int count=differentNum(p,target);
                p.setF(count);
                list.add(p);
            }
        }
        if (y - 1 >= 0)
        {
            tmp=c[x][y];
            c[x][y]=c[x][y-1];
            c[x][y-1]=tmp;
            p = new Node(c,null,null,null,null,null,0);
            if (!compare(start, p))
            {
                leaf.child3=p;p.parent=leaf;
                p.h=leaf.h+1;
                int count=differentNum(p,target);
                p.setF(count);
                list.add(p);
            }
        }
        if (y + 1 <= 2)
        {
            tmp=d[x][y];
            d[x][y]=d[x][y+1];
            d[x][y+1]=tmp;
            p = new Node(d,null,null,null,null,null,0);
            if (!compare(start, p))
            {
                leaf.child4=p;p.parent=leaf;
                p.h=leaf.h+1;
                int count=differentNum(p,target);
                p.setF(count);
                list.add(p);
            }
        }
    }
    public boolean compare(Node root,Node p){
        if (root != null && isEqual(root,p))return true;
        if (root.child1 != null)compare(root.child1, p);
        if (root.child2 != null)compare(root.child2, p);
        if (root.child3 != null)compare(root.child3, p);
        if (root.child4 != null)compare(root.child4, p);
        return false;
    }
    public int differentNum(Node p,Node q){
        int count=0;
        for (int i = 0; i < 3; i++)
            for (int j = 0; j < 3; j++)
                if(p.nowState[i][j]!=q.nowState[i][j])
                    count++;
                return count;
    }
    public void aStar(){
        if (isExist(start,target)) {
            Node p=start;
            list.add(p);
            while(!isEqual(p,target)){
                list.remove(0);
                add(p);
                sort();
                p=list.get(0);
            }
            Node q = p;
            while (q != null)
            {
                path.add(q);
                q = q.parent;
            }
            show();
        }
        else{
            System.out.println("不可行！");
        }
    }
    public void sort(){
        Node node;
        int left=0,right=list.size()-1;
        while(left<right)
        {
            for(int i=left+1;i<=right;i++){
                if(list.get(left).getF()>list.get(i).getF()){
                    node=list.get(i);
                    list.set(i,list.get(left));
                    list.set(left,node);
                }
            }
            left++;
            for(int i=right-1;i>=left;i--){
                if(list.get(right).getF()<list.get(i).getF()){
                    node=list.get(i);
                    list.set(i,list.get(right));
                    list.set(right,node);
                }
            }
            right--;
        }
    }
}

*****************
//
public class Main {
    public static void main(String[]args){
        Doit doit=new Doit();
        doit.aStar();
    }
}
//
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Doit {
    Node start;
    Node target;
    List<Node> list=new ArrayList<>();
    List<Node> path=new ArrayList<>();
    Scanner scanner=new Scanner(System.in);
    public Doit(){
        System.out.println("起始位置：");
        int [][]origin=new int[3][3];
        int [][]purpose=new int[3][3];
        for(int i=0;i<3;i++)
            for(int j=0;j<3;j++)
                origin[i][j]=scanner.nextInt();
        start=new Node(origin,null,null,null,null,null,0);
        System.out.println("目标位置：");
        for(int i=0;i<3;i++)
            for (int j = 0; j < 3; j++)
                purpose[i][j]=scanner.nextInt();
        target=new Node(purpose,null,null,null,null,null,0);
    }
    //判断是否可行
    public boolean isExist(Node a1,Node a2){
        int []b1=new int[9];
        int []b2=new int[9];
        int pd1=0,pd2=0,n1=0,n2=0;
        int i,j;
        for(i=0;i<3;i++) {
            for(j=0;j<3;j++){
                b1[n1++]=a1.nowState[i][j];
                b2[n2++]=a2.nowState[i][j];
            }
        }
        for(i=0;i<9;i++){
            for(j=0;j<i;j++){
                if(b1[j]>b1[i]&&b1[j]!=0&&b1[i]!=0)
                    pd1++;
            }
        }
        for(i=0;i<9;i++){
            for(j=0;j<i;j++){
                if(b2[j]>b2[i]&&b2[j]!=0&&b2[i]!=0)
                    pd2++;
            }
        }
        if(pd1%2==pd2%2)
            return true;
        else
            return false;
    }
    public boolean isEqual(Node a1,Node a2){
        for(int i=0;i<3;i++) {
            for(int j=0;j<3;j++){
                if(a1.nowState[i][j]!=a2.nowState[i][j])
                    return false;
            }
        }
        return true;
    }
    public void show(){
        System.out.println("移动步骤如下：");
        for(int k=path.size()-1;k>=0;k--)
        {
            System.out.println(path.size()-k+"：");
            for(int i=0;i<3;i++) {
                for(int j=0;j<3;j++){
                    System.out.print(path.get(k).nowState[i][j]+" ");
                }
                System.out.println();
            }
        }
    }
    public void add(Node leaf){
        int tmp;
        Node p;
        int [][]a=new int[3][3];
        int [][]b=new int[3][3];
        int [][]c=new int[3][3];
        int [][]d=new int[3][3];
        for(int i=0;i<3;i++) {
            for(int j=0;j<3;j++){
                a[i][j]=leaf.nowState[i][j];
                b[i][j]=leaf.nowState[i][j];
                c[i][j]=leaf.nowState[i][j];
                d[i][j]=leaf.nowState[i][j];
            }
        }
        int x=0,y=0;
        for(int i=0;i<3;i++) {
            for(int j=0;j<3;j++){
                if(a[i][j]==0)
                {
                    x=i;
                    y=j;
                }
            }
        }
        if ((x - 1) >= 0)
        {
            tmp=a[x][y];
            a[x][y]=a[x-1][y];
            a[x-1][y]=tmp;
            p = new Node(a,null,null,null,null,null,0);
            if (!compare(start, p))
            {
                leaf.child1=p;p.parent=leaf;
                p.h=leaf.h+1;
                int count=differentNum(p,target);
                p.setF(count);
                list.add(p);
            }
        }
        if (x + 1 <= 2)
        {
            tmp=b[x][y];
            b[x][y]=b[x+1][y];
            b[x+1][y]=tmp;
            p = new Node(b,null,null,null,null,null,0);
            if (!compare(start, p))
            {
                leaf.child2=p;p.parent=leaf;
                p.h=leaf.h+1;
                int count=differentNum(p,target);
                p.setF(count);
                list.add(p);
            }
        }
        if (y - 1 >= 0)
        {
            tmp=c[x][y];
            c[x][y]=c[x][y-1];
            c[x][y-1]=tmp;
            p = new Node(c,null,null,null,null,null,0);
            if (!compare(start, p))
            {
                leaf.child3=p;p.parent=leaf;
                p.h=leaf.h+1;
                int count=differentNum(p,target);
                p.setF(count);
                list.add(p);
            }
        }
        if (y + 1 <= 2)
        {
            tmp=d[x][y];
            d[x][y]=d[x][y+1];
            d[x][y+1]=tmp;
            p = new Node(d,null,null,null,null,null,0);
            if (!compare(start, p))
            {
                leaf.child4=p;p.parent=leaf;
                p.h=leaf.h+1;
                int count=differentNum(p,target);
                p.setF(count);
                list.add(p);
            }
        }
    }
    public boolean compare(Node root,Node p){
        if (root != null && isEqual(root,p))return true;
        if (root.child1 != null)compare(root.child1, p);
        if (root.child2 != null)compare(root.child2, p);
        if (root.child3 != null)compare(root.child3, p);
        if (root.child4 != null)compare(root.child4, p);
        return false;
    }
    public int differentNum(Node p,Node q){
        int count=0;
        for (int i = 0; i < 3; i++)
            for (int j = 0; j < 3; j++)
                if(p.nowState[i][j]!=q.nowState[i][j])
                    count++;
        return count;
    }
    public void aStar(){
        if (isExist(start,target)) {
            Node p=start;
            list.add(p);
            while(!isEqual(p,target)){
                list.remove(0);
                add(p);
                sort();
                p=list.get(0);
            }
            Node q = p;
            while (q != null)
            {
                path.add(q);
                q = q.parent;
            }
            show();
        }
        else{
            System.out.println("不可行！");
        }
    }
    public void sort(){
        Node node;
        int left=0,right=list.size()-1;
        while(left<right)
        {
            for(int i=left+1;i<=right;i++){
                if(list.get(left).getF()>list.get(i).getF()){
                    node=list.get(i);
                    list.set(i,list.get(left));
                    list.set(left,node);
                }
            }
            left++;
            for(int i=right-1;i>=left;i--){
                if(list.get(right).getF()<list.get(i).getF()){
                    node=list.get(i);
                    list.set(i,list.get(right));
                    list.set(right,node);
                }
            }
            right--;
        }
    }
}

//
public class Node {
    //存储当前状态的情况
    int [][]nowState=new int[3][3];
    Node parent=null;
    Node child1=null,child2=null,child3=null,child4=null;
    private int f;//价值
    int h=0;//层数
    public Node(int [][]a,Node p,Node c1,Node c2,Node c3,Node c4,int h){
        for(int i=0;i<3;i++){
            for(int j=0;j<3;j++)
                nowState[i][j]=a[i][j];
        }
        child1=c1;
        child2=c2;
        child3=c3;
        child4=c4;
        this.h=h;
    }
    public void setF(int g)
    {
        f=g+h;
    }
    public int getF(){
        return f;
    }
}

在这里插入图片描述
在这里插入图片描述

山无〇
关注
数据结构课设--隐式图的搜索问题(c++实现)
qq_45740088的博客
06-22 281
隐式图的搜索问题--c++实现一.实验内容二、实验提示三.启发式搜索算法的工作过程代码总结参考文献 一.实验内容 编写九宫重排问题的启发式搜索（A算法）求解程序。 在3х3组成的九宫棋盘上，放置数码为1~8的8个棋子，棋盘中留有一个空格，空格周围的棋子可以移动到空格中，从而改变棋盘的布局。根据给定初始布局和目标布局，编程给出一个最优的走法序列。输出每个状态的棋盘 测试数据：初始状态：123456780 目标状态：0cc3312345678 【输入格式】 输入包含三行，每行3各整数，分别为0-8这九个数
题目2：隐式图的搜索问题（A*算法解决八数码）
weixin_52382922的博客
03-12 749
文章目录声明题目要求何为八数码？状态如何表示所需知识导出所需知识优先队列BFS算法缺陷A*搜索算法总结：实际操作搜索过程描述启发式策略工作工程：红圈数字表示扩展顺序代码实现Map+BFS+A*Hash+BFS+A* 声明 题目要求 看过这次实验要求之后 总结：利用A*来解决八数码问题，状态很好找，每次移动空格就会形成一种新的状态， 何为八数码？ 八数码游戏包括一个3X3的棋盘，棋盘上摆放着8个数字的棋子，留下一个空位。与空位相邻的棋子可以滑动到空位中。游戏的目的是要达到一个特定的目标状态。标注的形式化如下（
数据结构(C语言版)(第2版)课后习题答案.docx
06-01
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术有关
题目2：隐式图的搜索问题（代码实现）
KT_xiaobai的博客
03-08 246
题目2：隐式图的搜索问题（代码实现）主类Main.javaREADME 主类 Main.java import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Scanner; /** * @author 86183 * @ClassName: IntelliJ IDEA * @Description: * @date 2021/3/5 13:15 */ p
数据结构课程实践（2）-代码实现
帅气dc的博客
03-01 349
数据结构课程实践（2） 一.题目：隐式图的搜索问题 ----代码实现 1.结点类 public class Node { //存储当前状态的情况 int [][]nowState=new int[3][3]; Node parent=null; Node child1=null,child2=null,child3=null,child4=null; private int f;//价值 int h=0;//层数 public Node(int [][
数据结构-简单单链表（带头节点）
qq_43290676的博客
07-10 169
简单单链表-上图 首先创建一个节点的类 class Node { //a和b是节点的数据，next是指向的下一个节点。 private int a; private String b; public Node next; public Node(int a,String b) { this.a=a; this.b=b; } public int getA() { return a; }
C语言实现：八数码问题的深度优先搜索、广度优先搜索、过程表示（全）
03-26
人工智能实验： 实现结果：给定八数码的起始...最简单的方法是在上述深度搜索代码上进行改动，即可进行广度搜索。 深度是将集合中的元素从末尾取出，即和栈的特点相同，那么将先进后出变为先进先出，即将栈改成了队列。
[Matlab]2018国赛 A题思路以及Matlab代码实现
热门推荐
Rinnki's memo
03-26 4万+
CUMCM2018 A题解题思路以及代码实现一些关于CUMCM的思考CUMCM2018 A题第一问第二问第三问结语参考文献 一些关于CUMCM的思考 CUMCM2018 A题 A题 高温作业专用服装设计 在高温环境下工作时，人们需要穿着专用服装以避免灼伤。专用服装通常由三层织物材料构成，记为I、II、III层，其中I层与外界环境接触，III层与皮肤之间还存在空隙，将此空隙记为IV层。 为设计专...
将隐式神经表示（INR）用于2D图像
Paper weekly
03-12 7440
©PaperWeekly 原创 ·作者 | 张一帆学校 | 中科院自动化所博士生研究方向 | 计算机视觉以图像为例，其最常见的表示方式为二维空间上的离散像素点。但是，在真实世界中，我们看...
数据结构笔记
NP_hard的博客
11-22 408
c数据结构 链表 链表的类实现 class Node//节点类 { public: Node* next; int data; Node() { next = NULL; } }; class LinkList//实例化得到一个带有空节点的头指针 { public: Node* head;//头指针 int len; LinkList() { head = new Node();//head头指针指向一个空节点 len = 0; } ~LinkList()//从头删到尾
数据结构和算法经典100题-第23题
bobkent的专栏
12-16 523
题目： 给定一个有序数组int array[n]，已知其中没有重复值，用这个有序数组生成一棵平衡二叉树，要求中序遍历结果与数组一致。 题目解析： 。。。。。。。。。。
java 递归json_【Java】JSON递归代码
weixin_29763641的博客
02-20 374
ExtJs树的递归算法(Java)，Json格式Java, ExtJs, Json, 递归, 算法Java代码publicclassNode{privateintid;privateintparentId;Node(){}Node(intid,intparentId){this.id=id;this.parentId=parentId;}publicintgetId()...
数据结构之树
IT之一小佬的博客
04-15 538
数据结构之树 树是一种抽象数据类型(ADT)或是视作这种抽象数据类型的数据结构，用来模拟具有树状结构性质的数据集合，他是由n（n>1）个有限节点组成一个具有层次结构的集合。把它叫做树是因为它看起来像一颗倒挂的树，也就是说它是根朝上，而叶朝下的。 树的定义 由n（n>0）个元素组成的有限集合，其中： 每个元素称为结点（node）； 有一个特定的结点，称为根结点或根（root）； 除根结点外，其余结点被分成m（m>=0）个互不相交的有限集合，而每个子集又都是一棵树（称为原树
数据结构与算法（基础 C++）P1
LongXinKou的博客
04-07 494
此博客用于记录第一次初步较浅层学习数据结构与算法的记录 文章目录1 swap()算法2 SelectSort()算法 1 swap()算法 （1）内容： swap()算法的两种实现 swap函数（2）算法实现 // 引用传参 void myswap(int &x,int &y) { int p; p=x; x=y; y=p; } //注意事项：直接传递变量无法实...
java对字符串快查找_字符串快速查找 - Trie算法
weixin_35087326的博客
02-26 717
Trie算法先对给定的字符串进行归集，形成一个多叉树形结构。使用字符导航方式作匹配查找。trie算法有很多变种，以最左(前缀)匹配为例进行说明。优点使用字符导航查找方式，能最大限度减少字符比较过程，常被用在词频统计和字符串排序方面。trie算法对文本只需遍历一次，将时间复杂度降到O(n)。Java示例数据结构class Node {Map next;}样本数据处理public void add(S...
Node开发（八）Class类
weixin_43933148的博客
09-26 2858
在ES5使用构造函数来创建对象(一直在使用函数来模拟对象) 在ES6中，引入class关键字，可以使用class来定义类 一、Class简介 1.什么是类？ 类是用来描述具有一些共同的特性和行为的事物 类由属性和方法组成 2.什么是对象？ 对象是类的实例 3.class class Student { constructor(no, name, age) { this.no = no; this.name = name;
C#双向链表
dayuhaitang1的博客
10-07 631
在这也没什么好说的，写博客也主要是为了记录学习过程中的自己编的一些程序和心得而已。 一、实现代码 1、节点类 class Node //建立节点类，作为节点 { public int ID; public string Name; public Node(int ID,string Name) { ...
HDU 1495 非常可乐（隐式图的遍历）
Java识堂，一个有干货的微信公众号
07-26 1233
题目地址：点击打开链接 思路：用3维数组标记已走过的点，其实没有必要，因为2个杯中的水确定下来，剩下的一个点也就确定下来了，只用一个2维数组标记即可 这道题是一个一般隐式图的遍历 说到底就是搜索问题，把各种状态都走一遍，直到走到要的那种状态，用数组标记已走过的状态，如果走过就不用进队了，要是你非要进，只会浪费时间 状态转移无非6种情况 S->N S->M N->M N-
Flutter实现轮播图效果：隐式动画控件详解
"这篇文章主要讲解了在Flutter中如何实现轮播图效果，通过实例代码提供了详细的步骤和指导，适合学习和工作中参考。" 在Flutter开发中，实现动态效果和动画是一项重要的任务，而轮播图作为常见的交互元素，自然也是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值