java堆空间用完——15个谜题

Posted 2023-02-19

【中文标题】java堆空间用完——15个谜题

【英文标题】：Running out of java heap space- 15 puzzle problem

【发布时间】：2010-12-26 18:34:15

【问题描述】：

万事如意， 我尝试了here发布的八个难题的解决方案 由 joel Neely 玩弄并修改它，以便可用于解决更高的网格[将网格的字符串表示更改为二维整数表示并修改 相应的逻辑]。然而，修改后的代码可以解决 3x3 网格，但很快就会耗尽 4x4 网格的堆空间。我想这是我认为使用的算法造成的限制 分支定界的变体，而不是 java 的变体。如果我的假设是正确的，有人可以提出任何其他好的算法来解决这个问题吗？如果没有，请提示可以做些什么来制作这个程序 为高阶网格工作。

import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;

class EightPuzzle 

    //Queue<Integer[][]> agenda = new LinkedList<Integer[][]>();    // Use of Queue Implemented using LinkedList for Storing All the Nodes in BFS.
    //Map<Integer[][],Integer> stateDepth = new HashMap<Integer[][], Integer>(); // HashMap is used to ignore repeated nodes
    //Map<Integer[][],Integer[][]> stateHistory = new HashMap<Integer[][],Integer[][]>(); // relates each position to its predecessor
    Map<String,String> stateHistory = new HashMap<String,String>(); // relates each position to its predecessor
    Map<String,Integer> stateDepth = new HashMap<String,Integer>();
    Queue<Integer[][]> agenda=new LinkedList<Integer[][]>();
    final int GRIDSIZE=4;
    int row=0,col=0;
    public static void main(String args[])

       // Integer[][] str="087465132";                                 // Input the Board State as a Integer[][] with 0 as the Blank Space
        Integer init[][]=1,3,12,4,2,9,10,7,0,14,8,15,5,6,13,11;
        //Integer init[][]=0,8,7,4,6,5,1,3,2;
        EightPuzzle e = new EightPuzzle();              // New Instance of the EightPuzzle

        e.add(init,null);                                                   // Add the Initial State

        while(!e.agenda.isEmpty())
            Integer[][] currentState = e.agenda.remove();
            e.up(currentState);                                       // Move the blank space up and add new state to queue
            e.down(currentState);                                     // Move the blank space down
            e.left(currentState);                                     // Move left
            e.right(currentState);                          // Move right and remove the current node from Queue
        

        System.out.println("Solution doesn't exist");
    

    //Add method to add the new Integer[][] to the Map and Queue
    void add(Integer newState[][], Integer oldState[][])
        if(!stateDepth.containsKey(convertToString(newState)))
            int newValue = oldState == null ? 0 : stateDepth.get(convertToString(oldState)) + 1;
            stateDepth.put(convertToString(newState), newValue);
            agenda.add(newState);
            stateHistory.put(convertToString(newState), convertToString(oldState));
        
    

    /* Each of the Methods below Takes the Current State of Board as Integer[][]. Then the operation to move the blank space is done if possible.
      After that the new Integer[][] is added to the map and queue.If it is the Goal State then the Program Terminates.
     */
    void up(Integer[][] currentState)
        Integer[][] nextState=new Integer[GRIDSIZE][GRIDSIZE];
        getIndicesOfZero(currentState, nextState);
        if(row!=0)
            nextState[row-1][col]=currentState[row][col];
            nextState[row][col]=currentState[row-1][col];
            checkCompletion(currentState, nextState);
        
    

    /**
     * @param currentState
     */
    /**
     * @param currentState
     */
    void down(Integer[][] currentState)
        Integer[][] nextState=new Integer[GRIDSIZE][GRIDSIZE];
        getIndicesOfZero(currentState, nextState);
        if(row!=GRIDSIZE-1)
            nextState[row+1][col]=currentState[row][col];
            nextState[row][col]=currentState[row+1][col];  
            checkCompletion(currentState, nextState);
        
    
    void left(Integer[][] currentState)
        Integer[][] nextState=new Integer[GRIDSIZE][GRIDSIZE];
        getIndicesOfZero(currentState, nextState);
        if(col!=0)
            nextState[row][col-1]=currentState[row][col];
            nextState[row][col]=currentState[row][col-1];
            checkCompletion(currentState, nextState);
        
    
    void right(Integer[][] currentState)
        Integer[][] nextState=new Integer[GRIDSIZE][GRIDSIZE];
        getIndicesOfZero(currentState, nextState);
        if(col!=GRIDSIZE-1)
            nextState[row][col+1]=currentState[row][col];
            nextState[row][col]=currentState[row][col+1];
            checkCompletion(currentState, nextState);
        
    

    private void checkCompletion(Integer[][] oldState, Integer[][] newState) 
        add(newState, oldState);
        Integer[][] completeState=1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,0;
        //Integer[][] completeState=1,2,3,4,5,6,7,8,0;
        boolean equality=true;
        outer:for(int i=0;i<GRIDSIZE;i++)
            for(int j=0;j<GRIDSIZE;j++)
                if(newState[i][j]!=completeState[i][j])
                    equality=false;
                    break outer;
                
            
        

        if(equality)
            System.out.println("Solution Exists at Level "+stateDepth.get(convertToString(newState))+" of the tree");
            String traceState = convertToString(newState);
            while (traceState != null)    
                System.out.println(traceState + " at " + stateDepth.get(traceState));
                traceState = stateHistory.get(traceState);
            
            System.exit(0);

        
    
    String convertToString(Integer[][] a)
        String str="";
        if(a!=null)
            for(int i=0;i<GRIDSIZE;i++)
                for(int j=0;j<GRIDSIZE;j++)
                    str+=a[i][j];
                
            
        
        else
            str=null;
        
        return str;
    
    void getIndicesOfZero(Integer[][] currentState,Integer[][] nextState)
        for(int i=0;i<GRIDSIZE;i++)
            for(int j=0;j<GRIDSIZE;j++)
                nextState[i][j]=currentState[i][j];
            
        
        outer:for(int i=0;i<GRIDSIZE;i++)
            for(int j=0;j<GRIDSIZE;j++)
                if(currentState[i][j]==0)
                    row=i;
                    col=j;
                    break outer;
                
            
        

    

提前致谢， 保罗。

【参考方案1】：

您的算法缺少启发式算法。换句话说，它是在没有指导的情况下探索搜索空间。对于 15 拼图，这个空间相当大，接近 3**（解的深度）。

如果您按每个图块到其目的地的曼哈顿距离之和对队列进行排序，则可能足以使其可解。在每个步骤中，展开议程上“错误”最少的项目。

另外，你确定你选择的起始状态是可解的吗？如果你随机订购瓷砖，你只有 50-50 的机会。

最后，您可以从Integer 切换到byte 以节省内存。多少取决于 java 实现，但由于 Integer 是一个类，而 byte 是一个原始类型，所以它可能很重要。

更新

【讨论】：

我应该补充一点，使用曼哈顿距离的建议来自 wikipedia page for 15-puzzles。

...当我说字节时，我的意思是字节。

是的，算法确实会检查所有可能性，但没有解决方案的指导。我知道初始状态配置是可以解决的，因为我从网络上的一个在线谜题中获取了它。感谢您对 wiki 文章的引用和更改为 byte 的建议。如果我需要进一步的帮助，我会尝试这些并回来。感谢你的宝贵时间。保罗。

Java 中有一个 PriorityQueue 类应该很容易集成到您的代码中：***.com/questions/683041/…