Java 确定骑士卫队的方格数

我在为这项任务生成正确的输出时遇到了一些问题，不确定我做错了什么

N x N棋盘上有K个骑士，你要确定他们守卫的方格数。如果一个广场被一个 骑士或骑士只需一次移动即可到达。 编写一个程序，读取正整数N和K，然后读取骑士的K个位置，并打印 这些K骑士守卫的方格数

输入示例：

82c1e2

相应的输出：

10

输入示例：

86c1e2d4c7f7h6

相应输出：

30

当我输入第一个示例时，它工作正常，但当我输入第二个示例时，它给出了

34

package knightguard;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class KnightGuard {

    static class Position {

        int x;
        int y;

        public Position(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public boolean equals(Position p) {
            if (p.x == x && p.y == y) {
                return true;
            }
            return false;
        }

        @Override
        public String toString() {
            return x + "," + y;
        }

    }

    ArrayList<Position> knightPositions;
    int size;
    int no_of_knights;

    public KnightGuard(int size, int k, ArrayList<Position> knightPositions) {
        this.knightPositions = knightPositions;
        no_of_knights = k;
        this.size = size;
    }

    public int getSafePositions() {
        Set<Position> safePos = new HashSet<>();
        for (Position p : knightPositions) {
            if (isValid(p.x - 2, p.y - 1)) {
                safePos.add(new Position(p.x - 2, p.y - 1));
            }
            if (isValid(p.x - 2, p.y + 1)) {
                safePos.add(new Position(p.x - 2, p.y + 1));
            }
            if (isValid(p.x + 2, p.y - 1)) {
                safePos.add(new Position(p.x + 2, p.y - 1));
            }
            if (isValid(p.x + 2, p.y + 1)) {
                safePos.add(new Position(p.x + 2, p.y + 1));
            }

            if (isValid(p.x - 1, p.y - 2)) {
                safePos.add(new Position(p.x - 1, p.y - 2));
            }
            if (isValid(p.x - 1, p.y + 2)) {
                safePos.add(new Position(p.x - 1, p.y + 2));
            }
            if (isValid(p.x + 1, p.y - 2)) {
                safePos.add(new Position(p.x + 1, p.y - 2));
            }
            if (isValid(p.x + 1, p.y + 2)) {
                safePos.add(new Position(p.x + 1, p.y + 2));
            }
        }

        return safePos.size();
    }

    private boolean isValid(int x, int y) {
        if (x < 0 || x >= size || y < 0 || y >= size) {
            return false;
        }

        if (knightPositions.contains(new Position(x, y))) {
            return false;
        }

        return true;
    }

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int size = s.nextInt();
        int knights = s.nextInt();
        ArrayList<Position> knightPos = new ArrayList<>();
        for (int i = 0; i < knights; i++) {
            int x = s.next().charAt(0) - 'a';
            int y = s.nextInt() - 1;
            knightPos.add(new Position(x, y));
        }

        KnightGuard knightGuard = new KnightGuard(size, knights, knightPos);
        System.out.println(knightGuard.getSafePositions());

        s.close();

    }

}

套装骑士卫队；
导入java.util.ArrayList；
导入java.util.HashSet；
导入java.util.Scanner；
导入java.util.Set；
公共级骑士卫队{
静态类位置{
int x；
int-y；
公共位置（整数x，整数y）{
这个.x=x；
这个。y=y；
}
公共布尔等于（位置p）{
如果（p.x==x&&p.y==y）{
返回true；
}
返回false；
}
@凌驾
公共字符串toString（）{
返回x+“，”+y；
}
}
ArrayList骑士职位；
整数大小；
int no_骑士；
公共骑士卫队（内部尺寸、内部k、阵列列表骑士职位）{
this.knightPositions=knightPositions；
无骑士=k；
这个。大小=大小；
}
public int getSafePositions（）{
Set safePos=新的HashSet（）；
对于（职位p：骑士职位）{
如果（有效（p.x-2，p.y-1））{
安全位置添加（新位置（p.x-2，p.y-1））；
}
如果（有效（p.x-2，p.y+1））{
安全位置添加（新位置（p.x-2，p.y+1））；
}
如果（有效（p.x+2，p.y-1））{
安全位置添加（新位置（p.x+2，p.y-1））；
}
如果（有效（p.x+2，p.y+1））{
安全位置添加（新位置（p.x+2，p.y+1））；
}
如果（有效（p.x-1，p.y-2））{
安全位置添加（新位置（p.x-1，p.y-2））；
}
如果（有效（p.x-1，p.y+2））{
安全位置添加（新位置（p.x-1，p.y+2））；
}
如果（有效（p.x+1，p.y-2））{
安全位置添加（新位置（p.x+1，p.y-2））；
}
如果（有效（p.x+1，p.y+2））{
安全位置添加（新位置（p.x+1，p.y+2））；
}
}
返回safePos.size（）；
}
私有布尔值有效（整数x，整数y）{
如果（x<0 | | x>=大小| | y<0 | | y>=大小）{
返回false；
}
if（骑士位置包含（新位置（x，y）））{
返回false；
}
返回true；
}
公共静态void main（字符串[]args）{
扫描仪s=新的扫描仪（System.in）；
int size=s.nextInt（）；
int骑士=s.nextInt（）；
ArrayList knightPos=新的ArrayList（）；
对于（int i=0；i

使用这种方法的一个问题是，可能会为不同的骑士生成重复的位置。例子；根据立柱上的图片，D4和H6位置的两名骑士都可以移动到F5的广场上。因此，发布的代码将对此位置计数两次。理论上，可能有八（8）名骑士在八个不同的位置，所有人都可以移动到同一个广场。必须进行检查以消除这些可能的“重复”位置

我对

KnightGuard

类和

getSafePositions

方法有点困惑。

KnightGuard

类有一个位置列表，这是给定骑士的位置列表。然而

getSafePositions

方法只是返回所有骑士可以移动的不同移动次数此方法不考虑前一位骑士也可以移动到第一段中描述的相同位置

为了简化事情…我觉得一个名为

Knight

的类会是一个更好的方法。Knight会有一个

Position

变量来指示“THIS”的位置骑士位于棋盘上。此外，

knight

类将包含

Position

对象的

ArrayList

，以指示该骑士在给定位置下可以进行的所有可能移动。

knight

不应该知道任何其他

knight

以及可以移动到的位置列表它可以移动到的所有位置，无论该位置是否有其他工件。该列表至少包含两（2）个位置，最多包含八（8）个不同位置

创建新的

Knight

对象时，实例化后会自动生成可能移动的列表以及它在板上的位置，稍后我们将需要这些位置

下面是这个

Knight

类的一个例子。应该注意的是，在这个类和main方法中，我将电路板的索引改为从1（a）开始，而不是从零（0）开始在左边和右边移动，也在y索引上，底部的y索引为1并向上移动。此外，还创建了一个

SetValidMoves

方法，以允许更改此骑士可以移动的位置列表。在

public class Knight {

  Position knightPosition;
  ArrayList<Position> validMoves;
  int boardSize;

  public Knight(Position position, int inBoardSize) {
    knightPosition = position;
    validMoves = new ArrayList<Position>();
    boardSize = inBoardSize;
    SetValidMoves();
  }

  public Position GetKnightPosition() {
    return knightPosition;
  }

  public ArrayList<Position> GetValidMoves() {
    return validMoves;
  }
  public void SetValidMoves(ArrayList<Position> newMoves) {
    validMoves = newMoves;
  }

  private void SetValidMoves() {
    int thisX = knightPosition.x;
    int thisY = knightPosition.y;
    // check for bottom moves 2 down 1 left - right
    if (thisY - 2 >= 1) { 
      if (thisX + 1 <= boardSize) { 
        validMoves.add(new Position(thisX + 1, thisY - 2));
      }
      if (thisX - 1 >= 1) { 
        validMoves.add(new Position(thisX - 1, thisY - 2));
      }
    }
    // check for bottom moves 1 down 2 left - right
    if (thisY - 1 >= 1) { 
      if (thisX + 2 <= boardSize) { 
        validMoves.add(new Position(thisX + 2, thisY - 1));
      }
      if (thisX - 2 >= 1) { 
        validMoves.add(new Position(thisX - 2, thisY - 1));
      }
    }
    // check for top moves 2 up 1 left - right
    if (thisY + 2 <= boardSize) { 
      if (thisX + 1 <= boardSize) { 
        validMoves.add(new Position(thisX + 1, thisY + 2));
      }
      if (thisX - 1 >= 1) { 
        validMoves.add(new Position(thisX - 1, thisY + 2));
      }
    }
    // check for top moves 1 up 2 left - right
    if (thisY + 1 <= boardSize) { 
      if (thisX + 2 <= boardSize) { 
        validMoves.add(new Position(thisX + 2, thisY + 1));
      }
      if (thisX - 2 >= 1) { 
        validMoves.add(new Position(thisX - 2, thisY + 1));
      }
    }
  }
}

private static ArrayList<Position> GetAllDifferentPositions() {
  ArrayList<Position> validMoves = new ArrayList<Position>();
  for (Knight curKnight : knightsOnBoard) {
    for (Position curPos : curKnight.validMoves) {
      if (!validMoves.contains(curPos)) {
        validMoves.add(curPos);
      }
    }
  }
  return validMoves;
}

@Override
public boolean equals(Object obj) {
  if (obj instanceof Position) {
    Position other = (Position)obj;
    if (this.x == other.x && this.y == other.y)
      return true;
   }
   return false;
}

private static void RemoveAllKnightPositions(ArrayList<Position> allPositions) {
  for (Knight curKnight : knightsOnBoard) {
    if (allPositions.contains(curKnight.knightPosition)) {
      allPositions.remove(curKnight.knightPosition);
    }
  }
}

static ArrayList<Knight> knightsOnBoard = new ArrayList<Knight>();

public static void main(String[] args) {
  Scanner s = new Scanner(System.in);
  int boardSize = s.nextInt();
  int knights = s.nextInt();
  for (int i = 0; i < knights; i++) {
      int x = (s.next().charAt(0) - 'a') + 1;
      int y = s.nextInt();
      Knight newKnight = new Knight(new Position(x,y), boardSize);
      knightsOnBoard.add(newKnight);
      System.out.println("Knight at : " + newKnight.knightPosition.x + " " +  newKnight.knightPosition.y);
   }

  ArrayList<Position> finalResults = GetAllDifferentPositions();
  RemoveAllKnightPositions(finalResults);
  System.out.println("Positions: " + (finalResults.size() + knightsOnBoard.size()));
  s.close();  
}