盲目搜索算法实现八数码问题

最新推荐文章于 2023-03-09 07:04:20 发布
最新推荐文章于 2023-03-09 07:04:20 发布
阅读量191 收藏
点赞数
文章标签： java servlet 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52130455/article/details/128843462
版权 
package com.jn.rz.实验一;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Stack;
import java.util.stream.Collectors;

/**
 * @author 江南大学1033190417
 * @date 2022/3/31 11:36
 */
public class Status implements Serializable {

    public int[][] status;//状态元素

    public Integer depth;

    public List<Status> path = new ArrayList<>();//路径

    public Status(int[][] status) {
        this.status = status;
    }

    public List<Status> getChildStatus() {
        List<Status> childStatus = new ArrayList<>();
        if (left()) {
            Status s = new Status(copyArray(this.status));
            s.depth = this.depth + 1;
            childStatus.add(s);
            right();
        }
        if (up()) {
            Status s = new Status(copyArray(this.status));
            s.depth = this.depth + 1;
            childStatus.add(s);
            down();
        }

        if (down()) {
            Status s = new Status(copyArray(this.status));
            s.depth = this.depth + 1;
            childStatus.add(s);
            up();
        }
        if (right()) {
            Status s = new Status(copyArray(this.status));
            s.depth = this.depth + 1;
            childStatus.add(s);
            left();
        }
        return childStatus;
    }

    //上移动，相对0来说
    public boolean up() {
        int[] coordinateOf0 = getCoordinateOf0();
        int x = coordinateOf0[0];
        int y = coordinateOf0[1];
        try {
            this.status[x][y] = this.status[x - 1][y];
            this.status[x - 1][y] = 0;
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    //下移
    public boolean down() {
        int[] coordinateOf0 = getCoordinateOf0();
        int x = coordinateOf0[0];
        int y = coordinateOf0[1];
        try {
            this.status[x][y] = this.status[x + 1][y];
            this.status[x + 1][y] = 0;
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    //左移
    public boolean left() {
        int[] coordinateOf0 = getCoordinateOf0();
        int x = coordinateOf0[0];
        int y = coordinateOf0[1];
        try {
            this.status[x][y] = this.status[x][y - 1];
            this.status[x][y - 1] = 0;
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    //右移
    public boolean right() {
        int[] coordinateOf0 = getCoordinateOf0();
        int x = coordinateOf0[0];
        int y = coordinateOf0[1];
        try {
            this.status[x][y] = this.status[x][y + 1];
            this.status[x][y + 1] = 0;
            return true;
        } catch (Exception e) {
            return false;
        }
    }
    
    /**
     * 定位0的位置
     *
     * @return 横纵坐标
     */
    public int[] getCoordinateOf0() {
        for (int i = 0; i < this.status.length; i++) {
            for (int j = 0; j < this.status[i].length; j++) {
                if (this.status[i][j] == 0) {
                    return new int[]{i, j};
                }
            }
        }
        return new int[]{-1, -1};
    }

    //深拷贝数组
    public static int[][] copyArray(int[][] input) {
        int[][] output = new int[input.length][input[0].length];
        for (int i = 0; i < input.length; i++) {
            for (int j = 0; j < input[i].length; j++) {
                output[i][j] = input[i][j];
            }
        }
        return output;
    }


    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Status status1 = (Status) o;
        for (int i = 0; i < this.status.length; i++) {
            for (int j = 0; j < this.status[i].length; j++) {
                if (this.status[i][j] != status1.status[i][j])
                    return false;
            }
        }
        return true;
    }

    @Override
    public String toString() {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < this.status.length; i++) {
            for (int j = 0; j < this.status[i].length; j++) {
                result.append(this.status[i][j]).append("\t");
            }
            result.append("\n");
        }
        return result.toString();
    }

    public static void main(String[] args) throws Exception {
        int[][] start = new int[3][3];//初始状态
        int[][] end = new int[3][3];//目标状态
        Stack<Status> open = new Stack<>();//open表
        Stack<Status> closed = new Stack<>();//closed表
        int depth = 5;//深度限制

        FileInputStream fis = new FileInputStream("D:\\桌面\\人工智能\\实验\\src\\com\\jn\\rz\\实验一\\input.txt");
        InputStreamReader dis = new InputStreamReader(fis);
        BufferedReader reader = new BufferedReader(dis);
        String s;
        int hang = 0;//行号标记
        while ((s = reader.readLine()) != null) {
            if ("".equals(s))
                continue;
            if (s.contains("depth")) {
                depth = Integer.parseInt(s.split(" ")[1]);
                continue;
            }
            String[] split = s.split(" ");
            if (hang >= 3) {
                for (int i = 0; i < 3; i++) {
                    end[hang % 3][i] = Integer.parseInt(split[i]);
                }
                hang++;
            } else {
                for (int i = 0; i < 3; i++) {
                    start[hang % 3][i] = Integer.parseInt(split[i]);
                }
                hang++;
            }
        }

        Status startStatus = new Status(start);
        startStatus.depth = 1;
        Status endStatus = new Status(end);
        open.add(startStatus);

        while (!open.isEmpty()) {
            Status n = open.pop();
            n.path.add(n);
            System.out.println(n);//输出遍历的过程
            closed.add(n);
            if (n.equals(endStatus)) {
                System.out.println("解路长度："+n.path.size());
                System.out.println("找到的解");
                for (Status status : n.path) {
                    System.out.println(status);
                }
               break;
            }
            if (n.depth == depth) {
                continue;
            }
            //得到所有子状态
            List<Status> childStatus = n.getChildStatus();
            //从n的子状态中删除已在open或closed表中出现的状态
            List<Status> statuses = childStatus.stream().filter(status -> {
                return (!open.contains(status) && !closed.contains(status));
            }).map(status -> {
                List<Status> list = new ArrayList<>(n.path);
                status.path = list;
                return status;
            }).collect(Collectors.toList());
            //将n的其余子状态，按生成的次序加入到open表的前端
            open.addAll(statuses);
        }
        System.out.println("搜索的步数：" + closed.size());
    }
}

package com.jn.rz.实验一;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Stack;
import java.util.stream.Collectors;

/**
 * @author 江南大学1033190417
 * @date 2022/3/31 11:36
 */
public class Status implements Serializable {

    public int[][] status;//状态元素

public Integer depth;

    public List<Status> path = new ArrayList<>();//路径

public Status(int[][] status) {
        this.status = status;
    }

    public List<Status> getChildStatus() {
        List<Status> childStatus = new ArrayList<>();
        if (left()) {
            Status s = new Status(copyArray(this.status));
            s.depth = this.depth + 1;
            childStatus.add(s);
            right();
        }
        if (up()) {
            Status s = new Status(copyArray(this.status));
            s.depth = this.depth + 1;
            childStatus.add(s);
            down();
        }

        if (down()) {
            Status s = new Status(copyArray(this.status));
            s.depth = this.depth + 1;
            childStatus.add(s);
            up();
        }
        if (right()) {
            Status s = new Status(copyArray(this.status));
            s.depth = this.depth + 1;
            childStatus.add(s);
            left();
        }
        return childStatus;
    }

    //上移动，相对0来说
public boolean up() {
        int[] coordinateOf0 = getCoordinateOf0();
        int x = coordinateOf0[0];
        int y = coordinateOf0[1];
        try {
            this.status[x][y] = this.status[x - 1][y];
            this.status[x - 1][y] = 0;
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    //下移
public boolean down() {
        int[] coordinateOf0 = getCoordinateOf0();
        int x = coordinateOf0[0];
        int y = coordinateOf0[1];
        try {
            this.status[x][y] = this.status[x + 1][y];
            this.status[x + 1][y] = 0;
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    //左移
public boolean left() {
        int[] coordinateOf0 = getCoordinateOf0();
        int x = coordinateOf0[0];
        int y = coordinateOf0[1];
        try {
            this.status[x][y] = this.status[x][y - 1];
            this.status[x][y - 1] = 0;
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    //右移
public boolean right() {
        int[] coordinateOf0 = getCoordinateOf0();
        int x = coordinateOf0[0];
        int y = coordinateOf0[1];
        try {
            this.status[x][y] = this.status[x][y + 1];
            this.status[x][y + 1] = 0;
            return true;
        } catch (Exception e) {
            return false;
        }
    }

//    //得到所有子状态
//    public List<Status> getAllChildStatus() {
//        List<Status> childStatus = new ArrayList<>();
//        if (up()) {
//            Status s = new Status(copyArray(this.status));
//            childStatus.add(s);
//            down();
//        }
//        if (down()) {
//            Status s = new Status(copyArray(this.status));
//            childStatus.add(s);
//            up();
//        }
//        if (left()) {
//            Status s = new Status(copyArray(this.status));
//            childStatus.add(s);
//            right();
//        }
//        if (right()) {
//            Status s = new Status(copyArray(this.status));
//            childStatus.add(s);
//            left();
//        }
//        return childStatus;
//    }

    /**
     * 定位0的位置
*
     * @return 横纵坐标
*/
public int[] getCoordinateOf0() {
        for (int i = 0; i < this.status.length; i++) {
            for (int j = 0; j < this.status[i].length; j++) {
                if (this.status[i][j] == 0) {
                    return new int[]{i, j};
                }
            }
        }
        return new int[]{-1, -1};
    }

    //深拷贝数组
public static int[][] copyArray(int[][] input) {
        int[][] output = new int[input.length][input[0].length];
        for (int i = 0; i < input.length; i++) {
            for (int j = 0; j < input[i].length; j++) {
                output[i][j] = input[i][j];
            }
        }
        return output;
    }


    @Override
public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Status status1 = (Status) o;
        for (int i = 0; i < this.status.length; i++) {
            for (int j = 0; j < this.status[i].length; j++) {
                if (this.status[i][j] != status1.status[i][j])
                    return false;
            }
        }
        return true;
    }

    @Override
public String toString() {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < this.status.length; i++) {
            for (int j = 0; j < this.status[i].length; j++) {
                result.append(this.status[i][j]).append("\t");
            }
            result.append("\n");
        }
        return result.toString();
    }

    public static void main(String[] args) throws Exception {
        int[][] start = new int[3][3];//初始状态
int[][] end = new int[3][3];//目标状态
Stack<Status> open = new Stack<>();//open表
Stack<Status> closed = new Stack<>();//closed表
int depth = 5;//深度限制

FileInputStream fis = new FileInputStream("D:\\桌面\\人工智能\\实验\\src\\com\\jn\\rz\\实验一\\input.txt");
        InputStreamReader dis = new InputStreamReader(fis);
        BufferedReader reader = new BufferedReader(dis);
        String s;
        int hang = 0;//行号标记
while ((s = reader.readLine()) != null) {
            if ("".equals(s))
                continue;
            if (s.contains("depth")) {
                depth = Integer.parseInt(s.split(" ")[1]);
                continue;
            }
            String[] split = s.split(" ");
            if (hang >= 3) {
                for (int i = 0; i < 3; i++) {
                    end[hang % 3][i] = Integer.parseInt(split[i]);
                }
                hang++;
            } else {
                for (int i = 0; i < 3; i++) {
                    start[hang % 3][i] = Integer.parseInt(split[i]);
                }
                hang++;
            }
        }

        Status startStatus = new Status(start);
        startStatus.depth = 1;
        Status endStatus = new Status(end);
        open.add(startStatus);

        while (!open.isEmpty()) {
            Status n = open.pop();
            n.path.add(n);
            System.out.println(n);//输出遍历的过程
closed.add(n);
            if (n.equals(endStatus)) {
                System.out.println("解路长度："+n.path.size());
                System.out.println("找到的解");
                for (Status status : n.path) {
                    System.out.println(status);
                }
               break;
            }
            if (n.depth == depth) {
                continue;
            }
            //得到所有子状态
List<Status> childStatus = n.getChildStatus();
            //从n的子状态中删除已在open或closed表中出现的状态
List<Status> statuses = childStatus.stream().filter(status -> {
                return (!open.contains(status) && !closed.contains(status));
            }).map(status -> {
                List<Status> list = new ArrayList<>(n.path);
                status.path = list;
                return status;
            }).collect(Collectors.toList());
            //将n的其余子状态，按生成的次序加入到open表的前端
open.addAll(statuses);
        }
        System.out.println("搜索的步数：" + closed.size());
    }
}
帅一个千秋
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
实验3：搜索算法求解8数码问题
Github主页：https://github.com/xinyangwy
03-25 3143
文章目录实验目的实验内容参考代码： 实验目的 (1）熟悉人工智能系统中的问题求解过程;(2）熟悉状态空间中的盲目搜索策略; (3）掌握盲目搜索算法，重点是宽度优先搜索和深度优先搜索算法。 实验内容 （1）用Python语言编程，采用宽度优先搜索求解8数码问题 采用宽度优先算法，运行程序，要求输入初始状态假设给定如下初始状态SO 2 8 3 1 6 4 7 0 5 和目标状态Sg 2 1 6 4 0 8 7 5 3 验证程序的输出结果，写出心得体会。 (2）对代码进行修改(选作)，实现深度优先搜索求解该问
八数码问题——盲目搜索（带移动步骤）
hongshanqu的博客
03-09 844
向son_father 压入now 时，压入的是：now：now的父，这样的键对。以后到达目标节点，可以在搜索树son_fathe中反溯，从目标找父，在找父，一直找到startlayout。为了能打印出能移动到目标的移动步骤，一个自然的想法是随时管理一个到达当前节点的最短移动路径，这个想法的实现太慢了。还是选择常用的方法，建立搜索树。这个搜索树是一个字典，用来记录节点之间父子关系，字典名为 son_father。把这个python文件命名为：cha2_8数码_自己版_带路径.py 保存。
八数码问题之盲目式搜索法（双向搜索法）
liuqiyu的专栏
01-19 2406
本文来自：http://kapinter.spaces.live.com/blog/cns!142AD4209363D971!665.entry 题目描述： 八数码问题 之 盲目式搜索法（双向搜索法）题目：http://acm.pku.edu.cn/JudgeOnline/problem?id=1077 //实质也是宽
八数码难题——盲目搜索（不显示移动步骤）
hongshanqu的博客
03-09 296
八数码难题是一个典型的搜索问题，出现在各种教材中，用来演示盲目搜索，启发式搜索的实现过程。这里给出的程序遵循标准的盲目搜索、启发式搜索算法编写，供初学基础搜索的同学比对参考。这里先给出只显示问题可解，不显示移动步骤的代码，可以直接简明地显示盲目搜索的步骤。
8数码盲目宽度搜索c语言实现,C语言实现8数码问题.doc
weixin_39938522的博客
05-21 356
#include//八数码状态对应的节点结构体struct Node{int s[3][3];//保存八数码状态，0代表空格int f,g;//启发函数中的f和g值struct Node * next;struct Node *previous;//保存其父节点};int open_N=0; //记录Open列表中节点数目//八数码初始状态int inital_s[3][3]={2,8,3,1,6...
java写的八数码问题（启发式搜索算法）
06-16
使用java语言写的八数码问题，仅供参考。其中用到了启发式搜索算法
python深度，广度，三种启发式搜索解决八数码问题
05-10
总结，Python提供了强大的工具和库，使我们能够轻松地实现和可视化八数码问题的各种搜索策略。通过理解这些算法的工作原理并结合实际编程实践，我们可以深入学习到搜索算法的精髓，这对于解决更复杂的问题和提升编程...
人工智能+八数码问题+深度、A*和广度搜索
03-30
分别用广度优先搜索策略、深度优先搜索策略和启发式搜索算法（A*算法）求解八数码问题；分析估价函数对启发式搜索算法的影响；探究各个搜索算法的特点。熟悉人工智能中的知识表示方法；熟悉盲目搜索和启发式搜索算法...
bashuma.rar_bashuma _八数码_八数码问题
09-19
【八数码问题】，也被称为滑动拼图游戏，是一个经典的计算机科学问题，涉及到人工智能、图论和搜索算法。在这个问题中，玩家需要通过移动一个空格与其他数字方块进行交互，以达到预设的目标状态。游戏板通常为2x3或3...
盲目式算法的编程实现
04-03
在编程领域，盲目式搜索算法是一种广泛应用于解决复杂问题的策略，主要分为广度优先搜索（Breadth-First Search, BFS）和深度优先搜索（Depth-First Search, DFS）。这两种算法都属于图论和树结构中的遍历方法，常...
盲目式搜索算法设计与实验报告
08-03
通过这个文件可以了解盲目式搜索算法的基础知识，对后续的人工学习有很大的帮助
人工智能 8数码问题 3个实验
06-13
关于8数码问题 实验1 盲目搜索 实验2 启发式搜索 实验3 A算法 都有实现代码
人工智能实验4——用盲目搜索求解八数码问题
weixin_30457551的博客
04-11 3324
八数码问题：在3×3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空的，其初始状态如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。 广度优先搜索算法流程： 1. 把起始节点放到OPEN表中(如果该起始节点为一目标节点，则求得一个解答)。 2. 如果OPEN是个空表，则没有解，失败退出；否则继续。 3. 把第一个节点(节点n)从OPEN...
Java 八数码问题求解
Braveryya的博客
05-15 278
import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; //以0为移动对象 Hn是错位个数/距离目标位置的距离 public class EightPuzzle implements Comparable { public static void main(String args[]) { ArrayList<EightPuzzle> open = new A..
HihoCoder1312八数码问题（启发式搜索
老街#
09-26 425
https://hihocoder.com/problemset/problem/1312 题意：是中文 思路：启发式搜索 意求从一个状态到另一个状态 hash每个状态存在一个数组里，排序，用二分找当前状态的下标。 bfs每种状态，如果和最终状态相同则更新答案。话不多说看代码吧 #include&lt;cstdio&gt; #include&lt;vector&gt; #includ...
三种搜索求解八数码 问题的效率对比
顺子的博客
07-23 7888
问题描述 以宽度优先搜索、深度优先搜索以及A*算法求解八数码问题。每一种算法都设置相同的初始状态和目标状态，针对搜索策略，求得问题的解，并比较搜索算法的性能。 针对下列两种八数码对算法进行对比 （1） （2） 基本原理 图搜索算法介绍 图搜索控制策略是指在图中寻找相应路径的方法。图中的每个节点对应一个状态，每条连线对应一个操作符。图的搜索策略主要有以下几种： 图的搜索策略 各个搜索算法的特点如下: 盲目搜索：没有启发信息的一种搜索形式，不需要重排open表，效率低，耗费过多的计算空
基于搜索策略的八数码问题求解（报告+源码）
qq_43393963的博客
04-29 6972
写在开头 这是"人工智能导论"课程的结课作业,里面包括了宽度优先搜索策略和全局择优搜索策略的算法描述与实现,并对于启发式函数进行了多次对比实验,主要介绍了6种可行的启发式函数,希望能给大家带来一些帮助. 项目源码见我的GitHub:https://github.com/Jupiter2Pluto/Eight-digit-problem 一、 问题描述 1.1 问题引入 对任意的八数码问题，...
A*算法解决八数码问题
热门推荐
我的新博客
10-12 7万+
1 问题描述 1.1什么是八数码问题 八数码游戏包括一个33的棋盘，棋盘上摆放着8个数字的棋子，留下一个空位。与空位相邻的棋子可以滑动到空位中。游戏的目的是要达到一个特定的目标状态。标注的形式化如下：   1 2 3 4 5 6 7 8 1.2问题的搜索形式描述
python深度优先搜索算法实现八数码难题
最新发布
04-06
可以使用深度优先搜索（DFS）或广度优先搜索（BFS）算法来解决八数码难题。具体实现可以采用递归或迭代的方式。在搜索过程中，需要记录每个状态的状态值、当前状态对应的操作步骤以及从起始状态到当前状态的路径等...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值