在给定程序中降低矢量数组实现堆栈的时间复杂度有哪些不同的可能方法?

What are the different possible ways to reduce the time complexity of vector array implementing stack in the given program..?

本文关键字：时间复杂度 方法 堆栈 程序 实现 数组      更新时间：2023-10-16

如果我使用10^5 测试运行，使用 vector 的堆栈实现需要很多时间才能运行 cases.so 我只是在寻找不同的方法来使我的代码高效，以便该程序在广泛的测试用例中运行得足够快，并且我知道每个向量函数都有巨大的成本。 就像如果我使用stack.size()那么它会迭代整个向量，所以它是使用它效率低下，但我认为没有其他方法，因为您必须遍历矢量数组。我只需要使我的代码更加优化，并需要这方面的建议。 请帮我解决这个问题。 谢谢。

`vector<int> stack;
void push()
{
int element;
cin>>element;
stack.push_back(element);
}
void pop()
{
if(stack.empty())
{
return;
}
stack.pop_back();
}
void max_element()
{
int max = stack[0];
for(int i=0; i<stack.size();i++)
{
if(max < stack[i])
{
max = stack[i];
}
} 
cout<<max<<endl;

}
int main() {  
int t,n;
cin>>t;
while(t--)
{
cin>>n;
switch (n)
{
case 1:push();
break;
case 2:pop();
break;
case 3:max_element();
break;
}
}
return 0;
}

这是一个使用 set 的实现

set用于存储从大到小的值， 所以第一个值总是最大值。O(1(

当有推送时，矢量项也被添加到集合中

当有弹出时，项目从集合中删除

输入集

6 test case 
1
10
1
43
1
12
1
55
2
3
43

最大值为 43

完整代码实现

#include <set>
#include <iostream>
#include <vector>
#include<algorithm>
using namespace std;
std::multiset<int,std::greater<int> > settrack;
vector<int> stack;
void push()
{
int element;
cin>>element;
stack.push_back(element);
settrack.insert(element);
}
void max_element()
{
auto max = settrack.begin();
cout<<*max<<endl;
}
void pop()
{
if(stack.empty())
{
return;
}
settrack.erase(settrack.find(stack.back()));
stack.pop_back();
}
int main() {
int t,n;
cin>>t;
while(t--)
{
cout<<"1:push  2:pop 3:max_element "<<endl;
cin>>n;
switch (n)
{
case 1:push();
break;
case 2:pop();
break;
case 3:max_element();
break;
}
}
return 0;
}

输出

6
1:push  2:pop 3:max_element 
1
10
1:push  2:pop 3:max_element 
1
43
1:push  2:pop 3:max_element 
1
12
1:push  2:pop 3:max_element 
1
55
1:push  2:pop 3:max_element 
2
1:push  2:pop 3:max_element 
3
43
Program ended with exit code: 0

PS：部分解决方案功劳归康拉德帕克查看评论

所有3 个pop、push和max_element运算的常时解：

#include <vector>
#include <iostream>
#include <limits>
#include <algorithm>
struct frame {
int value;
int max;
};
void push(std::vector<struct frame> &stack)
{
int element;
std::cin >> element;
stack.push_back({
element,
std::max(stack.back().max, element)
});
}
void pop(std::vector<struct frame> &stack)
{
if(stack.size() <= 1)
{
return;
}
stack.pop_back();
}
void max_element(const std::vector<struct frame> &stack)
{
std::cout << stack.back().max << std::endl;
}
int main() {
// Don't use global static variables, whenever possible make it local.
std::vector<struct frame> stack;
// Need to have a "default" maximum on the stack, use the lowest possible integer.
stack.push_back({
std::numeric_limits<int>::min(),
std::numeric_limits<int>::min()
});
int t,n;
std::cin >> t;
while(t--)
{
std::cin>>n;
switch (n)
{
case 1:
push(stack);
break;
case 2:
pop(stack);
break;
case 3:
max_element(stack);
break;
}
}
// Expect that only the "default" frame is left on the stack.
return stack.size() == 1 ? 0 : -1;
}

这是"动态规划"的典型例子。在可以免费获取部分解决方案时计算和存储部分解决方案，以便可以重复使用它们来计算将来的结果。

在这种情况下，在堆栈上存储每个单个帧的最大值是push操作中的恒定开销(您甚至几乎无法测量它(，但也允许在恒定时间内计算max_element。

无论stack已经包含哪些元素或多少元素，或者调用max_element的频率如何，性能都不会下降。

相关文章：