Java 从多个整数列表中查找K个最高和_Java_Arrays_Algorithm

Java 从多个整数列表中查找K个最高和

java arrays algorithm

Java 从多个整数列表中查找K个最高和,java,arrays,algorithm,Java,Arrays,Algorithm,给定多个整数列表/数组..只需从每个列表中选取一个元素，就可以找出K个最大和。每个列表/数组包含非递增序列中的整数例如，给定输入： [5,4,3,2,1] [4,1] [5,0,0] [6,4,2] [1] 如果K的值是5，即5个最高和结果将是： [21,20,19,19,18] 输入法的示例可能如下所示： List<Integer> fetchHighestSums(int[][] lists,int n){ } List fetchHighestSums（int[]

给定多个整数列表/数组..只需从每个列表中选取一个元素，就可以找出K个最大和。每个列表/数组包含非递增序列中的整数

例如，给定输入：

[5,4,3,2,1]
[4,1]
[5,0,0]
[6,4,2]
[1]

如果K的值是5，即5个最高和

结果将是：

[21,20,19,19,18]

输入法的示例可能如下所示：

List<Integer> fetchHighestSums(int[][] lists,int n){  }

List fetchHighestSums（int[][]List，int n）{

有人能帮我编写上面的java代码吗。

有很多方法可以做到这一点，尽管我不确定你在课堂上学到了什么，他们希望你应用。对我来说，一些“更简单”的解决方案就是把每一个可能的和组成一个数组，从每个列表中取一个。。。对其排序并获取第一个（或最后一个）N值。只要你没有被评为美女。

有很多方法可以做到这一点，尽管我不确定你在课堂上学到了什么，他们希望你应用。对我来说，一些“更简单”的解决方案就是把每一个可能的和组成一个数组，从每个列表中取一个。。。对其排序并获取第一个（或最后一个）N值。只要你没有被评为美貌。

首先，通过阅读你的函数标题，我认为它是一个2D数组，所以每个列表的长度应该是一样的

List<Integer> fetchHighestSums(int[][] lists,int n){
    List<Integer> result = new ArrayList<Integer>();
    if(lists==null || lists.length==0 || lists[0].length==0){
        return result;
    }
    else if(n>lists[0].length*lists.length){
        return null;
    }
    else{
        int[] indexes = new int[lists.length];
        int sum = 0;
        int curMax = Integer.MIN_VALUE;
        int curMaxIndex = -1;
        for(int i=0; i<n; i++){
            sum = 0;
            curMax = Integer.MIN_VALUE;
            for(int j=0; j<lists.length; j++){
                sum += lists[j][indexes[j]];
                if(lists[j][indexes[j]]>curMax){
                    curMaxIndex = j;
                }
            }
            result.add(sum);
            indexes[curMaxIndex]++;
        }
    return result;
}

List fetchHighestSums（int[][]列表，int n）{
列表结果=新建ArrayList（）；
if（lists==null | | lists.length==0 | | lists[0]。length==0）{
返回结果；
}
else if（n>列表[0].length*lists.length）{
返回null；
}
否则{
int[]索引=新的int[lists.length]；
整数和=0；
int curMax=Integer.MIN_值；
int curMaxIndex=-1；
对于（inti=0；i首先，通过读取函数头，我认为它是一个2D数组，因此每个列表的长度
应该是一样的
List<Integer> fetchHighestSums(int[][] lists,int n){
    List<Integer> result = new ArrayList<Integer>();
    if(lists==null || lists.length==0 || lists[0].length==0){
        return result;
    }
    else if(n>lists[0].length*lists.length){
        return null;
    }
    else{
        int[] indexes = new int[lists.length];
        int sum = 0;
        int curMax = Integer.MIN_VALUE;
        int curMaxIndex = -1;
        for(int i=0; i<n; i++){
            sum = 0;
            curMax = Integer.MIN_VALUE;
            for(int j=0; j<lists.length; j++){
                sum += lists[j][indexes[j]];
                if(lists[j][indexes[j]]>curMax){
                    curMaxIndex = j;
                }
            }
            result.add(sum);
            indexes[curMaxIndex]++;
        }
    return result;
}

List fetchHighestSums（int[][]列表，int n）{
列表结果=新建ArrayList（）；
if（lists==null | | lists.length==0 | | lists[0]。length==0）{
返回结果；
}
else if（n>列表[0].length*lists.length）{
返回null；
}
否则{
int[]索引=新的int[lists.length]；
整数和=0；
int curMax=Integer.MIN_值；
int curMaxIndex=-1；
对于（inti=0；i首先，通过读取函数头，我认为它是一个2D数组，因此每个列表的长度
应该是一样的
List<Integer> fetchHighestSums(int[][] lists,int n){
    List<Integer> result = new ArrayList<Integer>();
    if(lists==null || lists.length==0 || lists[0].length==0){
        return result;
    }
    else if(n>lists[0].length*lists.length){
        return null;
    }
    else{
        int[] indexes = new int[lists.length];
        int sum = 0;
        int curMax = Integer.MIN_VALUE;
        int curMaxIndex = -1;
        for(int i=0; i<n; i++){
            sum = 0;
            curMax = Integer.MIN_VALUE;
            for(int j=0; j<lists.length; j++){
                sum += lists[j][indexes[j]];
                if(lists[j][indexes[j]]>curMax){
                    curMaxIndex = j;
                }
            }
            result.add(sum);
            indexes[curMaxIndex]++;
        }
    return result;
}

List fetchHighestSums（int[][]列表，int n）{
列表结果=新建ArrayList（）；
if（lists==null | | lists.length==0 | | lists[0]。length==0）{
返回结果；
}
else if（n>列表[0].length*lists.length）{
返回null；
}
否则{
int[]索引=新的int[lists.length]；
整数和=0；
int curMax=Integer.MIN_值；
int curMaxIndex=-1；
对于（inti=0；i首先，通过读取函数头，我认为它是一个2D数组，因此每个列表的长度
应该是一样的
List<Integer> fetchHighestSums(int[][] lists,int n){
    List<Integer> result = new ArrayList<Integer>();
    if(lists==null || lists.length==0 || lists[0].length==0){
        return result;
    }
    else if(n>lists[0].length*lists.length){
        return null;
    }
    else{
        int[] indexes = new int[lists.length];
        int sum = 0;
        int curMax = Integer.MIN_VALUE;
        int curMaxIndex = -1;
        for(int i=0; i<n; i++){
            sum = 0;
            curMax = Integer.MIN_VALUE;
            for(int j=0; j<lists.length; j++){
                sum += lists[j][indexes[j]];
                if(lists[j][indexes[j]]>curMax){
                    curMaxIndex = j;
                }
            }
            result.add(sum);
            indexes[curMaxIndex]++;
        }
    return result;
}

List fetchHighestSums（int[][]列表，int n）{
列表结果=新建ArrayList（）；
if（lists==null | | lists.length==0 | | lists[0]。length==0）{
返回结果；
}
else if（n>列表[0].length*lists.length）{
返回null；
}
否则{
int[]索引=新的int[lists.length]；
整数和=0；
int curMax=Integer.MIN_值；
int curMaxIndex=-1；
对于（int i=0；i这有一个简单的贪婪算法。将所有数字排序到一个数组中，比如p，用数字所属数组的信息标记每个数字。
最初，总和将是所有最高（第一）的总和从每个数组中选择一个数字，并将这些数字存储在另一个数组s中。我们从P中删除这些数字。下一步是用P中下一个最高的数字替换s中的一个数字。我们从P中选择下一个最高的数字，从s中删除相应的数字，并从P中删除所选的数字。我们这样做，直到得到最高的k为止不，直到P为空。
例如，如果
A = [5,4,3,2,1]
B = [4,1]
C = [5,0,0]
D = [6,4,2]
E = [1] 

P = D[0] A[0] C[0] A[1] B[0] D[1] A[2] D[2] A[3] D[2] A[4] B[1] E[0] C[2]
S = D[0] + A[0] + C[0] + B[0] + E[0] and P = A[1] D[1] A[2] D[2] A[3] D[2] A[4] B[1] C[2]
S = D[0] + A[1] + C[0] + B[0] + E[0] and P = D[1] A[2] D[2] A[3] D[2] A[4] B[1] C[2]
S = D[1] + A[0] + C[0] + B[0] + E[0] and P = A[2] D[2] A[3] D[2] A[4] B[1] C[2]
S = D[0] + A[2] + C[0] + B[0] + E[0] and P = D[2] A[3] D[2] A[4] B[1] C[2]

…etc这有一个简单的贪婪算法。将所有数字排序到一个数组中，例如p，用编号所属数组的信息标记每个数字。
最初，总和将是所有最高（第一）的总和从每个数组中选择一个数字，并将这些数字存储在另一个数组s中。我们从P中删除这些数字。下一步是用P中下一个最高的数字替换s中的一个数字。我们从P中选择下一个最高的数字，从s中删除相应的数字，并从P中删除所选的数字。我们这样做，直到得到最高的k为止不，直到P为空。
例如，如果
A = [5,4,3,2,1]
B = [4,1]
C = [5,0,0]
D = [6,4,2]
E = [1] 

P = D[0] A[0] C[0] A[1] B[0] D[1] A[2] D[2] A[3] D[2] A[4] B[1] E[0] C[2]
S = D[0] + A[0] + C[0] + B[0] + E[0] and P = A[1] D[1] A[2] D[2] A[3] D[2] A[4] B[1] C[2]
S = D[0] + A[1] + C[0] + B[0] + E[0] and P = D[1] A[2] D[2] A[3] D[2] A[4] B[1] C[2]
S = D[1] + A[0] + C[0] + B[0] + E[0] and P = A[2] D[2] A[3] D[2] A[4] B[1] C[2]
S = D[0] + A[2] + C[0] + B[0] + E[0] and P = D[2] A[3] D[2] A[4] B[1] C[2]

…etc这有一个简单的贪婪算法。将所有数字排序到一个数组中，例如p，用编号所属数组的信息标记每个数字。
最初，总和将是所有最高（第一）的总和从每个数组中选择一个数字，并将这些数字存储在另一个数组s中。我们从P中删除这些数字。下一步是用P中下一个最高的数字替换s中的一个数字。我们从P中选择下一个最高的数字，从s中删除相应的数字，并从P中删除所选的数字。我们这样做，直到得到最高的k为止不，直到P为空。
例如，如果
A = [5,4,3,2,1]
B = [4,1]
C = [5,0,0]
D = [6,4,2]
E = [1] 

P = D[0] A[0] C[0] A[1] B[0] D[1] A[2] D[2] A[3] D[2] A[4] B[1] E[0] C[2]
S = D[0] + A[0] + C[0] + B[0] + E[0] and P = A[1] D[1] A[2] D[2] A[3] D[2] A[4] B[1] C[2]
S = D[0] + A[1] + C[0] + B[0] + E[0] and P = D[1] A[2] D[2] A[3] D[2] A[4] B[1] C[2]
S = D[1] + A[0] + C[0] + B[0] + E[0] and P = A[2] D[2] A[3] D[2] A[4] B[1] C[2]
S = D[0] + A[2] + C[0] + B[0] + E[0] and P = D[2] A[3] D[2] A[4] B[1] C[2]

…etc
这有一个简单的贪婪算法。将所有数字排序到一个数组中，例如p，标记每个数字