0

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

好的，斯蒂芬建议使用嵌套循环

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.点[x=4,y=2] java.awt.Point[x=4,y=1]

它适用于 2 个点，但这绝对不是解决方案，因为要检查三个点，我需要嵌套 3 个循环等等。我不能只是继续嵌套更多的循环，因为我不知道那里的点将如何对齐，我需要比较 3 个或更多，还有其他想法吗？

4

2 回答 2

0

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

于 2013-08-06T04:01:11.333 回答
0

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

    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;
  }
于 2013-08-06T11:18:05.430 回答