Question

我试图计算向量的连续元素的最大总和但我真的不知道该怎么做：

我开始编码：

#include <iostream>
#include <vector>
using namespace std;

void calcule_somme(vector<int> tab);

void calcule_somme(vector<int> tab) {

    int somme_partielle(0);
    vector<int> element_les_plusgrand;

    for(size_t i(0);tab.size();++i) {

        for(size_t j(i+1);tab.size();++i) {
                element_les_plusgrand.pushback(tab[i]);

                if (tab[i]+tab[j]>compteur) {
                    element_les_plusgrand.push_back(tab[j]);
                    compteur = tab[i]+tab[j];
                }


}







int main() {





    return 0;
}`

该函数必须返回：连续元素的最大总和是＆＃34; 4,5,78＆＃34;等于87

感谢您的帮助

Answer 1

首先，您需要跟踪两个向量，一个用于保存最大的字符序列，另一个用于保存当前正在计算的值。

从那里，你只需要遍历源向量中的元素，跟踪向量中的先前值和当前值。

如果当前值大于先前值，则将当前值推入当前向量，然后将先前值分配给当前值。

如果它小于（或我假设相等），则连续序列完成，您应该从下一个序列开始。这意味着您需要执行以下操作：

确定当前矢量的大小是否大于或等于最大矢量的大小和，当前矢量的总和大于最大值的总和。如果是，则指定maximum = current;
清除当前列表
指定当前int值的前一个。

以下是我的写作方式：

int sum(const vector<int>& tab) {
    int sum = 0;
    for (size_t i = 0; i < tab.size(); i++) {
        sum += tab[i];
    }

    return sum;
}

vector<int> calculate_some(const vector<int>& tab) {
    vector<int> ret, current;

    int previous = tab[0];
    current.push_back(previous);
    for (size_t i = 1; i < tab.size(); i++) {
        current.push_back(tab[i]);

        if (tab[i] <= previous  || i == (tab.size() - 1)) {
            if (current.size() >= ret.size() && sum(current) > sum(ret))
                ret = current;

            current.clear();
        }

        previous = tab[i];
    }

    return ret;
}

以下是我的称呼方式：

int main() {

    vector<int> tab = { -4,5,6,-9,24,-35,4,5,78 };
    vector<int> results = calculate_some(tab);

    for (size_t w(0); w<results.size(); ++w) {
        cout << results[w] << " ";
    }

    system("pause");


    return 0;
}

Answer 2

#include <iostream>
#include <vector>
using namespace std;







int sum(const vector<int>& tab) {
    int sum = 0;
    for (size_t i = 0; i < tab.size(); i++) {
        sum += tab[i];
    }

    return sum;
}

vector<int> calculate_sume(const vector<int>& tab) {
    vector<int> ret, current;

    int previous = -32767;
    for (size_t i = 0; i < tab.size(); i++) {
        if ((tab[i] > previous) == false) {
            if (current.size() >= ret.size() && sum(current) > sum(ret))
                ret = current;

            current.clear();
        }

        current.push_back(tab[i]);
        previous = tab[i];
    }
   for(size_t w(0);w<ret.size();++w) {
       cout << ret[w]<< " ";
    }
    return ret;
}


int main() {

    vector<int> tab ={-4,5,6,-9,24,-35,4,5,78};
    sum(tab);
    calculate_sume(tab);





    return 0;
}

告诉我-4 5 6

Answer 3

伪代码：

Algorithm Biggest_Consecutive_Sum
Input: Vector v
Output: Biggest_Sum

begin

    index = 0, Biggest_Sum = 0

    while(index < v.size()){

        Sum = 0

        while (Sum + V[index] > Sum){
            Sum = Sum + V[index]
            index = index + 1
        }

        if(Sum > Biggest_Sum) Biggest_Sum = Sum

        index = index + 1
    }

    return Biggest_Sum

end

计算连续元素的最大总和（在列表中）

3 个答案: