代码“有效”，但是我在优化方面遇到了问题。

算法的思想是计算从左上角开始导航n×n网格的方法的数量，始终向左，向右，向上或向下移动一个步骤，访问每个正方形。例如，当n = 3时，有8条可能的路径。

例如，使用p.count（7），任何提示/技巧，该算法将变得异常缓慢。

public class Paths {  

 static int[][] grid;
 static int n,counter;

 public int count(int n) {
 grid = new int[n][n];
 counter = 0;  
 search(0,1,n);
 return counter;       
}

 void search(int y,int x,int k,int n) {

 if (y < 0 || x < 0 || y >= n || x >= n) return;
 if (grid[y][x] != 0) return;

 if (x-1 > 0 && x+1 < n && y == n && grid[y][x-1] == 0 && grid[y][x+1] == 0) return;
 else if (x-1 > 0 && x+1 < n && y == 0 && grid[y][x-1] == 0 && grid[y][x+1] == 0) return;
 else if (y-1 > 0 && y+1 < n && x == n && grid[y-1][x] == 0 && grid[y+1][x] == 0) return;
 else if (y-1 > 0 && y+1 < n && x == 0 && grid[y-1][x] == 0 && grid[y+1][x] == 0) return;
 else if (y==n && x==n && grid[y][x-1] == 0 && grid[y-1][x] == 0) return;
 else if (y==n && x==0 && grid[y-1][x] == 0 && grid[y][x+1] == 0) return;
 else if (y==0 && x==n && grid[y+1][x] == 0 && grid[y][x-1] == 0) return;

 if (k == n*n) {
 counter++;
 return;
    }

 grid[y][x] = k;
 search(y,x-1,k+1,n);
 search(y,x+1,n);
 search(y+1,x,n);
 search(y-1,n);
 grid[y][x] = 0;
}
 }

输出：

 public static void main(String[] args) {
 Paths p = new Paths();
 System.out.println(p.count(1)); // 1
 System.out.println(p.count(2)); // 2
 System.out.println(p.count(3)); // 8
 System.out.println(p.count(4)); // 52
}
 }