现在我正在使用递归回溯,我的任务是找到迷宫中最长的路径,质量表示为用坐标覆盖的字段,并且墙壁的坐标在文件中是酸痛的.
我已经制作了一个解析器来解析输入文件并构建墙,但我也将这个坐标存储在一个对象类型Coordinate的数组中,以检查是否有可能在下一个“蛇”上移动下一个“蛇”字段,然后我创建了这个方法,现在我已经明白我需要一个方法来从数组中删除最后一个坐标,当我使用回溯时,我该怎么办？目标不是使用数组列表或链表只有数组！
谢谢！
public class Coordinate {
int xCoord;
int yCoord;
Coordinate(int x,int y) {
this.xCoord=x;
this.yCoord=y;
}
public int getX() {
return this.xCoord;
}
public int getY() {
return this.yCoord;
}
public String toString() {
return this.xCoord + "," + this.yCoord;
}
}
和
public class Row {
static final int MAX_NUMBER_OF_COORD=1000;
Coordinate[] coordArray;
int numberOfElements;
Row(){
coordArray = new Coordinate[MAX_NUMBER_OF_COORD];
numberOfElements=0;
}
void add(Coordinate toAdd) {
coordArray[numberOfElements]=toAdd;
numberOfElements +=1;
}
boolean ifPossible(Coordinate c1){
for(int i=0;i
if(coordArray[i].xCoord==c1.xCoord && coordArray[i].yCoord==c1.yCoord){
return false;
}
}
return true;
}
}

方向数组
方向数组常应用于搜索算法中，在c/c++中可以用二维数组来表示方向。例如二维数组a[k][n]含义就是方向数组里面储存了k个向量，而n则代表每个向量有n维（n一般为2）。下面我们由下图来讲解方向数组如何控制方向。

上图是（x,y）这个点八个方向的坐标，在c/c++中x和y并不是我们数学中的坐标系而是数组的行数（x对应行数）和列数（y对应列数）。
例题

解析
由本题题意可知我们要求这一堆数字中连续四个数字（不同方向）相乘最大值，我们就以图中标红的第一个数字26为例，可以看出26为起点一共有八个方向（上下，左右，右上左下，左上右下），但我们仔细观察可以发现我们从14这个数字观察它的左上方向和26数字的右下方向数字乘积一样，所以我们最后总结以26为起始的数字方向共有四个方向（下，右，右下，左下）
代码编写
#include <stdio.h>
#define max_n 20

int grid[max_n + 5][max_n + 5];
int dir[4][2] = {{0, 1}, {1, 1}, {1, 0}, {1, -1}};/*定义方向数组*/
int  calc(int x, int y) {
      int ans = 1;
    for(int i = 0; i < 4; i++) {
        int p = 1;
        for(int j = 0; j < 4; j++) {
            int dx = x + j * dir[i][0];
            int dy = y + j * dir[i][1];
            if(dx < 0 || dx >= 20) break;
            if(dy < 0 || dy >= 20) break;
            p  *=  grid[dx][dy];
        }
        if(p > ans) ans = p;
    }
    return ans;
}

int main() {
    for(int i = 0; i < max_n; i++) {
        for(int j =  0; j < max_n; j++) {
            scanf("%d", &grid[i][j]);    /*读入数据*/
        }
    }
    int ans;
    for(int i = 0; i < max_n; i++) {
        for(int j = 0; j < max_n; j++) {
            int p = calc(i, j);
            if(p > ans) ans = p;
        }
    }
    printf("%d",ans);
}

在研究numpy的时候发现数组是一个很抽象的概念，毕竟远离数学多年，其转置和换轴更是不知所谓了。所以花了一些时间通过画图搞清楚了一些东西。
数组在三维空间的表示方法
两轴数组
arr2 = numpy.arange(8).reshape(2, 4)
#结果
array([[0, 1, 2, 3],
       [4, 5, 6, 7]])

在坐标轴上表示应该为：



如果用transpose转置 或者用swapaxes换轴
arr2.transpose((1, 0))
arr2.swapaxes(1, 0)
#结果 array([[0, 4],
       [1, 5],
       [2, 6],
       [3, 7]])

坐标中表示为



实质为将原0轴方向的每组数据，变换成横轴表示，也就是说横纵轴进行了互换。如果不太理解可以看轴箭头方向的数值个数。例如：右图中的0轴沿着箭头方向仍然是4个数值，即为原来的左图的1轴。或者你可以自己画一下转换一下查看的方向，一目了然。
这里要说明一下transpose和swapaxes参数不同，transpose要将所有的轴都列出来，哪两个轴互换就把轴索引换一下，

例如：三维数组里0，1轴互换或者0,2轴互换应该写成：
transpose((1,0,2))
transpose((2,1,0)) 

如果用swapaxes应该写成：
swapaxes(1,0)
swapaxes(2,0)

三轴数组
那么如果是三轴的数组又该怎么理解呢
arr1 = arr1.reshape(2, 2, 4)
#结果
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7]],

       [[ 8,  9, 10, 11],
        [12, 13, 14, 15]]])
arr1.ndim#轴数
#结果3

画图表示为



这里的轴的编号已经通过程序测试过，通过图中可以看到，是两个两轴的数组通过0轴建立了关系，在这张图中0轴是固定轴，即只有一个0轴，1,2轴可以有多个，也就是说如果再有1维数据或者多维，只需要在0轴上再多画上1,2轴在平面上写上数组的数值就可以了。
接下来就要进行转置和换轴操作了，

我们先从简单的来

1 2轴的互换，这个很好理解，1，2轴在一个平面，如果互换跟上面的两轴数组是一个道理。
arr1.transpose((0, 2 ,1))
#或者
arr1.swapaxes(2,1)
#结果
array([[[ 0,  4],
        [ 1,  5],
        [ 2,  6],
        [ 3,  7]],

       [[ 8, 12],
        [ 9, 13],
        [10, 14],
        [11, 15]]])



是不是跟两轴的数组一样呢？因为1,2轴在同一个平面，只需要各回各家各找各妈自己的1，跟自己的2 换就可以了。
下面就稍微一丢丢的需要理解了，当然我能明白的，你们肯定能，因为我笨，而且，还是文科生。

这回咱们来换0 和1轴

还记得上面说的固定轴吗，0原本是固定轴，1轴和2轴都是可以有多个的，我们叫他活动轴。现在互换也就是让1变成固定轴，0变成和2一样的活动轴。即转置或换轴后，原1轴只有一个，原0和2可以有多个轴。
arr1.transpose((1, 0 ,2))
或者
arr1.swapaxes(1,0)
#结果
array([[[ 0,  1,  2,  3],
        [ 8,  9, 10, 11]],

       [[ 4,  5,  6,  7],
        [12, 13, 14, 15]]])



这张图我用原数组在图中的结构做了辅助线作为解释，轴号都是原数组的轴号，

红虚线标出的1号轴可当不存在，0号轴变成了活动轴可以有多个，所以2号轴要配合0号轴做一条新的2号轴（2号轴也可以有多个不违反规则），这样就组成了上下两个平面，每个平面上的数值就是数组的结果。
下面我们再来转置或换轴一下0和2号轴
arr1.transpose((2, 1, 0))
或者
arr1.swapaxes(2, 0)
#结果
array([[[ 0,  8],
        [ 4, 12]],

       [[ 1,  9],
        [ 5, 13]],

       [[ 2, 10],
        [ 6, 14]],

       [[ 3, 11],
        [ 7, 15]]])



这里还是用原数组图来说明问题，这个大家对电脑都很熟悉，机箱里你的交火显卡不就是这么排列的咩，每个平面上的4个数值就成了一组。2轴成为了固定轴，1和0轴成为了活动轴，可以有多个。

因此，如果跟0轴进行转置和换轴，实质为固定轴和活动轴的交换，而，1和2轴的转置和换轴，其实为两轴数组的交换。
图画的很烂，望见谅，如果有任何错误，请指正，不胜感激。

//这道题目刚开始根本就没有想到用树状数组来做
//我们知道树状数组提高了求和和修改的效率S[n]=A[1]+A[2]+...+A[n],而根据这个题目的题意，
//y坐标是递增的，我们只需要考虑x坐标，即求给点x坐标之前<=x的元素个数，关键是我们如何 
//确定A数组，A数组表示什么意思，这里A数组的意思是：A[i]表示i元素出现的次数，对于给定样例就是
//A[1]=1,A[3]=1,A[5]=2,A[7]=1(这是统计到最后的结果) 

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAXN 32005

int n,i,x,y;
int c[32005];
int level[32005];

int lowbit(int x){
    return x&(-x);
}

int sum(int n){
    int sum=0;
    while(n>0){
        sum+=c[n];
        n=n-lowbit(n);
    }
    return sum;
}
//修改n元素 
void update(int n){
    while(n<MAXN){
        c[n]++;
        n=n+lowbit(n);
    }
}

int main(){
    while(scanf("%d",&n)!=EOF){
        memset(level,0,sizeof(level));
        memset(c,0,sizeof(c));
        for(i=0;i<n;i++){
            scanf("%d%d",&x,&y);
            ++x;//关键，数组数组从1开始 
            level[sum(x)]++;
            update(x);
        }
        for(i=0;i<n;i++)
            printf("%d\n",level[i]);
    }
    return 0;
}