Question

因此，我试图解决的问题是，您有一系列股票价格，其中每个头寸是不同的股票价格。现在的问题是编写一个算法来计算股票的跨度，这基本上意味着每个i头寸包含的先前股票数量小于或等于当前股票。这就是我现在所拥有的：

NoHistory=true

我现在要做的就是使用堆栈来尝试将其运行时间提高到O（n）。事情是我更习惯使用for循环和数组来解决这个问题，那么如何在这个算法中实现堆栈呢？

Answer 1

Solution Source

股票跨度问题：对于给定的股票价格数组P，股票跨度是股票价格连续第i天小于或等于其价格的最大连续天数。使用堆栈可以有效地解决这个问题。

 public static int[] computeSpan(int[] P) {
    int length = P.length;
    int[] S = new int[P.length];
    MyStack<Integer> myStack = new MyStack<>(length);
    int h = 0;
    for (int i = 0; i < length; i++) {
        h = 0;
        while (!myStack.isEmpty()) {
            if (P[i] >= P[myStack.top()]) {
                myStack.pop();
            } else {
                break;
            }
        }
        h = myStack.isEmpty() ? -1 : myStack.top();
        S[i] = i - h;
        myStack.push(i);
    }
    return S;
}

请通过链接获取解决方案参考。

Answer 2

尝试此解决方案：

public static Map<Integer, Integer> getStockSpan(int[] prices) {
        Map<Integer, Integer> stockSpan = new HashMap<>();
        Stack<Integer> span = new Stack<>();
        for (int price : prices) {
            int count = 1;
            while (!span.isEmpty() && price >= span.peek()) {
                count += stockSpan.get(span.pop());
            }
            span.push(price);
            stockSpan.put(price, count);
        }
        return stockSpan;
    }

Answer 3

这是我使用堆栈库的C ++代码

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

void CalculateSpan(int a[],int n,int S[]){
    stack<int> st;
    //create the stack 
    int i;
    st.push(0); //pushed first element of ARRAY to stack 
    //as there is nothing to the left of initial element set its span as 1 to default
    S[0]=1;
    for(i=1;i<n;i++){
        //start looping from index 1
        //basically we are comparing initial element with all other element
        //now initially if top of stack is less than ith index of array then just pop
        while(!st.empty()&&a[st.top()]<=a[i])
          st.pop();
          if(st.empty())
           S[i]=i+1;
          else
          //to get span if ith index greater then top then just substract ith from top index and push the ith index
           S[i]=i-st.top();
           st.push(i);
    }
}

void printa(int arr[],int n){
    int i;
    for(i=0;i<n;i++){
        cout<<arr[i];
    }
}

int main()
{
  int a[10],S[10];
  int n,i;
  cout<<"Enter the size of the element you want";
  cin>>n;
  cout<<"\nEnter the number of elements you want\n";
  for(i=0;i<n;i++){
      cin>>a[i];
  }
  CalculateSpan(a,n,S);
  printa(S,n);
}

Answer 4

执行这些操作n次：
1）两个获得您需要计算的值
res = i-R + 1
其中i是当前索引，R是从堆栈弹出的索引

2）进行以下操作
i）如果堆栈不为空，并且当前元素> =顶部索引元素，则执行

当堆栈不为空并且当前元素> =到a [top]做pop（）

ii）将当前索引推入堆栈并计算值

    int *a, *res;
    a = new int[n];
    res = new int[n];
    stack<int>S;
    for(int i=0;i<n;i++){
        int top = i;
        if(!S.empty() && a[S.top()]<=a[i]) {
            while(!S.empty() && a[S.top()]<=a[i]){
                top = S.top();
                S.pop(); 
            }
            S.push(top);
        }
        S.push(i);
        res[i] = i-top+1; 
    }

如何使用堆栈解决此库存范围？

4 个答案: