Question

您将获得两个数组A和B，每个数组包含n个整数。您需要从A中精确选择一个数字，并从B中选择一个数字，这样两个所选数字的索引不相同，并且所选择的两个值之和最小。

您的目标是查找并打印此最低值。

例如，下图所示为最小总和。

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

    static int twinArrays(int[] ar1, int[] ar2){
        // Complete this function
        int minAr1 = ar1[0];
        int minAr2;
        int index = 0;
        for(int i =0; i<ar1.length;i++) {
            if(ar1[i]<minAr1) {
                minAr1 = ar1[i];
                index = i;
            }
        }
        if(index == 0) {
            minAr2 = ar2[1];
        }else {
            minAr2 =ar2[0];
        }

        for(int j=0;j<ar2.length;j++) {
            if(j!=index && minAr2>ar2[j]) {
                minAr2 =ar2[j];
            }
        }
        return minAr1+minAr2;
     }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        if(n>=2 && n<=1000000) {
        int[] ar1 = new int[n];
        for(int ar1_i = 0; ar1_i < n; ar1_i++){
            int temp1 = in.nextInt();
            if(temp1>=1&&temp1<=1000000) {
                ar1[ar1_i] = temp1;
            }
        }
        int[] ar2 = new int[n];
        for(int ar2_i = 0; ar2_i < n; ar2_i++){
            int temp2 = in.nextInt();
            if(temp2>=1&&temp2<=1000000) {
                ar2[ar2_i] = temp2;
            }
        }
        int result = twinArrays(ar1, ar2);
        System.out.println(result);
        }

    }
}

我已经实现了工作正常但仍然缺少某些测试用例失败可能有人给我一些线索并暗示如果您在此代码中发现任何缺陷来优化我的代码

Answer 1

您的代码的工作原理是从第一个数组中找到最小值，然后从第二个数组中找到第一个数组中最小值不在同一位置的最小值。这种方法的问题是不能保证找到总的最小总和。例如，考虑这些小数组：

 [0, 1], [0, 100]

这里，如果你取第一个数组的最小值（0）和不在同一个位置（100）的第二个数组的最小值，你得到总和100.但是，正确的总和为pick是第二个数组中的最小值（0），第一个数组中的第二个最小值（1）总共为1。

这里有用的一个观察是最小和对必须是以下之一：

每个数组中最小值的总和。
一个数组中最小值的总和与另一个数组中第二个最小值的总和。

你的解决方案在这里是正确的轨道，除了你不考虑从第二个阵列中获取最小值，从第一个阵列中取出第二个最小值。尝试编辑代码以解决这种情况。

Answer 2

一个简单的观察是，如果两个数组中的最小元素位于不同的位置，则两个元素的总和将是一个答案，因此在这种情况下排序答案后将是A[0]+B[0]，但如果两者都在同一位置，对两个数组进行排序后，有两种可能的答案。

假设我们有两个数组A和B，它们按递增顺序排序。然后有两个可能的答案，实际的答案是最小的。

从数组A中取尽尽可能少的数字，以便该数字为A[0]，现在从数组B中找到最小可能的数字，使该元素的索引不等于{{ 1}}所以最好的选择是0。因此，在这种情况下，答案是B[1]。
另一种可能性是我们首先考虑数组A[0]+B[1]中的最小可能数，然后从数组B中选择一个数字，所以这些数字将是A和{{1}在这种情况下，答案分别是A[1]。

现在，为了得到最终答案，我们可以尽量减少这两种可能的答案。

B[0]

如果您因为时间紧迫而不想对数组进行排序。您可以跟踪两个数组的A[1]+B[0]和Final_Answer = min(A[0]+B[1],A[1]+B[0]);最小元素，并分别在上面的等式中使用它代替First。

使用第一个和第二个最小值的示例代码

Second

Answer 3

我做的是，按升序排序一个数组（ar1）（取ar [0]），另一个按降序排序（ar2）然后取（ar2 [ar2.length-1]）。

 class TwinArray{
    static int twinArrays(int[] ar1, int[] ar2){
       Arrays.sort(ar1);
       Integer[] Ar2 = new Integer[ar2.length];
        for (int i=0;i<ar2.length;i++)
            Ar2[i]=ar2[i];
         Arrays.sort(Ar2,Collections.reverseOrder());
    System.out.println(Ar2[Ar2.length-1]);
     return (ar1[0]+Ar2[Ar2.length-1]);
    }
public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] ar1 = new int[n];
        for(int ar1_i = 0; ar1_i < n; ar1_i++){
            ar1[ar1_i] = in.nextInt();
        }
        int[] ar2 = new int[n];
        for(int ar2_i = 0; ar2_i < n; ar2_i++){
            ar2[ar2_i] = in.nextInt();
        }
        int result = twinArrays(ar1, ar2);
        System.out.println(result);
    }
}

Answer 4

这个可能会通过你的所有测试用例。

运行时复杂度~o（n）

static int twinArrays(int[] ar1, int[] ar2){
        int ar1Minimum = Integer.MAX_VALUE , ar1MinIndex = -1;
        int ar1SecondMin = Integer.MAX_VALUE ;

        //Get the element with minimum value and index
        for(int i = 0 ; i < ar1.length ; ++i){
            if(ar1Minimum > ar1[i]){
                ar1Minimum = ar1[i]; ar1MinIndex = i;
            }       
        }


        //Get the second minimum 
        for(int i = 0 ; i < ar1.length ; ++i){
            if(ar1SecondMin > ar1[i] && i!=ar1MinIndex){ // i != ar1MinIndex = Important to avoid duplicate minimum values [1,1,2,4] min = 1 , secondMin = 2 and not 1
                ar1SecondMin = ar1[i]; 
            }       
        }

        int ar2Minimum = Integer.MAX_VALUE , ar2MinIndex = -1;
        int ar2SecondMin = Integer.MAX_VALUE ;

        for(int i = 0 ; i < ar2.length ; ++i){
            if(ar2Minimum > ar2[i]){
                ar2Minimum = ar2[i]; ar2MinIndex = i;
            }       
        }

        for(int i = 0 ; i < ar2.length ; ++i){
            if(ar2SecondMin > ar2[i] && i != ar2MinIndex){
                ar2SecondMin = ar2[i];
            }       
        }

        if(ar1MinIndex != ar2MinIndex){
            return ar1Minimum + ar2Minimum;
        }

        return Math.max((ar1Minimum + ar2SecondMin), (ar1SecondMin + ar2Minimum));


 }

双数组查找每个数组索引的最小值必须不同

4 个答案: