Minimum difference between the highest and the smallest value of mines distributed - c++

Question

Given Question: Given n companies and m oil mines with values, design an algorithm to
distribute the sites among the companies in a fair manner, where the company getting the highest
total value of its assigned sites and the one getting the lowest total value is minimal. Your
algorithm should output this minimum difference. Note that oil mines sites assigned to each
company should be adjacent to each other, and that the number of mines m is always bigger than
or equal to the number of companies n
Sample Input: Input : n = 3, site values = [6, 10, 13, 2]
Output : 9 → for the assignment of [6] to company #1, [10] to company #2, and [13, 2]
to company #3, making the minimum difference (13+2) - 6 = 9
My attempt at solving:
Add all previous elements in array, so the new array becomes [6, 16, 29, 31].
Then, I form all possible solution arrays which are: note: 31 stays constant because it is the largest and I need to subtract the largest from the smallest
31, 29, 16
31, 29, 6
31, 16, 6
Then, I subtract all previous elements in array, so the new arrays become
2, 13, 16
2, 23, 6
15, 10, 6
Then I subtract the highest number from the lowest number in each array which would be:
16 - 2 = 14
23 - 2 = 21
15 - 6 = 9 // **answer**
I would pick the smallest difference which is 9
My question:
(1) Is there an easier way to solve this? As this seems like it a bit too complex and I'm just overthinking things. (2) How would I go about implementing generating all the possible combinations to the array? Should I use permutations? Recursion? This is the part that I'm stuck on the most, generating all possible solutions where 31 (in the example stays the same) and I select only 2 out of the 3 other elements in the array.
void Func (int n, int m, int prosValues[], int solArray[], bool summed) {
if (!summed) {
for (int i = 1; i < m; i++) {
prosValues[i] = prosValues[i] + prosValues[i-1];
}
solArray[0] = prosValues[m-1];
summed = true;
}
// generate all possible combinations as shown in example
}

Answer 1

Interesting problem! I chose a different approach to solve this. I don't know, if it is more elegant, but I spend some time thinking about it and wanted to share my solution at least.
I make the following convention for the site assignment:
The indices in the site array describe the start index for site values, from which the site values are assigned to that site. Let's make it clearer using two examples.
values = {2,6,3,8,2,1}
sites1 = {0,1,2}
sites2 = {0,2,5}
The two site distributions site1 and site2 will assign the site values as follows:
distribution for site1:
0: 2
1: 6
2: 3, 8, 2, 1
distribution for site2:
0: 2, 6
1: 3, 8
2: 2, 1
This way we can iterate through all combinations by shifting the indices in sites up. In the example for 6 site values, we would get:
{0,1,2}
{0,1,3}
{0,1,4}
{0,1,5}
{0,2,3}
{0,2,4}
{0,2,5}
{0,3,4}
{0,3,5}
{0,4,5}
{1,2,3}
{1,3,4}
{1,3,5}
.
.
.
{3,4,5}
For all these site distributions we sum up the site values for each site, calculate the maximum difference and pick the distribution with the smallest difference.
Putting it all together, here is the code I came up with:
#include <iostream>
#include <algorithm>
int calc_diff(int m, int n, int* values, int* sites)
{
// stores the sum of values for each site
int *result = new int[n] {0};
// iterate through all site values
for (int j = 0; j < m; j++)
{
// find the correct site index to which the value is assigned
int index = 0;
for (int i = n-1; i >= 0; i--)
{
if (j >= sites[i])
{
index = i;
break;
}
}
// sum up the site vaues
result[index] += values[j];
// debug print
// std::cout << index << ":\t" << result[index] << std::endl;
}
// print the site results
std::cout << "result:\t";
for (int i = 0; i < n; i++)
std::cout << result[i] << "\t";
// get the highest difference
auto min = std::min_element(result, result+n);
auto max = std::max_element(result, result+n);
int diff = *max - *min;
delete[] result;
return diff;
}
int main()
{
int n = 3;
int m = 6;
auto values = new int[m] {2,6,3,8,2,1};
auto sites = new int[n] {0,1,2};
// start index of the first site
int start_index = 0;
// current best difference (some really high number)
int max = 100000000;
// the current best solution
auto best = new int[n];
bool end = false;
while(!end)
{
std::cout << "sites:\t";
for (int i = 0; i < n; i++)
std::cout << sites[i] << "\t";
std::cout << std::endl;
// calculate the maximal difference of the current site distribution
auto diff = calc_diff(m, n, values, sites);
std::cout << "\nmax diff:\t" << diff << std::endl << std::endl;
// if we find a better solution than the current best, we store it as new best solution
if (diff < max)
{
max = diff;
memcpy(best, sites, n*sizeof(int));
}
// calculate new site distribution
int index = 0;
for (int i = n-1; i >= 0; i--)
{
// get the current index
index = sites[i];
// can we still move the index one position up?
// the index of the last site should not exceed m-1
// the index of all other sites should be less than the index of the next site
if ((i == n-1 && index < m-1) ||
(i < n-1 && i > 0 && index < sites[i+1]-1))
{
// increase the index of the current site
sites[i]++;
break;
}
// all site index have moved to maximum position?
// (we iterated through all indices (so i=0) and moved none of them)
if (i == 0)
{
// increase the start index of the first site
start_index++;
// reset the indices by starting from the current start_index
for (int j = 1; j < n; j++)
{
sites[j] = start_index + j;
// if we exceed the numbers of site values, we can stop the loop
if (sites[j] >= m)
end = true;
}
}
}
}
// print best soluition
std::cout << "Best distribution: ";
for (int i = 0; i < n; i++)
std::cout << best[i] << " ";
delete[] sites;
delete[] values;
delete[] best;
}