Question

我正在做一个练习，其中我将这些点与（x，y）存储在一个集合中，并且我将这些集合存储在HashMap中，其点类型为关键HashMap<String,Set<Point>>. 现在我要做的是比较一组中的点，找到3个或更多垂直或水平对齐并且彼此相邻的点。因此，如果点A（2,3），点B（2,4）和点C（2,5）将满足这一点。我想把这些通过测试的点放在另一个列表中。任何想法如何做到这一点？任何帮助表示赞赏

好好继续使用嵌套循环Stephen建议

for(Map.Entry<String,ArrayList<Point>> e : grid.entrySet()){
   if (e.getValue().size() > 3){
   for(Point p1 : e.getValue()){
      for(Point p2 : e.getValue()){
         if (neighborCheck(p1,p2) == true){
            System.out.println(p1 + " " + p2);
         }
      }
   }
}

public boolean neighborCheck (Point p1, Point p2){
        boolean neighbor = false;
        if((p1.getX()==p2.getX()+1 && p1.getY()==p2.getY()) || 
           (p1.getX()==p2.getX()-1 && p1.getY()==p2.getY()) ||
           (p1.getX()==p2.getX() && p1.getY()==p2.getY()+1) ||
           (p1.getX()==p2.getX() && p1.getY()==p2.getY()-1)) {
            neighbor = true;
        }
        return neighbor;
    }

输出：

java.awt.Point [x = 3，y = 4] java.awt.Point [x = 4，y = 4] java.awt.Point [x = 4，y = 4] java.awt.Point [x = 3，y = 4] java.awt.Point [x = 0，y = 4] java.awt.Point [x = 1，y = 4] java.awt.Point [x = 1，y = 4] java.awt.Point [x = 0，y = 4] java.awt.Point [x = 3，y = 2] java.awt.Point [x = 4，y = 2] java.awt.Point [x = 4，y = 1] java.awt.Point [x = 4，y = 2] java.awt.Point [x = 4，y = 2] java.awt.Point [x = 3，y = 2] java.awt.Point [x = 4，y = 2] java.awt.Point [x = 4，y = 1]

它适用于2分，但这肯定不是解决方案，因为检查三个点我需要嵌套3个循环，依此类推。我不能继续嵌套更多的循环，因为我不知道有什么点可以对齐，我需要比较3个或更多，任何其他的想法？

Answer 1

遍历hashmap。取一个集合，通过创建另一个到hashmap的迭代器，将其（x，y）与其他每个集合进行比较。如果您的条件满足，只需将其存储在另一个列表中。

Answer 2

这可以通过以下方式完成：

    Map<String, Set<Point>> mapSets = new HashMap<String, Set<Point>>();
    Set<Point> p1 = new HashSet<Point>();
    p1.add(new Point(2, 3));
    p1.add(new Point(2, 4));
    p1.add(new Point(2, 5));
    p1.add(new Point(3, 1));
    p1.add(new Point(4, 1));
    p1.add(new Point(5, 1));

    mapSets.put("p1", p1);

    Map<Double, List<Point>> horMap = new HashMap<Double, List<Point>>();
    Map<Double, List<Point>> verMap = new HashMap<Double, List<Point>>();

    for ( Point p : p1 )
    {
      List<Point> presList = horMap.get(p.getX());
      if ( presList == null )
      {
        presList = new ArrayList<Point>();
        presList.add(p);
      }
      else
      {
        presList.add(p);
      }
      horMap.put(p.getX(), presList);
    }

    for ( Point p : p1 )
    {
      List<Point> presList = verMap.get(p.getY());
      if ( presList == null )
      {
        presList = new ArrayList<Point>();
        presList.add(p);
      }
      else
      {
        presList.add(p);
      }
      verMap.put(p.getY(), presList);
    }

    // boolean hNe = checkHorNeighbor(horMap);
    // boolean vNe = checkVerNeighbor(verMap);

    for ( Entry<Double, List<Point>> point : horMap.entrySet() )
    {
      if ( point.getValue().size() >= 3 )
      {
        Collections.sort(point.getValue(), new Comparator<Point>()
        {
          @Override
          public int compare(Point o1, Point o2)
          {
            return Double.valueOf(o1.getY()).compareTo(Double.valueOf(o2.getY()));
          }
        });

        int count = 0;
        for ( int i = 0; i < point.getValue().size(); i++ )
        {
          if ( point.getValue().get(i).getY() + 1 == point.getValue().get(i +
                                                                          1).getY() )
          {
            count++;
          }
          if ( count >= 2 )
          {
            System.out.println("Found horizontal pair");
            count = 0;
            break;
          }
        }

      }
    }
  }

获得垂直直线可能有类似的运行。

另一种方法是执行以下操作。它应该更快更干净。

private static boolean checkVerNeighbor(Map<Double, List<Point>> verMap)
  {

    for ( List<Point> ps : verMap.values() )
    {
      NavigableSet<Point> sortedSet = new TreeSet<Point>(new Comparator<Point>()
      {
        @Override
        public int compare(Point o1, Point o2)
        {
          return Double.valueOf(o1.getX()).compareTo(Double.valueOf(o2.getX()));
        }
      });

      sortedSet.addAll(ps);

      for ( Point p : sortedSet )
      {
        Set<Point> triplets = sortedSet.subSet(p, true,
                                               new Point(Double.valueOf(p.getX() + 2).intValue(), Double.valueOf(p.getY())
                                                                                                        .intValue()), true);
        if ( triplets.size() >= 3 )
        {
          System.out.println("Found Triplets + " + p);
          return true;

        }
      }
    }
    return false;
  }

如何比较一组中的Point对象？

2 个答案: