问题描述
|
给定每个大小为K的N个数组。.对N个数组中的K个元素中的每一个进行排序，这些N * K个元素中的每个元素都是唯一的。从N个元素的选定子集中，从N个数组中的每一个中选择一个元素。减去最小和最大元素。现在，这个
差异应该是最小可能的。。希望问题是清楚的:) :)
样品：
N=3,K=3
N=1 : 6,16,67
N=2 : 11,17,68
N=3 : 10,15,100
解决方法
我可以想到O（N * K * N）（由zivo正确指出后编辑，现在不是一个好的解决方案:(）解决方案。
1.以N指针初始指向N个数组中的每个数组的初始元素。
6,16,67
^
11,17,68
^
10,15,100
^
6,67
^
11,68
^
10,100 (difference:5)
^
6,100 (difference:5)
^
6,68
^
10,100 (difference:2)
^
6,100 (difference:84)
^
6,67
^
11,100 (difference:83)
^
Struct
{
int element;
int arraynumer;
}
6|0,16|0,67|0
11|1,17|1,68|1
10|2,15|2,100|2
int count[N] = { 0 }
int head = 0;
int diffcnt = 0;
// mindiff is initialized to overall maximum value - overall minimum value
int mindiff = combined_val[N * K - 1] - combined_val[0];
for (int i = 0; i < N * K; i++)
{
count[combined_ind[i]]++;
if (count[combined_ind[i]] == 1) {
// diffcnt counts how many arrays have at least one element between
// indexes of \"head\" and \"i\". Once diffcnt reaches N it will stay N and
// not increase anymore
diffcnt++;
} else {
while (count[combined_ind[head]] > 1) {
// We try to move head index as forward as possible while keeping diffcnt constant.
// i.e. if count[combined_ind[head]] is 1,then if we would move head forward
// diffcnt would decrease,that is something we dont want to do.
count[combined_ind[head]]--;
head++;
}
}
if (diffcnt == N) {
// i.e. we got at least one element from all arrays
if (combined_val[i] - combined_val[head] < mindiff) {
mindiff = combined_val[i] - combined_val[head];
// if you want to save actual numbers too,you can save this (i.e. i and head
// and then extract data from that)
}
}
}
int[n] result;// where result[i] keeps the element from bucket N_i
int[n] latest;//where latest[i] keeps the latest element visited from bucket N_i
Iterate elements in (N_1 + N_2 + N_3) in sorted order
{
Keep track of latest element visited from each bucket N_i by updating \'latest\' array;
if boundary(latest) < boundary(result)
{
result = latest;
}
}
int boundary(int[] array)
{
return Max(array) - Min(array);
}
choose the element in 2nd array that is closest to the element in 1st array
current_array = 2;
do
{
choose the element in current_array+1 that is closest to the element in current_array
current_array++;
} while(current_array < n);
复杂度：O（k ^ 2 * n）
,这是我如何解决此问题的逻辑，请记住，我们需要从N个数组中各选择一个元素（以计算最小值）
// if we take the above values as an example!
// then the idea would be to sort all three arrays while keeping another
// array to keep the reference to their sets (1 or 2 or 3,could be
// extended to n sets)
1 3 2 3 1 2 1 2 3 // this is the array that holds the set index
6 10 11 15 16 17 67 68 100 // this is the sorted combined array.
| |
5 2 33 // this is the computed least minimum,// the rule is to make sure the indexes of the values
// we are comparing are different (to make sure we are
// comparing elements from different sets),then for example
// the first element of that example is index:1|value:6 we hold
// that value 6 (that is the value we will be using to compute the least minimum,// then we go to the edge of the comparison which would be the second different index,// we skip index:3|value:10 (we remove it from the array) we compare index:2|value:11
// to index:1|value:6 we obtain 5 which would go to a variable named leastMinimum = 5,// now we remove the indexes and values we already used,// and redo the same steps.
1 3 2 3 1 2 1 2 3
6 10 11 15 16 17 67 68 100
|
5
leastMinumum = 5
3 1 2 1 2 3
15 16 17 67 68 100
|
2
leastMinimum = min(2,leastMinumum) // which is equal 2
1 2 3
67 68 100
33
leastMinimum = min(33,leastMinumum) // which is equal to old leastMinumum which is 2
// After sorting the n arrays we will have the below indexes array and values array
1 1 2 3 2 3
6 7 8 12 15 16
* * *
* we skip second index of 1|7 and we take the least minimum of 1|6 and 3|12 (index:2|value:8 will be removed as it is not at the edges,we pick the minimum and maximum of the unique index subset of n elements)
1 3
6 12
=6
* second step we remove the values we already used,so the array become like below:
1 2 3
7 15 16
* * *
7 - 16
= 9
1 3 2 3 1 2 1 2 3
6 10 11 15 16 17 67 68 100
1 3 2
6 10 11
3 1 2
15 15 17
1 2 3
67 68 100