写了下并行调度算法的Java版本，是想把这个思路先实现了，后面改写Python版作为参考，调试这个版本之后，再来写Python版，发现差别还不小。

Java版本的目前支持动态赋值，目前的元素个数是10个，可以根据情况修改，并行度是4，可以根据情况修改。

import java.util.Random; import java.util.Arrays; public class Test { public static void main(String args[]) { new Test().test(); // int[] array ={96,59,55,34,22,11,7,5,3,2}; // new Test().getMaxIndex(array); } public void test(){
System.out.println("test"); int ARRAY_SIZE = 10; int test_array[] = new int[ARRAY_SIZE]; for (int i = 0; i < ARRAY_SIZE; i++) {
test_array[i] = new Random().nextInt(100);
}
Arrays.sort(test_array); for (int i = 0; i < ARRAY_SIZE; i++) {
System.out.println(test_array[i]);
} int GRP_NO = 4; int array_group[][] = new int[GRP_NO][ARRAY_SIZE]; int array_sum_group [] = new int[GRP_NO]; for (int i = 0; i < GRP_NO; i++) {
array_group[i][0] = test_array[ARRAY_SIZE - i - 1];
array_sum_group[i] = test_array[ARRAY_SIZE - i - 1];
System.out.println("init value :"+array_sum_group[i]);
} int min_grp_no = 0; int max_index = 0; for (int i = ARRAY_SIZE-GRP_NO-1 ; i >= 0; i--) { //get min array group index System.out.println("new value:"+test_array[i]);
min_grp_no = getMinGrpNo(array_sum_group);
max_index = getMaxIndex(array_group[min_grp_no]);
array_group[min_grp_no][max_index+1] = test_array[i];
array_sum_group[min_grp_no] += test_array[i];
System.out.println(array_group[min_grp_no][max_index+1]+","+array_group[min_grp_no][max_index]+","+array_sum_group[min_grp_no]);
}
System.out.println(array_group);
} public int getMinGrpNo(int[] array) { int temp_value = 0; int min_index = 0; if(array.length>1) {
temp_value = array[0]; for (int i = 1; i < array.length; i++) { if (temp_value > array[i]) {
temp_value = array[i];
min_index = i;
}
}
}
System.out.println("getMinGrpNo:"+min_index+" value:"+temp_value); return min_index;
} public int getMaxIndex(int[] array) { int temp_value = 0; int max_index = 0; if(array.length>1) {
temp_value = array[0]; for (int i = 1; i < array.length; i++) { if(array[i] != 0) { if (temp_value > array[i]) {
temp_value = array[i];
max_index = i;
}
}
}
}
System.out.println("getMaxIndex:"+max_index+" value:"+temp_value); return max_index;
}
}

程序的执行结果如下，整体的思路是生成随机数的数组，然后对数组排序，然后对数组做数据处理，每次添加新元素都需要对每组累计值做一个排序，累计值最小的可以添加新的元素，直至元素被添加完。

所以自己在逻辑的部分写了两个函数来单独处理：

一个是得到累计值最小的数组，得到数组的下标

另外一个是查找数组中元素的最大下标，比如数组有3个元素，那么最大下标就是2（数组从0开始）

test 18 28 31 33 41 57 59 59 79 86 init value :86 init value :79 init value :59 init value :59 new value:57 getMinGrpNo:2 value:59 getMaxIndex:0 value:59 57,59,116 new value:41 getMinGrpNo:3 value:59 getMaxIndex:0 value:59 41,59,100 new value:33 getMinGrpNo:1 value:79 getMaxIndex:0 value:79 33,79,112 new value:31 getMinGrpNo:0 value:86 getMaxIndex:0 value:86 31,86,117 new value:28 getMinGrpNo:3 value:100 getMaxIndex:1 value:41 28,41,128 new value:18 getMinGrpNo:1 value:112 getMaxIndex:1 value:33 18,33,130

当然上面的实现，如果拿10个元素来看，好像意义不大，但是如果是100个，200个这种场景，你会明显感觉到效果了。