-3

我有一个家庭作业，我完全卡住了（级别：初学者）。

我必须创建一个方法来找到距用户条目和数组中所有点最近的 3 个距离 - 我被困在这里。

方法是：public static int[] troisPlusProches(int x, int y, int[] coordonneesHabitations) 其中int x和int y是用户条目，数组int[] coordonneesHabitations是int[] coordonneesHabitations = {9, 30, 18、8、3、18、25、36}。所以点是（9,30），（18,8），（3,18）和（25,36）。

我使用公式：distance = Math.sqrt(((x1 - x2) * (x1 - x2)) + ((y1 - y2) * (y1 - y2))) 来计算距离。

现在我必须从用户条目中找到 3 个最短距离，并将它们的位置返回到一个新数组中。

因此，如果用户条目是 x=10，则 y=15。

最短的距离是距点 (3, 18) 的 7.616，下一个是距点 (18, 8) 的 10.630，第三个是距点 (9, 30) 的 15.033。在这种情况下，该方法应返回一个数组 int[] troisPlusProches = {3, 18, 18, 8, 9, 30}。

我知道我必须做什么，我只是不知道如何...

这是许多错误尝试之一：

public static int[] troisPlusProches (int x, int y, int[] (coordonneesHabitations) 
{
    int [] that = Arrays.copyOf(coordonneesHabitations, coordonneesHabitations.length);
    int table[] = new int[6];
    double distanceA = 0.0; 
    double minDistance = Float.MAX_VALUE;
    int a = 0;
    int b = 0;
    int i = 0;
    double ignore = Float.MAX_VALUE;
    double ignore2 = Float.MAX_VALUE;

    for (i = 0; i < that.length; i += 2) {
           a = that[i];
           b = that[i+1]; 
           distanceA = calculerDistance(a, b, x, y);
           if (distanceA < minDistance) { 
               minDistance = distanceA;
               table[0] = a;
               table[1] = b;
           }
       }
    ignore = minDistance;


    for (i = 0; i < that.length; i += 2) {
           a = that[i];
           b = that[i+1]; 
           distanceA = calculerDistance(a, b, x, y);
           if (distanceA == ignore) {
               continue; 
               }
           if (distanceA < minDistance) { 
               minDistance = distanceA;
               table[2] = a;
               table[3] = b;
               } 
           }
    ignore2 = minDistance;

    for (i = 0; i < that.length; i += 2) {
           a = that[i];
           b = that[i+1]; 
           distanceA = calculerDistance(a, b, x, y);
           if ((distanceA == ignore) || (distanceA == ignore2)) {
               continue; 
               }
           if (distanceA < minDistance) { 
               minDistance = distanceA;
               table[2] = a;
               table[3] = b;
               } 
           }

    return table; 
    }
4

2 回答 2

1

我不会说法语，所以我发现很难阅读您的代码。但是，请这样考虑：

Tou 有一种方法可以计算到用户条目的最近点。现在您需要创建该方法的副本，它允许您计算到用户条目的最近点，不包括您已经找到的点。这将使您找到第一个和第二个最近点。然后做同样的事情来找到第三个点，这次排除你已经找到的两个点。

您可以复制现有方法。它可能看起来像这样：

public static int plusProche (int x, int y, int[] coordonneesHabitations, int ignoreIndex) {
    double distanceA = 0.0; 
    int k = x;
    int z = y;
    int a = 0;
    int b = 0;
    int [] that = Arrays.copyOf(coordonneesHabitations, coordonneesHabitations.length); 
    int taille = that.length;
    int i = 0;
    double minDistance = Float.MAX_VALUE;
    int position = 0;

       for (i = 0; i < taille; i += 2) {

           //here we add the ability to skip the passed index
           if ((i / 2) == ignoreIndex) {
               continue;
           }

           a = that[i];
           b = that[i+1]; 
           distanceA = calculerDistance(a, b, k, z);
           if (distanceA < minDistance) { 
               minDistance = distanceA;
               position = i/2;
               System.out.println(i + " " + minDistance);
           }
       }
       return position;
}

通过将最近点的索引作为参数传递，您可以使用上述方法找到第二个最近点。它将跳过该索引，因此找到下一个最接近的索引。做类似的事情来找到第三个最近的点。

于 2016-10-19T20:21:39.273 回答
0

有一个可行的解决方案，以防有人可能需要它......

public static int[] troisPlusProches (int x, int y, int[] coordonneesHabitations) 
{
    LinkedList<Integer> resultArray = new LinkedList<Integer>();
    int[] origArr = Arrays.copyOf(coordonneesHabitations, coordonneesHabitations.length);
    while (resultArray.size() < 6) {
        int positionInArray = Decharge.plusProche(x, y, origArr);
        LinkedList<Integer> newArr = new LinkedList<Integer>();
        for (int i = 0; i < origArr.length; i = i + 2) {
            if (i != positionInArray * 2) {
                newArr.add(origArr[i]);
                newArr.add(origArr[i + 1]);
            } else {
                resultArray.add(origArr[i]);
                resultArray.add(origArr[i + 1]);
            }
        }
        origArr = new int[newArr.size()];
        for (int k = 0; k < origArr.length; k++) {
            origArr[k] = newArr.get(k);
        }
    }
    int[] intResultArray = new int[resultArray.size()];
    for (int l = 0; l < intResultArray.length; l++) {
        intResultArray[l] = resultArray.get(l);
    }
    return intResultArray;
于 2016-10-20T18:39:26.063 回答