Question

所以我对Java相对较新（我目前正在我的学校学习AP java）并且我正在尝试开发一种递归算法来解决n * n板，我觉得我非常接近但还没到那里。我写了一切来遍历我的字典，以查找我发送的字母是否是单词等。我的算法是在我的数组中将起始字母设为（n，p），将这些坐标发送到另一个方法，该方法将在每个方向上找到所有可能的组合。一旦找到所有以（n，p）开头的组合，我会增加p直到它到达行的末尾，然后我将增加n并再次从0开始p。（我只通过一半的字母，因为组合是相同的向后和向前）

我遇到麻烦的部分是递归序列，因为一旦我越过板上的某个位置，我想标记它以确保我再也没有为序列的其余部分重复它。它没有完全工作，我想知道是否有人可以告诉我为什么/帮我写一个更好的算法。提前致谢

public void AllLetters(int n, int p, int x, int y,String word, String MyLetteres[][]){
    int temp=0;
    int StartLetter =(int)(Math.pow(MyLetteres.length,2));
    while(temp<StartLetter)//runs through every letter
    {   
        if(temp==0)
            getPaths(p, n,x,y,word, MyLetteres);
        else if(temp%(MyLetteres.length-1)==temp){
            getPaths(p, n+1,x,y,word, MyLetteres);
        }
        else {
            getPaths(p+1, 0,x,y,word, MyLetteres);
        }
        if(temp==(StartLetter/2-1)){
            temp=StartLetter;
        }
        temp++;
    }

}


public void getPaths(int p, int n, int x, int y,String word, String MyLetteres[][]){
    if( x ==p-1 && y == n-1){//reach the (n,p) point
    System.out.print("");
    }else if( x >= MyLetteres.length || y >= MyLetteres.length||x < 0 || y < 0){//out of bounds
    return;
    }else {
        if(x+1<MyLetteres.length&&!MyLetteres[x+1][y].equals("0")){//up{
            word=word+""+MyLetteres[x+1][y];
            Check(word);//function that checks if it is a word
            reverse(word);//checks its a word backwards (for efficenicy)
            MyLetteres[x+1][y]="0";//marking that I've used this position
            System.out.print("1");//debugging purposes
            getPaths(n,p, x +1, y,word , MyLetteres);
        }
        if(x-1>0&&!MyLetteres[x-1][y].equals("0")){//down
            word=word+""+MyLetteres[x-1][y];
            Check(word);
            reverse(word);
            MyLetteres[x-1][y]="0";
            System.out.print("2");
            getPaths(n,p, x -1, y ,word, MyLetteres);
        }
        if(y+1<MyLetteres.length&&!MyLetteres[x][y+1].equals("0")){//right
            word=word+""+MyLetteres[x][y+1];
            Check(word);
            reverse(word);
            MyLetteres[x][y+1]="0";
            System.out.print("3");
            getPaths(n, p,x , y +1,word, MyLetteres);
        }
        if(y-1>0&&!MyLetteres[x][y-1].equals("0")){//left
            word=word+""+MyLetteres[x][y-1];
            Check(word);
            reverse(word);
            MyLetteres[x][y-1]="0";
            System.out.print("4");
            getPaths(n,p, x , y -1,word, MyLetteres);
        }
        if(x+1<MyLetteres.length&&y+1<MyLetteres.length&&!MyLetteres[x+1][y+1].equals("0")){//right, up
            word=word+""+MyLetteres[x+1][y+1];
            Check(word);
            reverse(word);
            MyLetteres[x+1][y+1]="0";
            System.out.print("5");
            getPaths(n,p, x +1, y +1,word, MyLetteres);
        }
        if(x-1>0&&y-1>0&&!MyLetteres[x-1][y-1].equals("0")){//down, left
            word=word+""+MyLetteres[x-1][y-1];
            Check(word);
            reverse(word);
            MyLetteres[x-1][y-1]="0";
            System.out.print("6");
            getPaths(n,p, x-1 , y -1,word, MyLetteres);
        }
        if(x-1>0&&y+1<MyLetteres.length&&!MyLetteres[x-1][y+1].equals("0")){//down, right
            word=word+""+MyLetteres[x-1][y+1];
            Check(word);
            reverse(word);
            MyLetteres[x-1][y+1]="0";
            System.out.print("7");
            getPaths(n,p, x+1, y-1, word,MyLetteres);
        }
        if(x+1<MyLetteres.length&&y-1>0&&!MyLetteres[x+1][y-1].equals("0")){//up, left
            word=word+""+MyLetteres[x+1][y-1];
            Check(word);
            reverse(word);
            MyLetteres[x+1][y-1]="0";
            System.out.print("8");
            getPaths(n, p,x-1 , y +1, word,MyLetteres);
        }
    }
}

Answer 1

将0写入MyLetteres以防止递归循环回自身。但是一旦递归调用返回，您需要恢复该位置的原始字母。否则，搜索只能在它尝试的所有分支上查看每个位置一次。

（另外，您可以通过循环遍历（x，y）偏移列表而不是为每个偏移量分别设置if语句来简化代码。

修改

int[][] offsets = { {-1, -1}, {0, -1}, {1, -1}, {-1, 0}, {1, 0}, {-1, 1}, {0, 1}, {1, 1} }; for(int[] off : offsets) { nx = x + off[0]; ny = y + off[1]; if(nx < 0 || ny < 0 || nx >= MyLetteres.length || ny >= MyLetteres[nx].length) { continue; } String letter = MyLetteres[nx][ny]; if(letter.equals("0")) { continue; } MyLetteres[nx][ny] = "0"; Check(word + letter); reverse(word + letter); getPaths(n,p, nx, ny, word + letter, MyLetteres); MyLetteres[nx][ny] = letter; }

麻烦我的算法来解决一个boggle板

1 个答案: