羣組成員分配算法

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[]中的每個數字都取決於三到五個數字（本身以及兩到四個數字），因此創建計算每個條目的循環是一個棘手的問題。