Code for calculating best possible combination in an array

If there are \$n\$ stations then your approach takes \$O(n^2)\$ time. I can't see a \$O(n)\$ time algorithm, but there is a simple \$O(n \log n)\$ time one:

Define \$S(i) = p_1 + p_2 + \ldots + p_i\$. Then you're trying to find \$s\$ and \$e\$ to minimise \$|S(e) - S(s)|\$. If you sort the values of \$S(i)\$ in \$O(n \log n)\$ time, the minimum difference will be between two consecutive values, so you can do a linear scan to find it.

Bug #1

The main bug that is probably causing your incorrect answers is due to your misreading of the problem. The problem says that if two or more segments have the same score, then you need to return the longest segment. Then, if there are multiple segments of the same score and length, you can return any of these segments.

Currently, your code only finds the first segment with the lowest score. You could trivially modify your program to also record the best segment length and use it as a tiebreaker when you find a new segment of the same score.

Possible Bug #2

Depending on the problem intention, it could be a bug that your program does not consider segments of length 0 (i.e. a segment containing just one station). Your program currently only considers segments with a minimum of 2 stations. Thus, given the input 1 2 3 4 5, your program would find the segment 1 2 instead of the segment 1 1. Of course, if 0 length segments are not allowed, then your program is fine.

Possible Bug #3

Depending on the input, you may be overflowing your integer variables when you do things like:

int prof = prevCost + profit[j];

If this addition overflows past MAX_INT, then prof will turn negative when it actually should be a large positive value. For example, if prevCost and profit[j] were both 0x7fffffff, then the addition will result in the value 0xfffffffe which should be over 4 billion, but when treated as a signed int is -2.

Better algorithm

@PeterTaylor already demonstrated an \$O(n \log n)\$ solution that is probably the simplest to understand. I had come up with another \$O(n \log n)\$ algorithm that works in a similar way. Both are based on the fact that \$S(j) - S(i)\$ gives you the profit of a segment.

1. Create a std::map, which will use running sums (sum[i]) as keys and indices (i) as values. Note that std::map has guaranteed logarithmic insertion and find time, because it uses some form of a a balanced binary tree implementation.
2. Loop i from 0..n, keeping a running sum of profit[0..i].
3. Search the map for the closest match to the current sum. If this closest match is better than the previous best match (by both score and by segment length), then record it as the new best match.
4. If sum does not exist in the map, insert it. If it already exists, do not insert it because the earlier index with the same sum will give a longer segment so we can throw away the current index. Then go back to step #2.

Sample implementation using std::map

#include <iostream>
#include <cmath>
#include <climits>
#include <map>

int main()
{
    int n;
    std::ios_base::sync_with_stdio(false);
    std::map<int, int> sumMap;
    int sum       = 0;
    int bestScore = INT_MAX;
    int bestLen   = 0;
    int bestStart = 0;
    int bestEnd   = 0;

    std::cin >> n;

    // Need to add a sum of 0 with index -1 so that we can find sequences
    // starting at the first station.
    sumMap[0] = -1;

    for (int i=0;i<n;i++) {
        bool alreadyExists = false;
        int  profit;
        std::map<int, int>::iterator it;

        // Maintain running sum of profit[0..i]
        std::cin >> profit;
        sum += profit;

        // Search map for closest match to sum.  Need to search twice.
        for (int loop = 0; loop < 2; loop++) {
            if (loop == 0) {
                // On the first loop, find the closest match >= sum, if
                // there is one.  Use lower_bound() to find this.
                it = sumMap.lower_bound(sum);
                if (it == sumMap.end())
                    continue;
            } else {
                // On the second loop, find the closest match < sum.  We can
                // find this by just decrementing the previous lower_bound.
                if (it == sumMap.begin())
                    break;
                it--;
            }
            // Replace the best match if this match is better.
            int prevSum = it->first;
            int score   = std::abs(sum - prevSum);
            int len     = i - it->second;
            if (score < bestScore || (score == bestScore && len > bestLen)) {
                bestScore = score;
                bestLen   = len;
                bestStart = it->second;
                bestEnd   = i;
            }
            if (score == 0)
                alreadyExists = true;
        }
        // Add sum to map, if it doesn't already exist.
        if (!alreadyExists)
            sumMap[sum] = i;
    }
    std::cout << bestScore << std::endl;
    std::cout << bestStart+2 << " " << bestEnd+1 << std::endl;

    return 0;
}

Sample implementation using sort

Out of curiosity, I wrote a solution using @PeterTaylor's algorithm that used a sort. You can decide whether you think this one is easier to understand than the one using a map. There is one tricky part here where if there are multiple answers all with score 0, you need to handle that specially in order to find the longest segment with score 0.

#include <iostream>
#include <cmath>
#include <climits>
#include <vector>
#include <algorithm>

int main()
{
    int n;
    std::ios_base::sync_with_stdio(false);
    std::vector<std::pair<int, int> > sums;
    int sum       = 0;
    int bestScore = INT_MAX;
    int bestLen   = 0;
    int bestStart = 0;
    int bestEnd   = 0;
    std::pair<int, int> sumPair;

    std::cin >> n;

    // Need to add a sum of 0 with index -1 so that we can find sequences
    // starting at the first station.
    sumPair.first  = 0;
    sumPair.second = -1;
    sums.push_back(sumPair);

    // Create vector of sums.
    for (int i=0;i<n;i++) {
        int profit;
        std::cin >> profit;
        sum += profit;
        sumPair.first  = sum;
        sumPair.second = i;
        sums.push_back(sumPair);
    }

    // Sort vector by sum, then by element index.
    std::sort(sums.begin(), sums.end());

    // Iterate through vector looking for smallest sum distance between
    // adjacent entries.  There is a special case for distance 0 where we
    // need to find the max length segment.
    std::vector<std::pair<int, int> >::iterator it = sums.begin();
    int prevSum   = it->first;
    int prevIndex = it->second;
    for (it++; it != sums.end(); it++) {
        int sum   = it->first;
        int index = it->second;
        int score = std::abs(sum - prevSum);
        int len   = std::abs(index - prevIndex);
        if (score < bestScore || (score == bestScore && len > bestLen)) {
            bestScore = score;
            bestLen   = len;
            bestStart = prevIndex;
            bestEnd   = index;
        }
        if (score != 0)
            prevIndex = index;
        prevSum   = sum;
    }
    // Swap start and end if necessary.
    if (bestStart > bestEnd) {
        int tmp   = bestStart;
        bestStart = bestEnd;
        bestEnd   = tmp;
    }
    std::cout << bestScore << std::endl;
    std::cout << bestStart+2 << " " << bestEnd+1 << std::endl;

    return 0;
}

So here would be my take for the code using two std::vectors. The idea is that the first vector simply stores the individual profits, whereas the second vector starts with all the profits of the 2 segment chains, aka [i, i+1]. We determine the minimum of that vector. Now in the next step we increase vector2 by element i+2. So now it holds all the segments of length 3 (obviously in every step the last element gets ignored). We continue until we reach the full segment.

#include <iostream>
#include <utility>
#include <vector>

int main() {
    std::ios_base::sync_with_stdio(false);
    size_t numStations;
    std::cin>>numStations;

    std::vector<int> profits;
    profits.reserve(numStations);        
    for (size_t station = 0; station < numStations; ++station) {
        int profit;
        std::cin >> profit;
        profits.push_back(profit);
    }

    /* Define the total maximum as the sum of the first pair rather than INT_MAX*/
    size totalMin = std::abs(profit[0] + profit[1]);
    std::pair<size_t, size_t> range = std::make_pair(0, 1);

    std::vector<int> profitSum = profits;
    for (unsigned segmentLength = 2; segmentLength < numStations; ++segmentLength) {
        /* Erase the last segment, as it cannot be enlarged */
        profitSum.pop_back();

        /* Define a starting value for this segment length */
        size_t currentMin = (profitSum[0] + profits[segmentLength-1]); 
        std::pair<size_t, size_t> currentRange = std::make_pair(0, segmentLength-1);

        /* Iterate over all segments of lenth segmentLength and get their sum */
        for (unsigned i = 0; i < profitSum.size(); ++i) {
            profitSum[i] += profits[i+segmentLength-1];

            /* Update if appropriate */
            if (std::abs(profitSum[i]) < currentMin) {
                currentMin = std::abs(profitSum[i]);
                currentRange = std::make_pair(i, i + segmentLength-1);
            }

            /* If 0 is reached we can immediately stop as we can choose any equal sum so take the first */
            if (currentMin == 0) {
                break;
            }
        } 

        /* Update if appropriate. Note that equalness leads to an update, as we search for the longest segment */
        if (currentMin <= totalMin) {
            totalMin = currentMin;
            range    = currentRange;
        }
    }

    /* I opted to go for an absolute minimum instead of calling std::abs every time in the comparison. This is up to you. Obviously this loop would then be superfluous */
    int result = 0;
    for (unsigned i = range.first; i <= range.second; ++i) {
        result += profit[i];
    }
    std::cout << result << "\n";
    std::cout << range.first << " " << range.second << "\n";
}