Java 找到配对（i，j），使i<；j和（a[i]&x2B；a[j]）是最大值

给定一个未排序的数组–arr找到一对arr[i]和arr[j]，这样

---

arr[i]
应该从阵列的末端（右侧）开始将阵列拆分为子阵列。以迭代方式构建子阵列。你从最右边的数字开始，把他前面所有比他低的数字加到子数组中。当您达到一个大于/等于子阵列中最右边的数字时，迭代将转到下一个子阵列

例如：

您的数组是：{1,7,3,4,5,4,6,2}

输出应为：（5,6）

拆分应为：

{{1，7}，{3,4,5,4，6}，{2}

  <--(3)     <--(2) <--(1)

我考虑了你的问题很多，我想我找到了一个可以接受的解决方案

应该从阵列的末端（右侧）开始将阵列拆分为子阵列。以迭代方式构建子阵列。你从最右边的数字开始，把他前面所有比他低的数字加到子数组中。当您达到一个大于/等于子阵列中最右边的数字时，迭代将转到下一个子阵列

例如：

您的数组是：{1,7,3,4,5,4,6,2}

输出应为：（5,6）

拆分应为：

{{1，7}，{3,4,5,4，6}，{2}

  <--(3)     <--(2) <--(1)

您可以按如下方式执行：

public class Main {
    public static void main(String[] args) {
        findPair(new int[] { 1, 7, 3, 4, 5, 4, 6, 2 });
    }

    static void findPair(int[] a) {
        int max = a[0], secondMax = a[0], indexMax = 0, indexSecondMax = 0, maxSum = max + secondMax;
        for (int i = 1; i < a.length; i++) {
            if (a[i] > max) {
                secondMax = max;
                indexSecondMax = indexMax;
                max = a[i];
                indexMax = i;
            } else if (a[i] > secondMax) {
                secondMax = a[i];
                indexSecondMax = i;
            }
            if (indexSecondMax < indexMax && a[indexSecondMax] < a[indexMax]) {
                maxSum = a[indexSecondMax] + a[indexMax];
            } else if (max + secondMax > maxSum) {
                max = secondMax;
            }
        }
        if (indexSecondMax < indexMax && a[indexSecondMax] < a[indexMax]) {
            System.out.println("Pair is (" + a[indexSecondMax] + "," + a[indexMax] + ").");
        } else {
            System.out.println("There is no pair which fulfills the conditions.");
        }
    }
}

逻辑是直截了当的。如有任何疑问，请随时发表评论。
您可以按以下方式进行：

public class Main {
    public static void main(String[] args) {
        findPair(new int[] { 1, 7, 3, 4, 5, 4, 6, 2 });
    }

    static void findPair(int[] a) {
        int max = a[0], secondMax = a[0], indexMax = 0, indexSecondMax = 0, maxSum = max + secondMax;
        for (int i = 1; i < a.length; i++) {
            if (a[i] > max) {
                secondMax = max;
                indexSecondMax = indexMax;
                max = a[i];
                indexMax = i;
            } else if (a[i] > secondMax) {
                secondMax = a[i];
                indexSecondMax = i;
            }
            if (indexSecondMax < indexMax && a[indexSecondMax] < a[indexMax]) {
                maxSum = a[indexSecondMax] + a[indexMax];
            } else if (max + secondMax > maxSum) {
                max = secondMax;
            }
        }
        if (indexSecondMax < indexMax && a[indexSecondMax] < a[indexMax]) {
            System.out.println("Pair is (" + a[indexSecondMax] + "," + a[indexMax] + ").");
        } else {
            System.out.println("There is no pair which fulfills the conditions.");
        }
    }
}

逻辑是直截了当的。如有任何疑问，请随时发表评论。
免责声明：解决方案是O（n^2），而不是OP要求的O（n）

使用两个嵌套循环如何：


i
从
0
到
a.length
j
从
i+1
到
a.length

这确保了免责声明：解决方案是O（n^2），而不是OP要求的O（n）

使用两个嵌套循环如何：


i
从
0
到
a.length
j
从
i+1
到
a.length

这确保了
i这里有一个使用堆栈的解决方案。其思想是堆栈始终包含一个降序序列，因此对于您查看的每个数字，它可以与堆栈中低于它的最大数字配对

在使用数字时，可以安全地将其弹出，因为例如，如果您有一个6，而堆栈顶部是3，则无需保留3，以防它可以与更大的数字配对；若后面有一个7，你们会等着把它和6而不是3配对

公共作废解决方案（int[]arr）{
堆栈=新堆栈（）；
int-bestX=-1，bestY=-1，bestSum=-1；
对于（整数y:arr）{
而（！stack.isEmpty（）&&stack.peek（）bestSum）{bestX=x；bestY=y；bestSum=x+y；}
}
叠加推压（y）；
}
System.out.println（bestX+“”+bestY）；
}

尽管存在嵌套循环，但时间复杂度为O（n），因为内部循环总是从堆栈中弹出，并且每个元素只被推送一次，因此只能弹出一次。
下面是一个使用堆栈的解决方案。其思想是堆栈始终包含一个降序序列，因此对于您查看的每个数字，它可以与堆栈中低于它的最大数字配对

在使用数字时，可以安全地将其弹出，因为例如，如果您有一个6，而堆栈顶部是3，则无需保留3，以防它可以与更大的数字配对；若后面有一个7，你们会等着把它和6而不是3配对

公共作废解决方案（int[]arr）{
堆栈=新堆栈（）；
int-bestX=-1，bestY=-1，bestSum=-1；
对于（整数y:arr）{
而（！stack.isEmpty（）&&stack.peek（）bestSum）{bestX=x；bestY=y；bestSum=x+y；}
}
叠加推压（y）；
}
System.out.println（bestX+“”+bestY）；
}

尽管存在嵌套循环，但时间复杂度为O（n），因为内部循环总是从堆栈中弹出，并且每个元素只被推送一次，因此只能弹出一次。
谢谢。还有：如果没有解决方案，我们会返回什么，如
[4,3,2,1]
？与帕特尔会面-如果其中一个答案解决了您的问题，您可以通过将其标记为已接受来帮助社区。公认的答案有助于未来的访问者自信地使用解决方案。查看以了解如何操作。谢谢。还有：如果没有解决方案，我们会返回什么，如
[4,3,2,1]
？与帕特尔会面-如果其中一个答案解决了您的问题，您可以通过将其标记为已接受来帮助社区。公认的答案有助于未来的访问者自信地使用解决方案。检查以了解如何操作。谢谢，但我需要一个O（n）解决方案。此解决方案是O（n^2），因为它迭代了
I
@kaya3的所有索引对。好的，谢谢，我将在答案顶部添加一个免责声明，因为它仍然对查找此线程有用。谢谢，但我需要一个O（n）解决方案。此解决方案是O（n^2）因为它会在
i
@kaya3的所有索引对上迭代，谢谢，我会在答案的顶部添加一个免责声明，因为它仍然可以帮助人们找到这条线索这是O（n）解决方案，这肯定会起作用。我将编写java代码。谢谢你告诉我方法，谢谢。此外，您实际上不必“构建”子阵列。你可以只扫描最大值，它也低于最右边的值。这是O（n）解决方案，这肯定有效。我将编写java代码。谢谢你告诉我
Pair is (5,6).

int currentMax = -1;
int foundI = -1;
int foundJ = -1;
for(int i=0; i<a.length; i++) {
    for(int j=i+1; j<a.length; j++) {
        if(a[i] < a[j] && a[i] + a[j] > currentMax) {
            currentMax = a[i] + a[j];
            foundI = i;
            foundJ = j;
        }
    }
}

System.out.println("i:" + foundI);
System.out.println("j:" + foundJ);
System.out.println("a[i]:" + a[foundI]);
System.out.println("a[j]:" + a[foundJ]);
System.out.println("sum:" + currentMax);

i:0
j:4
a[i]:4
a[j]:5
sum:9