在数字字段中查找最大总和

Question

I have to write a program that sums up sequential elements of an array and outputs the maximum sum. As you will see my algorithm won't work if all elements are negative.

#include <iostream>

int main()
{
    int nums[1000] = {-1,-3,-4,-2,-5,-1,-9,-4,-2,-2};
    int sums[100][100];
    int n = 9;

    for(int i = 0; i <= n; i++) {
        for(int j = n; j >= i; j--) {
            for(int k = j; k >= i; k--) {
                sums[i][j] += nums[k];
            }
        }

    }

    int max_sum = 0; 
    int max_begin;
    int max_end;

     for(int i = 0; i <= n; i++) {
        for(int j = i+1; j <= n; j++){
                std::cout << "i = " << i << " j = " << j << ": " << sums[i][j] << "\n";
            if(max_sum < sums[i][j]) {
                max_sum = sums[i][j];
                max_begin = i;
                max_end = j;
                }
            }
        }

    std::cout << "Maximum: " << max_sum << " bei i = " << max_begin << " bis j = " << max_end;

    return 0;
}

I already tried this solution

#include <climits>
...
int max_sum = INT_MIN;
...

While this works perfectly fine we didn't have climits in our lecture yet so I'm looking for another way.

Answer 1

Change to:

int max_sum = sums[0][0];

This way you will never have to worry about the range of numbers.

Answer 2

This is one of the main motivations for a std::optional type (when all values in a range are valid). If you cannot use it, we can imitate it for our purposes with a simple boolean:

bool max_set = false;
int max_sum = 0;

// ...
if (!max_set || max_sum < sums[i][j]){
   max_set = true;
   max_sum = sums[i][j];
}

We can make a simple class to further imitate it if we'd like (untested code):

class optional_int{
   bool is_set = false;
   int value = 0;
public:
   bool operator()() const{return is_set;}
   int& operator=(int _value){value = _value; is_set=true; return value;}
   int& get(){
      if (!is_set){throw std::logic_error("attempting to access unset optional");}
      return value;
};

optional_int max_sum;
//...
if (!max_sum || max_sum.get() < sums[i][j]){
   max_sum = sums[i][j];
}

We can continue to make this type more and more generic, but we'd only be re-implementing std::optional