Question

我有一个方法可以计算数组包含的3个元素的总数，它们等于0。我需要帮助找到在循环中停止计算相同的三元组的方式。例如，1 + 3 - 4 = 0，但也是3 - 4 +1 = 0.这是方法：

private static int counter(int A[])
    {   
         int sum;
         int e = A.length;
         int count = 0;
         for (int i=0; i<e; i++)
         {
             for (int j=i+1; j<e; j++)
             {
                 sum=A[i]+A[j];
                 if(binarySearch(A,sum))
                 {
                      count++;
                 }
             }  
         }
         return count;

编辑：我必须使用二进制搜索（数组已排序）。这是binarySearch代码：

   private static boolean binarySearch(int A[],int y)
    {   
        y=-y;
        int max = A.length-1;
        int min = 0;
        int mid;
        while (max>=min)
        {      
            mid = (max+min)/2;
            if (y==A[mid])
            {
                return true;
            }   
            if (y<A[mid]) 
            {
                max=mid-1;
            }
            else
            {
                min=mid+1;
            }
        }
        return false;

Answer 1

您可以通过假设我们需要使用x < y < z和A[x] + A[y] + A[z] == 0来查找三元组（x，y，z）来避免计算不同的三元组。

所以你需要做的是修改binarySearch函数以返回大于y的索引数并且具有A [z] == - （A [x] + A [y]）

private static int binarySearch(int A[],int y, int index)
    {   
        y=-y;
        int max = A.length-1;
        int min = index + 1;
        int mid;
        int start = A.length;
        int end = 0;
        while (max>=min)
        {      
            mid = (max+min)/2;
            if (y==A[mid])
            {
                start = Math.min(start, mid);
                max = mid - 1;
            } else  
            if (y<A[mid]) 
            {
                max=mid-1;
            }
            else
            {
                min=mid+1;
            }
        }
        int max = A.length - 1;
        int min = index + 1;
        while (max>=min)
        {      
            mid = (max+min)/2;
            if (y==A[mid])
            {
                end = Math.max(end, mid);
                min= mid + 1;
            } else if (y<A[mid]) 
            {
                max=mid-1;
            }
            else
            {
                min=mid+1;
            }
        }
        if(start <= end) 
           return end - start + 1;
        return 0;
}

因此，新功能binarySearch将返回大于index且值等于y的索引总数。

所以剩下的工作就是计算答案

private static int counter(int A[])
{   
     int sum;
     int e = A.length;
     int count = 0;
     for (int i=0; i<e; i++)
     {
         for (int j=i+1; j<e; j++)
         {
             sum=A[i]+A[j];
             count += binarySearch(A,sum, j);

         }  
     }
     return count;
}

注意我是如何使用两个二进制搜索来查找大于y的所有值的起始和结束索引！

Answer 2

private static int counter(int A[]) {
    int e = A.length;
    int count = 0;
    for (int i = 0; i < e; i++) {
        for (int j = 1; (j < e - 1) && (i != j); j++) {
            for (int k = 2; (k < e - 2) && (j != k); k++) {
                if (A[i] + A[j] + A[k] == 0) {
                    count++;
                }
            }
        }
    }
    return count;
}

Answer 3

private static int counter(int ints[]) {
  int count = 0;
  for (int i = 0; i < ints.length; i++) {
    for (int j = 0; j < ints.length; j++) {
      if (i == j) {
        // cannot sum with itself.
        continue;
      }
      for (int k = 0; k < ints.length; k++) {
        if (k == j) {
          // cannot sum with itself.
          continue;
        }

        if ((ints[i] + ints[j] + ints[k]) == 0) {
          count++;
        }
      }
    }
  }

  return count;
}

Answer 4

解决二元搜索问题
你的代码几乎是正确的。所有你需要做的只是取代

if (sum == binarySearch(A,sum)) {

用这个

if (binarySearch(A,sum)) {

我假设您的binarySearch(A, sum)方法会返回 true ，如果它在sum数组中找到A则 {{ 1}} 的

false

Answer 5

这是我的解决方案，假设数组已排序且没有重复元素，我使用了您提供的二进制搜索功能。输入数组可能包含重复的元素吗？你能提供一些测试用例吗？

为了不在循环中计算相同的三元组，我们应该有一种检查重复元素的方法，我在这里使用的主要思想是有一个int []数组列表，保存{{1的排序整数然后在每次迭代中，我将新的A [i]和A [j]与列表中的记录进行比较，从而消除重复的记录。

{A[i],A[j],-sum}

Answer 6

你可以使用辅助数组，存储指示元素是否被使用的标志; 这是代码：

private static int counter(int A[])
{   
     int sum;
     int e = A.length;
     int count = 0;
     // assisted flag array
     List<Boolean> flagList = new ArrayList<Boolean>(e);
     for (int k = 0; k < e; k++) {
        flagList.add(k, false);// initialization
     }
     for (int i=0; i<e; i++)
     {
         for (int j=i+1; j<e; j++)
         {
             sum=A[i]+A[j];
             // if element used, no count
             if(binarySearch(A,sum)&& !flagList.get(i)&& !flagList.get(j))
             {
                  count++;
                  flagList.set(i, true);
                  flagList.set(j, true);
             }
         }  
     }
     return count;

在数组中搜索总和

6 个答案: