Fatal编程技术网
  • java/
  • Java AI为NxN难题找到解决方案

Java AI为NxN难题找到解决方案

java memory-leaks artificial-intelligence

Java AI为NxN难题找到解决方案,java,memory-leaks,artificial-intelligence,depth-first-search,Java,Memory Leaks,Artificial Intelligence,Depth First Search,首先，有很多代码，因为我真的不知道我的问题在哪里，我道歉 我制作了一个程序，它解决了一个大小不等的难题，如EG（3x3和0－8），零代表空白的瓦片，目标是移动空白的瓦片，直到达到目标状态。目前，我正在使用深度优先搜索来解决这个难题。当我运行该程序时，Netbeans返回一个“OutOfMemory”错误，但是如果我更改了目标状态，因此只需要一次移动即可完成，它将显示解决方案。下面是我的代码，我只添加了一些类，因为我不希望这篇文章长得离谱。如果你需要其他课程，请告诉我 编辑：为电路板类插入了错误的

首先，有很多代码，因为我真的不知道我的问题在哪里，我道歉

我制作了一个程序，它解决了一个大小不等的难题，如EG（3x3和0－8），零代表空白的瓦片，目标是移动空白的瓦片，直到达到目标状态。目前，我正在使用深度优先搜索来解决这个难题。当我运行该程序时，Netbeans返回一个“OutOfMemory”错误，但是如果我更改了目标状态，因此只需要一次移动即可完成，它将显示解决方案。下面是我的代码，我只添加了一些类，因为我不希望这篇文章长得离谱。如果你需要其他课程，请告诉我

编辑：为电路板类插入了错误的代码

package npuzzle;

import java.util.ArrayList;
import java.util.Stack;

public class DFSearch {

public static void search(int[][] initial, int[][] goal, int rows, int columns)
{
    Board board = new Board(initial, goal, rows, columns, "");
    Node root = new Node(board);
    Stack<Node> stack = new Stack<Node>();

    stack.add(root);

    performSearch(stack, board);
}

 public static void performSearch(Stack<Node> s, Board board)
{
    int searchCount = 1;

    while (!s.isEmpty())
    {
        Node tNode = (Node) s.pop();

        //if not goal state
        if (!tNode.getCurrentState().isGoalState())
        {
            ArrayList<State> tChildren = tNode.getCurrentState().gChildren();

            for (int i = 0; i < tChildren.size(); i++)
            {
                Node newNode = new Node(tNode, tChildren.get(i), tNode.getGCost() + tChildren.get(i).findCost(), 0);

                if(!isRepeatedState(newNode))
                {
                    s.add(newNode);
                }
            }
            searchCount++;
        }
        else
        {                
            tNode.getCurrentState().printState();
            System.exit(0);
            //PRINTING OF DIRECTIONS
        }
    }

    System.out.println("Error! No solution found!");
}

private static boolean isRepeatedState(Node c)
{
    boolean returnVal = false;
    Node checkNode = c;

    while(c.getParent() != null && !returnVal)
    {
        if (c.getParent().getCurrentState().equals(checkNode.getCurrentState()))
        {
            returnVal = true;
        }

        c = c.getParent();
    }

    return returnVal;
}

package npuzzle;

import java.util.ArrayList;
import java.util.Arrays;

public class Board implements State
{
private int PUZZLE_SIZE = 0;
private int outOfPlace = 0;

private int rows;
private int columns;

private int[][] GOAL;

private int[][] currentBoard;

private String directions = "";

public Board(int[][] initial, int[][] goal, int N, int M, String direction)
{
    currentBoard = initial;
    GOAL = goal;

    rows = N;
    columns = M;

    PUZZLE_SIZE = rows*columns;

    directions = direction;

    setOutOfPlace();
}

@Override
public boolean isGoalState() {

    if (Arrays.deepEquals(currentBoard, GOAL))
    {
        return true;
    }

    return false;
}

@Override
public ArrayList<State> gChildren() {

    ArrayList<State> children = new ArrayList<State>();
    int[] blanktile = getBlankTile();
    int[] newblanktile = Arrays.copyOf(blanktile, blanktile.length);

    if (blanktile[0] != 0) {
        newblanktile[0]--;
        Swap(newblanktile, blanktile, children, "up");
        newblanktile =  Arrays.copyOf(blanktile, blanktile.length);
    }

    if (blanktile[1] != 0) {
        newblanktile[1]--;
        Swap(newblanktile, blanktile, children, "left");
        newblanktile =  Arrays.copyOf(blanktile, blanktile.length);
    }

    if (blanktile[0] != (this.rows - 1)) {
        newblanktile[0]++;
        Swap(newblanktile, blanktile, children, "down");
        newblanktile =  Arrays.copyOf(blanktile, blanktile.length);
    }

    if (blanktile[1] != (this.columns - 1)) {
        newblanktile[1]++;
        Swap(newblanktile, blanktile, children, "right");
        newblanktile =  Arrays.copyOf(blanktile, blanktile.length);
    }

    return children;
}

@Override
public double findCost() {
    return 1;
}

@Override
public void printState() {
    System.out.println(directions);
}

@Override
public boolean equals(State s) {

    if (Arrays.deepEquals(currentBoard, ((Board) s).getCurrentBoard()))
    {
        return true;
    }
    else
        return false;
}

private void setOutOfPlace() {

    int i = 0;
    int j = -1;

    do 
    {
        if (j == (columns - 1)) {j = 0; i++;}
        else {j++;}

        if (currentBoard[i][j] != GOAL[i][j])
        {
            outOfPlace++;
        }

    } while (((i+1)*(j+1)) < PUZZLE_SIZE);
}

private int[] getBlankTile()
{
    int i = 0;
    int j = -1;

    int[] blanktile = {0,0};

    do 
    {
        if (j == (columns - 1)) {j = 0; i++;}
        else {j++;}

        if (currentBoard[i][j] == 0) {
            blanktile[0] = i;
            blanktile[1] = j;
        }

    } while (((i+1)*(j+1)) < PUZZLE_SIZE);
    return blanktile;
}

public int getOutOfPlace()
{
    return outOfPlace;
}

private int[][] copyBoard(int[][] state)
{
    int[][] returnArray = new int[rows][columns];
    for (int i = 0, j = 0; i*j < PUZZLE_SIZE; i++, j++)
    {
        returnArray[i] = Arrays.copyOf(state[i], state[i].length);
    }
    return returnArray;
}

private void Swap(int[] nbt, int[] bt, ArrayList<State> children, String direction) {

    int[][] cpy = copyBoard(currentBoard);
    int temp = cpy[nbt[0]][nbt[1]];
    cpy[nbt[0]][nbt[1]] = currentBoard[bt[0]][bt[1]];
    cpy[bt[0]][bt[1]] = temp;
    children.add(new Board(cpy, this.getGOAL(), this.getRows(), this.getColumns(), (this.getDirections() + direction + ", ")));
}

 public int getPUZZLE_SIZE() {
    return PUZZLE_SIZE;
}

public int getRows() {
    return rows;
}

public int getColumns() {
    return columns;
}

public int[][] getGOAL() {
    return GOAL;
}

public int[][] getCurrentBoard()
{
    return currentBoard;
}

public String getDirections()
{
    return directions;
}
深度优先搜索类

package npuzzle;

import java.util.ArrayList;
import java.util.Stack;

public class DFSearch {

public static void search(int[][] initial, int[][] goal, int rows, int columns)
{
    Board board = new Board(initial, goal, rows, columns, "");
    Node root = new Node(board);
    Stack<Node> stack = new Stack<Node>();

    stack.add(root);

    performSearch(stack, board);
}

 public static void performSearch(Stack<Node> s, Board board)
{
    int searchCount = 1;

    while (!s.isEmpty())
    {
        Node tNode = (Node) s.pop();

        //if not goal state
        if (!tNode.getCurrentState().isGoalState())
        {
            ArrayList<State> tChildren = tNode.getCurrentState().gChildren();

            for (int i = 0; i < tChildren.size(); i++)
            {
                Node newNode = new Node(tNode, tChildren.get(i), tNode.getGCost() + tChildren.get(i).findCost(), 0);

                if(!isRepeatedState(newNode))
                {
                    s.add(newNode);
                }
            }
            searchCount++;
        }
        else
        {                
            tNode.getCurrentState().printState();
            System.exit(0);
            //PRINTING OF DIRECTIONS
        }
    }

    System.out.println("Error! No solution found!");
}

private static boolean isRepeatedState(Node c)
{
    boolean returnVal = false;
    Node checkNode = c;

    while(c.getParent() != null && !returnVal)
    {
        if (c.getParent().getCurrentState().equals(checkNode.getCurrentState()))
        {
            returnVal = true;
        }

        c = c.getParent();
    }

    return returnVal;
}

package npuzzle;

import java.util.ArrayList;
import java.util.Arrays;

public class Board implements State
{
private int PUZZLE_SIZE = 0;
private int outOfPlace = 0;

private int rows;
private int columns;

private int[][] GOAL;

private int[][] currentBoard;

private String directions = "";

public Board(int[][] initial, int[][] goal, int N, int M, String direction)
{
    currentBoard = initial;
    GOAL = goal;

    rows = N;
    columns = M;

    PUZZLE_SIZE = rows*columns;

    directions = direction;

    setOutOfPlace();
}

@Override
public boolean isGoalState() {

    if (Arrays.deepEquals(currentBoard, GOAL))
    {
        return true;
    }

    return false;
}

@Override
public ArrayList<State> gChildren() {

    ArrayList<State> children = new ArrayList<State>();
    int[] blanktile = getBlankTile();
    int[] newblanktile = Arrays.copyOf(blanktile, blanktile.length);

    if (blanktile[0] != 0) {
        newblanktile[0]--;
        Swap(newblanktile, blanktile, children, "up");
        newblanktile =  Arrays.copyOf(blanktile, blanktile.length);
    }

    if (blanktile[1] != 0) {
        newblanktile[1]--;
        Swap(newblanktile, blanktile, children, "left");
        newblanktile =  Arrays.copyOf(blanktile, blanktile.length);
    }

    if (blanktile[0] != (this.rows - 1)) {
        newblanktile[0]++;
        Swap(newblanktile, blanktile, children, "down");
        newblanktile =  Arrays.copyOf(blanktile, blanktile.length);
    }

    if (blanktile[1] != (this.columns - 1)) {
        newblanktile[1]++;
        Swap(newblanktile, blanktile, children, "right");
        newblanktile =  Arrays.copyOf(blanktile, blanktile.length);
    }

    return children;
}

@Override
public double findCost() {
    return 1;
}

@Override
public void printState() {
    System.out.println(directions);
}

@Override
public boolean equals(State s) {

    if (Arrays.deepEquals(currentBoard, ((Board) s).getCurrentBoard()))
    {
        return true;
    }
    else
        return false;
}

private void setOutOfPlace() {

    int i = 0;
    int j = -1;

    do 
    {
        if (j == (columns - 1)) {j = 0; i++;}
        else {j++;}

        if (currentBoard[i][j] != GOAL[i][j])
        {
            outOfPlace++;
        }

    } while (((i+1)*(j+1)) < PUZZLE_SIZE);
}

private int[] getBlankTile()
{
    int i = 0;
    int j = -1;

    int[] blanktile = {0,0};

    do 
    {
        if (j == (columns - 1)) {j = 0; i++;}
        else {j++;}

        if (currentBoard[i][j] == 0) {
            blanktile[0] = i;
            blanktile[1] = j;
        }

    } while (((i+1)*(j+1)) < PUZZLE_SIZE);
    return blanktile;
}

public int getOutOfPlace()
{
    return outOfPlace;
}

private int[][] copyBoard(int[][] state)
{
    int[][] returnArray = new int[rows][columns];
    for (int i = 0, j = 0; i*j < PUZZLE_SIZE; i++, j++)
    {
        returnArray[i] = Arrays.copyOf(state[i], state[i].length);
    }
    return returnArray;
}

private void Swap(int[] nbt, int[] bt, ArrayList<State> children, String direction) {

    int[][] cpy = copyBoard(currentBoard);
    int temp = cpy[nbt[0]][nbt[1]];
    cpy[nbt[0]][nbt[1]] = currentBoard[bt[0]][bt[1]];
    cpy[bt[0]][bt[1]] = temp;
    children.add(new Board(cpy, this.getGOAL(), this.getRows(), this.getColumns(), (this.getDirections() + direction + ", ")));
}

 public int getPUZZLE_SIZE() {
    return PUZZLE_SIZE;
}

public int getRows() {
    return rows;
}

public int getColumns() {
    return columns;
}

public int[][] getGOAL() {
    return GOAL;
}

public int[][] getCurrentBoard()
{
    return currentBoard;
}

public String getDirections()
{
    return directions;
}

包npuzzle；
导入java.util.ArrayList；
导入java.util.Stack；
公共类DFSearch{
公共静态无效搜索（int[][]初始，int[][]目标，int行，int列）
{
董事会董事会=新董事会（初始、目标、行、列，“”）；
节点根=新节点（板）；
堆栈=新堆栈（）；
stack.add（root）；
性能搜索（堆栈、板）；
}
公共静态无效性能搜索（堆栈、板）
{
int searchCount=1；
而（！s.isEmpty（））
{
Node tNode=（Node）s.pop（）；
//如果不是目标状态
如果（！tNode.getCurrentState（）.isGoalState（））
{
ArrayList tChildren=tNode.getCurrentState（）.gChildren（）；
对于（int i=0；i
}

董事会级别

package npuzzle;

import java.util.ArrayList;
import java.util.Stack;

public class DFSearch {

public static void search(int[][] initial, int[][] goal, int rows, int columns)
{
    Board board = new Board(initial, goal, rows, columns, "");
    Node root = new Node(board);
    Stack<Node> stack = new Stack<Node>();

    stack.add(root);

    performSearch(stack, board);
}

 public static void performSearch(Stack<Node> s, Board board)
{
    int searchCount = 1;

    while (!s.isEmpty())
    {
        Node tNode = (Node) s.pop();

        //if not goal state
        if (!tNode.getCurrentState().isGoalState())
        {
            ArrayList<State> tChildren = tNode.getCurrentState().gChildren();

            for (int i = 0; i < tChildren.size(); i++)
            {
                Node newNode = new Node(tNode, tChildren.get(i), tNode.getGCost() + tChildren.get(i).findCost(), 0);

                if(!isRepeatedState(newNode))
                {
                    s.add(newNode);
                }
            }
            searchCount++;
        }
        else
        {                
            tNode.getCurrentState().printState();
            System.exit(0);
            //PRINTING OF DIRECTIONS
        }
    }

    System.out.println("Error! No solution found!");
}

private static boolean isRepeatedState(Node c)
{
    boolean returnVal = false;
    Node checkNode = c;

    while(c.getParent() != null && !returnVal)
    {
        if (c.getParent().getCurrentState().equals(checkNode.getCurrentState()))
        {
            returnVal = true;
        }

        c = c.getParent();
    }

    return returnVal;
}

package npuzzle;

import java.util.ArrayList;
import java.util.Arrays;

public class Board implements State
{
private int PUZZLE_SIZE = 0;
private int outOfPlace = 0;

private int rows;
private int columns;

private int[][] GOAL;

private int[][] currentBoard;

private String directions = "";

public Board(int[][] initial, int[][] goal, int N, int M, String direction)
{
    currentBoard = initial;
    GOAL = goal;

    rows = N;
    columns = M;

    PUZZLE_SIZE = rows*columns;

    directions = direction;

    setOutOfPlace();
}

@Override
public boolean isGoalState() {

    if (Arrays.deepEquals(currentBoard, GOAL))
    {
        return true;
    }

    return false;
}

@Override
public ArrayList<State> gChildren() {

    ArrayList<State> children = new ArrayList<State>();
    int[] blanktile = getBlankTile();
    int[] newblanktile = Arrays.copyOf(blanktile, blanktile.length);

    if (blanktile[0] != 0) {
        newblanktile[0]--;
        Swap(newblanktile, blanktile, children, "up");
        newblanktile =  Arrays.copyOf(blanktile, blanktile.length);
    }

    if (blanktile[1] != 0) {
        newblanktile[1]--;
        Swap(newblanktile, blanktile, children, "left");
        newblanktile =  Arrays.copyOf(blanktile, blanktile.length);
    }

    if (blanktile[0] != (this.rows - 1)) {
        newblanktile[0]++;
        Swap(newblanktile, blanktile, children, "down");
        newblanktile =  Arrays.copyOf(blanktile, blanktile.length);
    }

    if (blanktile[1] != (this.columns - 1)) {
        newblanktile[1]++;
        Swap(newblanktile, blanktile, children, "right");
        newblanktile =  Arrays.copyOf(blanktile, blanktile.length);
    }

    return children;
}

@Override
public double findCost() {
    return 1;
}

@Override
public void printState() {
    System.out.println(directions);
}

@Override
public boolean equals(State s) {

    if (Arrays.deepEquals(currentBoard, ((Board) s).getCurrentBoard()))
    {
        return true;
    }
    else
        return false;
}

private void setOutOfPlace() {

    int i = 0;
    int j = -1;

    do 
    {
        if (j == (columns - 1)) {j = 0; i++;}
        else {j++;}

        if (currentBoard[i][j] != GOAL[i][j])
        {
            outOfPlace++;
        }

    } while (((i+1)*(j+1)) < PUZZLE_SIZE);
}

private int[] getBlankTile()
{
    int i = 0;
    int j = -1;

    int[] blanktile = {0,0};

    do 
    {
        if (j == (columns - 1)) {j = 0; i++;}
        else {j++;}

        if (currentBoard[i][j] == 0) {
            blanktile[0] = i;
            blanktile[1] = j;
        }

    } while (((i+1)*(j+1)) < PUZZLE_SIZE);
    return blanktile;
}

public int getOutOfPlace()
{
    return outOfPlace;
}

private int[][] copyBoard(int[][] state)
{
    int[][] returnArray = new int[rows][columns];
    for (int i = 0, j = 0; i*j < PUZZLE_SIZE; i++, j++)
    {
        returnArray[i] = Arrays.copyOf(state[i], state[i].length);
    }
    return returnArray;
}

private void Swap(int[] nbt, int[] bt, ArrayList<State> children, String direction) {

    int[][] cpy = copyBoard(currentBoard);
    int temp = cpy[nbt[0]][nbt[1]];
    cpy[nbt[0]][nbt[1]] = currentBoard[bt[0]][bt[1]];
    cpy[bt[0]][bt[1]] = temp;
    children.add(new Board(cpy, this.getGOAL(), this.getRows(), this.getColumns(), (this.getDirections() + direction + ", ")));
}

 public int getPUZZLE_SIZE() {
    return PUZZLE_SIZE;
}

public int getRows() {
    return rows;
}

public int getColumns() {
    return columns;
}

public int[][] getGOAL() {
    return GOAL;
}

public int[][] getCurrentBoard()
{
    return currentBoard;
}

public String getDirections()
{
    return directions;
}

包npuzzle；
导入java.util.ArrayList；
导入java.util.array；
公共类委员会实施国家
{
私有整数拼图大小=0；
私有int-out-of-place=0；
私有int行；
私有int列；
私有int[][]目标；
专用int[][]电流板；
私有字符串方向=”；
公共板（int[][]初始，int[][]目标，int N，int M，字符串方向）
{
电流板=初始值；
目标=目标；
行=N；
列=M；
拼图大小=行*列；
方向=方向；
setoutof place（）；
}
@凌驾
公共布尔值isGoalState（）{
if（Arrays.deepEquals（currentBoard，GOAL））
{
返回true；
}
返回false；
}
@凌驾
公共阵列列表gChildren（）{
ArrayList子项=新的ArrayList（）；
int[]blanktile=getBlankTile（）；
int[]newblanktile=Arrays.copyOf（blanktile，blanktile.length）；
if（blanktile[0]！=0）{
新片[0]-；
交换（新片、空白片、子片，“向上”）；
newblanktile=Arrays.copyOf（blanktile，blanktile.length）；
}
如果（blanktile[1]！=0）{
纽班克瓷砖[1]-；
交换（newblanktile、blanktile、子对象，“左”）；
newblanktile=Arrays.copyOf（blanktile，blanktile.length）；
}
if（blanktile[0]！=（this.rows-1））{
新片[0]++；
交换（新片、空白片、子片，“向下”）；
newblanktile=Arrays.copyOf（blanktile，blanktile.length）；
}
if（blanktile[1]！=（this.columns-1））{
newblanktile[1]++；
交换（newblanktile、blanktile、儿童，“右”）；
newblanktile=Arrays.copyOf（blanktile，blanktile.length）；
}
返回儿童；
}
@凌驾
公共双findCost（）{
返回1；
}
@凌驾
public void printState（）{
系统输出打印（方向）；
}
@凌驾
公共布尔等于（状态s）{
if（Arrays.deepEquals（currentBoard，（（Board）s.getCurrentBoard（）））
{
返回true；
}
其他的
返回false；
}
私有void setOutof place（）{
int i=0；
int j=-1；
做
{
如果（j==（列-1））{j=0；i++；}
else{j++；}
如果（当前板[i][j]！=目标[i][j]）
{
外地++；
}
}而（（（i+1）*（j+1））