C++ 排序向量（c+；+；）

我必须把向量N分成M等于的部分（M小于N）

但是那些相等的部分必须在中间。如果我有不相等的部分，我需要将它们放在第一个和/或最后一个元素中。第一个和最后一个之间的差异必须最小。我已经成功地实现了一种功能。函数正在生成新的向量（sizeof（M））并在内部存储向量N中的零件数。 例10/7向量M[1 2 2 1]1+1+2+2+2+1+1=10分成7部分。这意味着我将n或n+1对象作为向量n，并将索引存储在向量M中。其中的值不必相等

现在我遇到了麻烦，因为我的偏差只能是第一个和最后一个元素。 我也有一些问题需要解决 例12/9因为我得到了M[1 1 2 1 1] 但如果我能有第一个和最后一个一样不同 那么它应该像M[3 1 2]

所以我的问题是：有没有更好的方法

#include "stdafx.h"
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;

int N = 12;     // size of vector
int M = 9;      // numbers of divisions


static void subsizes(int vecSize, int subCount, vector<int> &v)
{
    int baseSize = vecSize / subCount;
    int bumps = vecSize % subCount;
    int i,n=0,nPlus,counterPlus=0,counterN,counterLeft;
    vector<int> temp(subCount);         // for new results
    vector<int> proba(subCount);

    for (i = 0; i < subCount; i++)          //dividing to n, n+1 and placing them in vector
    {
        temp[i]= baseSize + (i < bumps);
    }


    for (i=0; i<subCount; i++)          // finding what numbers are n, n+1
    {
        nPlus=temp[i];
        if(n==0 && n<nPlus){
            n=nPlus;}
    }

    for(i=0; i<subCount;i++)            //counting n, n+1
    {
        if(nPlus==temp[i])counterPlus++;
    }
    counterN=subCount-counterPlus;
    counterLeft=counterPlus-2;


    for(i=0; i<counterPlus/2; i++)          //placing them in right order
        temp[i]=nPlus;
    for(i=counterPlus/2; i<counterPlus/2+counterN; i++)
        temp[i]=n;
    for(i=counterPlus/2+counterN; i<subCount; i++)
        temp[i]=nPlus;

    cout<<endl<<"Divided vector is :"<<endl;            //printing results
    for(i=0; i<subCount;i++)
    {
        int part = temp[i];
        cout<<"At : vector["<<i<<"] nubmer of objects is --- "<<part<<endl;

    }
    putchar('\n');
}


int _tmain(int argc, _TCHAR* argv[])
{
    vector<int> vec(N);
    int vecSize = vec.size();       //length of original vector
    int subCount=M;                 //number of sub-vectors parts   

    generate(vec.begin(), vec.end(), rand); // filling vector with C function rand()

    cout<<"Vector is [ ";
    for (auto i : vec)          // printing out a vector
    {
        cout<<i<<" ";
    }
    cout<<"]"<<endl;

    subsizes(vecSize,subCount,vec);     // calling funciton that divideds and print results


    system("PAUSE");
    return 0;
}

#包括“stdafx.h”
#包括
#包括
#包括
#包括
使用名称空间std；
int N=12；//向量大小
int M=9；//师数
静态空洞沉降（int vecSize、int subCount、vector&v）
{
int baseSize=vecSize/子计数；
int bumps=vecSize%子计数；
int i，n=0，nPlus，计数器=0，计数器n，计数器左；
向量温度（子计数）；//用于新结果
向量概率（亚计数）；
对于（i=0；i对于（i=0；i我不确定我是否完全掌握了您的问题，但您似乎可以更改
vec
中包含的元素。在这种情况下，这可能就是您想要的：

void subsizes(vector<int>& vec)
{
    if(vec.size() > 1) // Don't do anything if there aren't at least 2 elements
    {
        // Get the sum of all the elements,
        // but we're going to be adding back in 1s in every element but the last
        // so subtract (vec.size() - 1) from this total.
        // This is done by initializing accumulate to 1 - vec.size()
        int last = accumulate(vec.begin(), vec.end(), 1 - vec.size());

        // Now put 1s in all the elements
        fill(vec.begin(), vec.end(), 1);

        // Change the last element to the value accumulated in last
        vec.back() = last;
    }
}

void子块（向量和向量）
{
if（vec.size（）>1）//如果没有至少2个元素，则不要执行任何操作
{
//得到所有元素的总和，
//但是除了最后一个元素外，我们将在1秒内把每个元素都加回去
//因此，从总数中减去（vec.size（）-1）。
//这是通过将累加初始化为1-vec.size（）完成的
int last=accumulate（vec.begin（），vec.end（），1-vec.size（））；
//现在在所有元素中放入1
填充（向量开始（），向量结束（），1）；
//将最后一个元素更改为最后一个元素中累积的值
返回向量（）=last；
}
}
你让这件事复杂化了很多

如果我理解正确的话


你想要取一个大小为N的向量，然后把它分成M个部分
M个零件中的每个零件应具有相同的长度
如果N中有剩余的元素，则希望在开始和结束时将剩余元素分配给额外的子部分
您的输出是子零件大小的向量

编辑：看来我的假设“您希望在开始和结束时将剩余部分分配给额外的子部分”是错误的

如果这确实是你想要的，那么你可以这样做

void subsizes(int vecSize, int subCount, vector<int> &v)
{
    int regular_size = (vecSize+2) / subCount;
    int remainder = vecSize - regular_size * subCount;

    vector<int> sizes(subCount, regular_size);

    int front_remainder = remainder - (remainder / 2);
    int back_remainder = remainder / 2;

    sizes.front() += front_remainder;
    sizes.back() += back_remainder;

    for (int i = 0; i<sizes.size(); i++)
    {
        int part = sizes[i];
        cout << "At : vector[" << i << "] nubmer of objects is --- " << part << endl;

    }
    putchar('\n');
}

void子项（int-vecSize、int-subCount、vector&v）
{
int常规大小=（vecSize+2）/子计数；
整数余数=向量大小-常规大小*子计数；
向量大小（子计数、常规大小）；
int front_RESTRINCE=余数-（余数/2）；
int back_余数=余数/2；
size.front（）+=前余数；
size.back（）+=back\u余数；
对于（int i=0；我能不能更清楚地描述一下你期望的输入和输出？输出应该是除法每个部分的开始和结束的索引。这就是为什么我创建了新的向量来存储结果。输入只是向量的大小和除法部分的数量。因为里面的元素并不重要，只是除法比率。在你的12/7 e中例如，您更改输入中的数字。允许吗？是的，我在顶部有int M和int N，您可以在任何值上更改它们，只要MSo…我的解决方案有效吗？如果无效，请帮助我了解您要查找的是什么。但是，如果我的subCount=9，则有点不允许。我的新向量需要有9个大小为[0]和[8]的元素我可以有更多的元素，但是中间的计数必须是相等的。当我运行你的函数时，我的向量扩展…@ USSR350597，你的例子：代码> 12/7 m [ 3，1，1，1，1，1，1，1，2 ] < /代码>是我的基础。on@user3350597我编辑它时假设
12/7
是一个打字错误，应该是
12/9
是的，因为如果我选10/6，它应该是M[1 2 2 1]所以我的新向量必须有6个元素，当我加上所有的值时，它应该是=10，但只有在M[0]和M[1]上，我可以有更大或更小的数字。中间必须相等。@user为什么
10/6
不是
[3 1 1 3]
？我只需要将向量分成几个部分，其中的元素并不重要。因此，对于例如sizeof（vec）=10个分割部分的数量=6个新的分割向量[0]和分割向量[last]可以是任何数目，但所有在中间必须是平等的…和积累我不强模板模板我会看它over@user3350597在中添加了一些注释以帮助理解是的，但如果我理解正确，您在代码中没有将向量划分为多个部分…我需要将向量大小划分为10，例如向量大小为6。所以我说M[1 2 2 1]在M[0]我保存了1个元素形式向量N在M[1]我保存了2，依此类推。。。