单栈模式-在数组无法满足时间限制的情况下

题目

设计一个算法收集某些股票的每日报价，并返回该股票当日价格的 跨度 。

当日股票价格的 跨度 被定义为股票价格小于或等于今天价格的最大连续日数（从今天开始往回数，包括今天）。

例如，如果未来 7 天股票的价格是 [100,80,60,70,60,75,85]，那么股票跨度将是 [1,1,1,2,1,4,6] 。

实现 StockSpanner 类：

StockSpanner() 初始化类对象。
int next(int price) 给出今天的股价 price ，返回该股票当日价格的 跨度 。

示例：

输入：
[“StockSpanner”, “next”, “next”, “next”, “next”, “next”, “next”, “next”]
[[], [100], [80],[200],[100], [60], [70], [60], [75], [85]]
输出：
[null, 1, 1, 1, 2, 1, 4, 6]

解释：
StockSpanner stockSpanner = new StockSpanner();
stockSpanner.next(100); // 返回 1
stockSpanner.next(80); // 返回 1
stockSpanner.next(60); // 返回 1
stockSpanner.next(70); // 返回 2
stockSpanner.next(60); // 返回 1
stockSpanner.next(75); // 返回 4 ，因为截至今天的最后 4 个股价 (包括今天的股价 75) 都小于或等于今天的股价。
stockSpanner.next(85); // 返回 6

单栈模式

class StockSpanner {
public:
    StockSpanner() {
        this->stk.emplace(-1, INT_MAX);
        this->idx = -1;
    }
    
    int next(int price) {
        idx++;
        while (price >= stk.top().second) {
            stk.pop();
        }
        int ret = idx - stk.top().first;
        stk.emplace(idx, price);
        return ret;
    }

private:
    stack<pair<int, int>> stk; 
    int idx;
};

可以实现但是超出时间限制的代码

class StockSpanner {
public:
    StockSpanner() {
    }
    
    int next(int price) 
    {
        DailyPrices.push_back(price);
        if (DailyPrices.size() == 1)
        {
            return 1;
        }
        
        int iStartCount = 0;
        int iEndCount = 0;
        for (int i = 0; i < DailyPrices.size() - 1; i++)
        {
            bool bcal = false;
            if (DailyPrices[i] <= price)
            {
                iStartCount +=1;
                bcal = true;
            }
            else
            {
                iStartCount = 0;
            }
            int j = DailyPrices.size() - 1 - i;
            if (j < 0 )
            {
                break;
            }

            if (DailyPrices[j] <= price)
            {
                iEndCount += 1;
            }
            else if ( i < j)
            {
                return iEndCount;
            }
            
            if ( i == j)
            {
                if (bcal)
                {
                    return iEndCount + iStartCount - 1;
                }
                return iEndCount + iStartCount;
                
            }
            
            if (i == j - 1)
            {
                return iEndCount + iStartCount;
            }
            
        }
        return iStartCount + iEndCount;
    }
private:
    std::vector<int> DailyPrices;
};