群组成员分配算法

Question

我听一些地方，并获得一些价值。 我想将这些值分组为我的理想组。

例如我的如意集团：

float group[10] = { -27.f, -28.f, -29.f, -30.f, -31.f, -33.f, -36.f, -40.f, -45.f, -50.f }; 

和一些值：

float inputs[] = { -54.6501, -56.6878, -49.5917, -42.457, -38.6332, 
        -33.4834, -40.7184, -37.1994, -33.6179, -33.6831, 
        -31.3403, -31.0914, -28.8593, -25.398, -26.5037, 
        -50.1182, -50.4615, -47.0196, -35.7407, -34.6086, 
        -31.556, -31.8881, -29.5504, -27.6697, -26.219, 
        -26.9407, -26.5384 
       }; 

当我发布最接近的值，我发现计数：

group[0]:6 
group[1]:1 
group[2]:1 
group[3]:0 
group[4]:4 
group[5]:4 
group[6]:2 
group[7]:3 
group[8]:1 
group[9]:5 

但实际上我需要分配平衡分配。如果组[0]是6，它可以给组[1]和组[2]（它不能给组[3]不同的原因，它可以给出最多2组上升或下降）：

group[0]:3 
group[1]:3 
group[2]:2 
group[3]:0 
group[4]:4 
group[5]:4 
group[6]:2 
group[7]:3 
group[8]:1 
group[9]:5 

和组[4]可以给组[3]分配2个项目，组[5]可以给组[6]分配1个项目。

group[0]:3 
group[1]:3 
group[2]:2 
group[3]:2 
group[4]:2 
group[5]:3 
group[6]:3 
group[7]:3 
group[8]:1 
group[9]:5 

最后一组[9]可以给组[8] 2项。

group[0]:3 
group[1]:3 
group[2]:2 
group[3]:2 
group[4]:2 
group[5]:3 
group[6]:3 
group[7]:3 
group[8]:3 
group[9]:3 

我不知道我该怎么做到这一点。我没有分配太多的经验。

有什么建议吗？图书馆？

========================================

我的工作促进均匀分布。这与我所说的不一样，但我认为它对我有用。

float group[10] = { -27.f, -28.f, -29.f, -30.f, -31.f, -33.f, -36.f, -40.f, -45.f, -50.f }; 
const int GROUPSIZE = 10; 

float groupRatio[10]; 

std::vector<std::vector<float> > grouped; 
grouped.resize(10); 

boost::math::uniform_distribution<float> groupDist(-50, -27); 

for (int i = 0; i < GROUPSIZE; ++i) { 
    std::cout << "cdf[" << i << "]: " << cdf(groupDist, group[i]) << std::endl; 
    groupRatio[i] = cdf(groupDist, group[i]); 
} 

float inputsA[] = { -54.6501, -56.6878, -49.5917, -42.457, -38.6332, 
    -33.4834, -40.7184, -37.1994, -33.6179, -33.6831, 
    -31.3403, -31.0914, -28.8593, -25.398, -26.5037, 
    -50.1182, -50.4615, -47.0196, -35.7407, -34.6086, 
    -31.556, -31.8881, -29.5504, -27.6697, -26.219, 
    -26.9407, -26.5384 
}; 
const int INPUTSIZE = 27; 

std::vector<float> inputs; 
std::copy(&inputsA[0], &inputsA[INPUTSIZE], std::back_inserter(inputs)); 
std::copy(inputs.begin(), inputs.end(), std::ostream_iterator<float>(std::cout, " ")); 

std::cout << "\ninputs.size(): " << inputs.size() << std::endl; 

float max = -150.f; 
for (int i = 0; i < inputs.size(); ++i) { 
    if (max < inputs[i]) 
     max = inputs[i]; 
} 
std::cout << "max : " << max << std::endl; 
boost::math::uniform_distribution<float> inputDist(-50, max); 

float temp; 
for (int i = 0; i < inputs.size(); ++i) { 
    temp = boost::math::cdf(inputDist, inputs[i]); 
    std::cout << "cdf[" << i << "]: " << temp << std::endl; 
    for (int j = 0; j < GROUPSIZE-1; ++j) { 
     if (groupRatio[j] >= temp && groupRatio[j+1] < temp) 
      grouped[j].push_back(inputs[i]); 
     else if (j == GROUPSIZE-2 && groupRatio[j+1] >= temp) 
      grouped[GROUPSIZE-1].push_back(inputs[i]); 
    } 
} 

for (int i = 0; i < grouped.size(); ++i) 
    std::cout << "grouped[" << i << "]: " << grouped[i].size() << std::endl; 

for (int i = 0; i < grouped.size(); ++i) 
    for (int j = 0; j < grouped[i].size(); ++j) 
     std::cout << "grouped[" << i << "][" << j << "]: " << grouped[i][j] << std::endl; 

，这是输出：

cdf[0]: 1 
cdf[1]: 0.956522 
cdf[2]: 0.913043 
cdf[3]: 0.869565 
cdf[4]: 0.826087 
cdf[5]: 0.73913 
cdf[6]: 0.608696 
cdf[7]: 0.434783 
cdf[8]: 0.217391 
cdf[9]: 0 

-54.6501 -56.6878 -49.5917 -42.457 -38.6332 -33.4834 -40.7184 -37.1994 -33.6179 -33.6831 -31.3403 -31.0914 -28.8593 -25.398 -26.5037 -50.1182 -50.4615 -47.0196 -35.7407 -34.6086 -31.556 -31.8881 -29.5504 -27.6697 -26.219 -26.9407 -26.5384 

inputs.size(): 27 

max : -25.398 

cdf[0]: 0 
cdf[1]: 0 
cdf[2]: 0.0165962 
cdf[3]: 0.306601 
cdf[4]: 0.462027 
cdf[5]: 0.671352 
cdf[6]: 0.37727 
cdf[7]: 0.520307 
cdf[8]: 0.665885 
cdf[9]: 0.663235 
cdf[10]: 0.758463 
cdf[11]: 0.76858 
cdf[12]: 0.859308 
cdf[13]: 1 
cdf[14]: 0.955056 
cdf[15]: 0 
cdf[16]: 0 
cdf[17]: 0.121145 
cdf[18]: 0.579599 
cdf[19]: 0.625616 
cdf[20]: 0.749695 
cdf[21]: 0.736196 
cdf[22]: 0.831217 
cdf[23]: 0.907662 
cdf[24]: 0.966629 
cdf[25]: 0.937294 
cdf[26]: 0.953646 

grouped[0]: 2 
grouped[1]: 3 
grouped[2]: 1 
grouped[3]: 2 
grouped[4]: 3 
grouped[5]: 5 
grouped[6]: 3 
grouped[7]: 2 
grouped[8]: 2 
grouped[9]: 4 

grouped[0][0]: -25.398 
grouped[0][1]: -26.219 
grouped[1][0]: -26.5037 
grouped[1][1]: -26.9407 
grouped[1][2]: -26.5384 
grouped[2][0]: -27.6697 
grouped[3][0]: -28.8593 
grouped[3][1]: -29.5504 
grouped[4][0]: -31.3403 
grouped[4][1]: -31.0914 
grouped[4][2]: -31.556 
grouped[5][0]: -33.4834 
grouped[5][1]: -33.6179 
grouped[5][2]: -33.6831 
grouped[5][3]: -34.6086 
grouped[5][4]: -31.8881 
grouped[6][0]: -38.6332 
grouped[6][1]: -37.1994 
grouped[6][2]: -35.7407 
grouped[7][0]: -42.457 
grouped[7][1]: -40.7184 
grouped[8][0]: -49.5917 
grouped[8][1]: -47.0196 
grouped[9][0]: -54.6501 
grouped[9][1]: -56.6878 
grouped[9][2]: -50.1182 
grouped[9][3]: -50.4615 

Answer 1

如果我理解正确的问题，你计算最接近不同的号码group[]如何inputs[]许多数字的计数，然后将这些计数存储到group[]中这些数字的位置。您希望能够在不同位置之间分配盘点，但每个仓位只能分配两个仓位。它是否正确？

您应该检出Boost/Math/Distributions.hpp。它有很多的发行版，其中有几个可能在这种情况下很有用。

我认为可能有趣的是，如果您将原始请求中概述的分布应用了足够多的时间，那么group[]中的所有元素将倾向于平均值。换句话说，应用分配足够的时间后，你将永远结束了一个数组，其中的所有元素或者等于

ceil([total # of numbers in inputs[]]/[# of places in group[]])

OR

floor([total # of numbers in inputs[]]/[# of places in group[]])

例如，在中数组最后在原始请求中的示例中，所有元素都是2或3.如果您查看起始数组，并将inputs[]中的数字数除以group[]中的地点数，则会得到2.7 。所以基本上，这意味着如果你在group[]之间的位置之间平均计算inputs[]中的数字，则group[]中的每个点有2.7个数字。如果你足够应用了你在原始请求中详细描述的分配，那么你的结果应该尽可能接近平均水平（你显然不能有0.7的数字，这就是为什么某些职位比其他职位多一个数字） 。

我希望我的解释至少有一点意义。我需要一个更明确的分配算法的定义来尝试编码它。似乎分布式group[]中的每个数字都取决于三到五个数字（本身以及两到四个数字），因此创建计算每个条目的循环是一个棘手的问题。