计算(列表中）连续元素的最大和

calculate the biggest sum of consecutive Elements ( in a list)

本文关键字：元素 连续 列表 计算      更新时间：2023-10-16

我试图计算vector<int>的连续元素的最大和，但我真的不知道该怎么做：

我开始编码：

#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;
}

函数必须返回：连续元素的最大和是"4，5，78〃；其等于87。

#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

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

从那里开始，您只需要遍历源向量中的元素，跟踪向量中的上一个和当前值。

如果当前值大于上一个值，则将当前值推入当前向量，然后将上一个数值指定给当前值。

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

  1. 确定当前矢量的大小是否大于或等于最大矢量的大小和当前矢量的和是否大于最大矢量的和。如果是，则指定最大值=当前值
  2. 清除当前列表
  3. 将previor赋值给当前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;
}

伪代码：

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
相关文章：