算法思想总结：栈

一、栈的经典应用：波兰表达式与逆波兰表达式

          我们平时看到的 1+2*（3-4*5）+6/7 叫做中缀表达式，平时我们习惯用这个计算的原因是我们可以整体地去看到这个表达式并且清楚地知道各个运算符的优先级，但是计算机并不一定知道，因为他总是从前往后去遍历这个表达式。如上面这个例子，当按照计算机的逻辑去扫描了1+2的时候，并不敢直接去进行运算，因为可能后面存在一个优先级更高的操作符会优先进行计算。甚至有些时候还会出现括号这一种可以改变操作符优先级的符号！！所以这个时候，为了能够解决这个问题，就有了波兰表达式（前缀表达式）和逆波兰表达式（后缀表达式）。

     前缀表达式：操作符+操作数+操作数

     中缀表达式：操作数+操作符+操作数

     后缀表达式：操作数+操作数+操作符

1.1 后缀表达式转中缀表达式

 1.2 中缀表达式转后缀表达式

 二、逆波兰表达式求值

. - 力扣（LeetCode）

class Solution {
public:
    int evalRPN(vector<string>& tokens) 
    {
      stack<int> st;//栈帮助我们计算
      for(auto&s:tokens) //遍历字符串
      {
        if(s=="+"||s=="-"||s=="*"||s=="/")//如果是操作符的话，取栈顶两个元素计算
        {
           //先取右操作数，再取左操作数
           int right=st.top(); st.pop();
           int left=st.top();st.pop();
           //因为可能会有不同的情况，所以要用一个swich去计算
           switch(s[0])
           {
            case '+':
              st.push(left+right);
              break;
            case '-':
              st.push(left-right);
              break;
            case '*': 
              st.push(left*right);
              break;
            case '/': 
               st.push(left/right);
               break;
           }
        }
        else st.push(stoi(s));如果不是操作符的话，利用stoi将字符串转化成数字并入栈 
      }
      return st.top();
    }
};

三、基本计算器II

. - 力扣（LeetCode）

class Solution {
public:
    int calculate(string s) 
    {
      vector<int> v;
      char op='+';
      int i=0,n=s.size();
      while(i<n)
      {
        if(s[i]==' ') ++i;
        else if(isdigit(s[i]))
        {
            int temp=0;//先取出这个数字
            while(i<n&&isdigit(s[i]))  temp=temp*10+(s[i++]-'0');
            //这时候要根据当前op的情况去判断怎么操作
            switch(op)
            {
              case '+':v.push_back(temp);break;
              case '-':v.push_back(-temp);break;
              case '*':v.back()*=temp;break;
              case '/':v.back()/=temp;break;
            }
        }
        else op=s[i++];//是操作符就直接改掉op
      }
      return accumulate(v.begin(),v.end(),0);
    }
};

四、基本计算器I 

. - 力扣（LeetCode）

class Solution {
public:
    void calc(stack<int> &numst, stack<char> &ops)
    {
                int right=numst.top();numst.pop();
                int left=numst.top();numst.pop();
                char op=ops.top();ops.pop();
                numst.push(op=='+'?left+right:left-right);//根据op去计算
    }

    void replace(string&s)
    {
        //去掉空格
        int pos=s.find(" ");
        while(pos!=-1) 
        {
            s.erase(pos,1);
            pos=s.find(" ");
        }
    }
   
    int calculate(string s)
    {
        //利用双栈
        stack<int> numst;//存放所有数字
        //防止第一个数为负数
        numst.push(0);//防止第一个数是负数
        stack<char> ops;//存放所有运算符
        replace(s);
        int n=s.size();int i=0;
        while(i<n)
        {
            if(s[i]=='(')  ops.push(s[i++]);  //如果是左括号 直接压栈。
            else if(s[i]==')')  //如果是右括号，就计算到左括号为止
            {
               while(ops.top()!='(')  calc(numst,ops);  //还没遍历到左括号的时候
                     //循环结束说明遇到(了 此时跳过即可
                   ops.pop();//弹出左括号
                   ++i;//去下一个位置
            }
            else if(isdigit(s[i]))//遇到数字的时候
            {
                int temp=0;
                while(i<n&&isdigit(s[i])) temp=temp*10+(s[i++]-'0');
                numst.push(temp);
            }
            else //此时遇到操作符了
            {  
                if(i>0&&s[i]=='-'&&s[i-1]=='(') numst.push(0);//应对括号后面带负数的情况
                while(!ops.empty()&& ops.top() != '(')//放入之前先把能算的给算了
                        calc(numst, ops);
                ops.push(s[i++]);//操作符入栈
            }
        }
        //最后要将栈中的所有的都计算一便
        while(!ops.empty())   calc(numst,ops);
        return numst.top();//最后剩下的就是最终结果
    }
};

五、有效的括号

. - 力扣（LeetCode）

class Solution {
public:
    bool isValid(string s)
    {
      //用一个栈来模拟 
      stack<char> st;
      for(auto&ch:s)
      {
        if(ch=='('||ch=='{'||ch=='[') st.push(ch);//遇到左括号肯定是无脑入栈的
        else //此时肯定遇到了右括号 
        {
            //有两种情况，一种是右括号比左括号多，此时栈可能为空,就肯定不符合了
            if(st.empty()) return false;
            //还有一种情况是前面的对不上
            else if(ch==')'&&st.top()!='(' ||ch=='}'&&st.top()!='{'||ch==']'&&st.top()!='[') return false;
            else st.pop();
        }
      }
      return st.empty();//可能左括号比右括号多，导致最后栈里面还有剩下
    }
};

六、删除字符串中所有相邻重复项

. - 力扣（LeetCode）

class Solution {
public:
    string removeDuplicates(string s) 
    {
        string ret;
        for(auto&ch:s)
        {
            if(ret.size()&&ret.back()==ch) ret.pop_back();
            else ret.push_back(ch);
        }
        return ret;
    }
};

七、比较含退格的字符串

. - 力扣（LeetCode）

class Solution {
public:
    bool backspaceCompare(string s, string t) 
    {
       //没遇到# 就入栈，遇到#就出栈
       return stringchange(s)==stringchange(t);
    }
    string stringchange(string&s)
    {
        string ret;
        for(auto &ch:s)
        {
            if(ch!='#') ret.push_back(ch);
            else if(ret.size()) ret.pop_back();
        }
        return ret;
    }
};

八、字符串解码

. - 力扣（LeetCode）

该题也是利用到基本计算器的解题思想

class Solution {
public:
    string decodeString(string s)
    {
     stack<int> numst;//数字栈
     stack<string> strst;//字符串栈
     strst.push("");//先插入一个空字符串 防止越界访问
     int i=0,n=s.size();
     while(i<n)
     {
        if(isdigit(s[i])) //遇到数字，提取出来放到字符串栈中
        {
          int temp=0;
          while(isdigit(s[i])) temp=temp*10+(s[i++]-'0');
          numst.push(temp);
        }
        else if(s[i]=='[')//遇到[将后面的字符串提取出来放入字符串栈中
        {
            ++i;//先跳过这个括号
            string str;
           while(islower(s[i])) str+=s[i++];
           strst.push(str);
        }
        else if(s[i]==']')//遇到]就提取栈顶元素进行计算
        {
            int k=numst.top();numst.pop();
            string str=strst.top();strst.pop();
            for(int j=0;j<k;++j) strst.top()+=str;
            ++i;//跳过这个右括号
        }
        else //遇到单独的字符，直接加进去
            strst.top()+=s[i++];
     }    
     return strst.top();
    }
};

九、最小栈

. - 力扣（LeetCode）

 策略3解题：

class MinStack {
public:
    MinStack() {

    }
    
    void push(int val) {
         st.push(val);
         //如果当前栈为空，或者是当前的数比栈顶元素小或者相等，就入minst
         if(minst.empty()||minst.top()>=val) minst.push(val);
    }
    
    void pop() {
         //如果当前数和minst的栈顶元素相等，就得出
         if(minst.top()==st.top()) minst.pop();
          st.pop();
    }
    
    int top() {
      return st.top();
    }
    
    int getMin() {
       return minst.top();
    }
    private:
        stack<int> st;
        stack<int> minst;
    };

策略4解题：存键值对

class MinStack {
public:
    MinStack() {

    }
    
    void push(int val) {
         st.push(val);
         //如果当前栈为空，或者是当前的数比栈顶元素小或者相等，就入minst
         if(minst.empty()||minst.top().first>val) minst.push(pair(val,1));
         else if(minst.top().first==val) ++minst.top().second;
    }
    
    void pop() {
         if(minst.top().first==st.top()) 
         {
            if(minst.top().second==1) minst.pop();
            else --minst.top().second;
         }
          st.pop();
    }
    
    int top() {
      return st.top();
    }
    
    int getMin() {
       return minst.top().first;
    }
    private:
        stack<int> st;
        stack<pair<int,int>> minst;//第一个代表最小值，第二个代表其数量
    };

十、验证栈序列

. - 力扣（LeetCode）

class Solution {
public:
    bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
       stack<int> st;
        int popi=0;
       for(auto&num:pushed)
        {
            st.push(num);
            while(!st.empty()&&st.top()==popped[popi])//可能会连续出多个
                {
                     st.pop();
                    ++popi;
                }
        }
                  //return popi==popV.size();
                  return st.empty();
    }
};

十一、1-n所有可能的出栈序列

如果入栈序列是1-n 将所有可能的出栈序列存储起来并返回。

//尝试输出所有出栈序列
vector<vector<int>> ret;//记录所以出栈序列
int n;//记录入栈范围
void dfs(int i, vector<int> push, vector<int> pop) //深搜+回溯
{
	if (i == n + 1)
	{
		if (pop.size() == n)
		{
			ret.push_back(pop);
		}
		return;
	}
	//入栈
	push.push_back(i);
	//可以选择出栈，或者不出栈
	//选择不出栈
	dfs(i + 1, push, pop);
	//选择出栈
	while (!push.empty())
	{
		pop.push_back(push.back());
		push.pop_back();
		dfs(i + 1, push, pop);//用形参去记录路径
	}
}
vector<vector<int>> poporder(int _n)
{
	n = _n;
	dfs(1, {}, {});
	return ret;
}

我们来测试一下： 

void test()
{
	vector<vector<int>> ret = poporder(5);
	for (int i = 0; i < ret.size(); ++i)
	{
		for (int j = 0; j < ret[i].size(); ++j)
			cout << ret[i][j] << " ";
		cout << endl;
	}
	cout << "入栈序列为";
	for (int i = 1; i <= n; ++i) cout << i;
	cout << "的出栈序列一共有" << ret.size() << "种" << endl;;
}

 十二、利用栈实现基本计算器

目标：实现一个基本计算器，能够满足以下条件的运算：

  1. 操作数：支持正数、负数、多位数计算
  2. 操作符：支持（ ） + - * / % ^ 这些操作符

设计思路来源：中缀表达式和后缀表达式

具体的设计思路：

  1. 所需要的数据结构——双栈+哈希表（设为全局变量）。其中一个存储整型的栈帮助我们存储操作数，另一个存储字符类型的栈帮助我们存储操作符，然后哈希表帮我们确立操作符的优先级。
  2. + -的映射关系为1,* / %的映射关系为2，^的映射关系为3，按照上述方式存进哈希表来映射操作符优先级。然后对于左括号和右括号，我们进行特殊处理。
  3. 因为我们输入的是字符串，所以有些时候需要用空格分割操作符和操作数，所以我们在计算前的第一步就是封装一个replace函数来帮助我们删除字符串中的所用空格。
  4. 封装一个calc函数，帮助我们在满足计算条件的时候，取出数字栈的头两个元素分别作为右操作数和左操作数，再取出字符栈的栈顶操作符进行计算，用一个swtich语句根据不同的操作符类型执行不同的运算逻辑
  5. 进行分类讨论：
  1. 如果遇到(，无脑进栈
  2. 如果遇到 ),不断进行calc直到遇到( ,并将(弹出
  3. 如果遇到数字，因为要实现的是多位数的计算，所以可能后面的数字是挨着连在一起的，此时我们要想将该数提取出来，如果下一位也是数字，就将当前的数*10+下一个数字，当不再是数字的时候，将提取出来的数字入数字栈。
  4. 如果遇到操作符，首先要处理一个特殊情况就是，如果当前操作符是- 并且前一个操作符时( 说明该-表示的是负数而不是减，所以为了运算的合理性，我们要在数字中压个0进去。  然后我们的新操作符要跟栈顶的操作符进行比较，如果运算的优先级较低或相等，就得将栈顶的操作符弹出来进行计算，即进行calc，不断重复该过程，直到新加入的操作符优先级比栈顶元素高，此时再将新操作符入栈
  5. 细节处理：第一个数可能是负数，所以我们也要按照（4）中的逻辑一样，再数字栈上先压个0进去。
  6. 最后当整个字符串遍历结束之后，我们将栈中剩余的操作数和操作符拿出来运算，最后留在数字栈顶的元素。就是我们的最终结果。
  7. 该计算器的小缺陷：（1）不支持浮点数（2）整型除不尽会舍去。
using namespace std;
unordered_map<char, int> map{{'+',1},{'-',1} ,{'*',2} ,{'/',2} ,{'%',2} ,{'^',3}}; //建立哈希映射，建立各操作符的优先级。
stack<int> nums;//创建一个数字栈，存储操作数信息
stack<char> ops;//创建一个字符栈，存储操作数信息
//对于左括号，我们直接入栈，等待右括号的匹配
//一旦遇到右括号，就需要计算()内的结果，直到遇到左括号然后弹出
//计算器
void calc()
{
    if (nums.size() < 2 || ops.empty())
    {
        cout << "表达式有误" << endl;
        return;//少于两个操作数或没有操作符，说明输入的表达式有误
    }
    //先取右操作数，再取左操作数，根据操作符进行运算
    int right = nums.top(); nums.pop();
    int left = nums.top(); nums.pop();
    char op = ops.top(); ops.pop();
    switch (op)
    {
    case '+':nums.push(left + right); break;
    case '-':nums.push(left - right); break;
    case '*':nums.push(left * right); break;
    case '/':nums.push(left / right); break;
    case '%':nums.push(left % right); break;
    case '^':nums.push((int)pow(left, right)); break;
    default:cout << "操作符有误" << endl; break;//如果都不符合，就是操作符有误
    }
}
void replace(string& s) //删除字符串中所有空格
{
    int index = 0;
    if (!s.empty())
    {
        while ((index = s.find(' ', index)) != string::npos)
        {
            s.erase(index, 1);
        }
    }
}
//可以计算整型(正负数均可,也可以是多位数)    有关()、+、-、*、/、%、^的运算      
//小缺陷：1、不支持小数   2、因为是整型,/除不尽小数会被省去
int calculate(string s)//基本计算器的实现
{
    replace(s);//先去掉空格 方便我们计算
    int i = 0, n = s.size();//用来遍历字符串
    nums.push(0);//先补个0，目的是防止第一个数是负数
    while (i < n)
    {
      //如果遇到( 直接压栈即可
        if (s[i] == '(') ops.push(s[i++]);
      //如果遇到右括号，将一直到（的结果进行计算
        else if (s[i] == ')')
        {
            while (ops.top() != '(') calc();
            //此时遇到左括号，弹出左括号并++
            ops.pop();
            ++i;
        }
        //如果遇到数字，将数字提出出来
        else if (isdigit(s[i]))
        {
           //将数字提取出来放到nums中
            int temp = 0;
            while (i < n && isdigit(s[i])) temp = temp * 10 + (s[i++] - '0');
            nums.push(temp);
        }
        //如果遇到操作符
        else
        {
           //如果是(-的情况，补0，保证运算合理
            if (i > 0 && s[i] == '-' && s[i - 1] == '(') nums.push(0);
            //在放入这个操作符之前，把能算的给算了
            while (!ops.empty() && ops.top() != '(')//放入之前先把能算的给算了
            {
                char prev = ops.top();
                if (map[prev] >= map[s[i]])  calc();//如果我比前面的运算符优先级低或者相等，就将前面运算符弹出来计算。
                else break;
            }
            //然后将新的操作符入栈
            ops.push(s[i++]);
        }
    }
    //整个过程遍历结束后，将栈中的剩下的进行计算
    while (!ops.empty()) calc();
    return nums.top();//此时栈顶留下来的就是最终结果
}

十三、利用栈实现十进制转任意进制 

stack<int> st;//帮助我们存储进制数
string basechage(int n, int x) 
{
    string ret;
    if (x < 2 && x>36) { cout << "不存在" << x << "进制数" << endl; return ret; }
    while (n) //当n变成0的时候
    {
        st.push(n % x);
        n/=x;
    }
    //此时栈中存储的就是 最终结果 
    while (!st.empty())
    {
        int top = st.top();
        if ( top>=0 && top <= 9) //如果是0-9,直接插入
            ret.push_back(top + '0');
        else //此时不是1-9，要用字母来替代
            ret.push_back(top + 55);
        st.pop();
    }
    return ret;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/564184.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

截断堆积柱状图绘制教程

截断堆积柱状图绘制教程

本教程原文链接&#xff1a;截断堆积柱状图绘制教程 欢迎大家转载&#xff01;&#xff01;&#xff01;&#xff01; 本期教程 写在前面 堆积柱状图是柱状图的常见类型之一&#xff0c;也是平时使用概率较高的图形之一。我们前期发布了很多个柱状图的绘制教程&#xff0c;若你…
阅读更多...
FPGA Quartus IP核 打开使用

FPGA Quartus IP核 打开使用

两种Quartus版本下的IP核&#xff0c;从使用者的角度来看仅仅是配置界面不同&#xff0c;在参数设置和使用方法上基本一致。本文以“MegaWizard Plug-In Manager”中的FIR Compiler IP核使用为例。 Quartus的FIR IP核属于收费IP&#xff0c;如果是个人学习使用需要对IP核单独破…
阅读更多...
xhEditor实现WORD粘贴图片自动上传

xhEditor实现WORD粘贴图片自动上传

1.下载示例&#xff1a; 从官网下载 http://www.ncmem.com/webapp/wordpaster/versions.aspx 从gitee中下载 https://gitee.com/xproer/wordpaster-php-xheditor1x 2.将插件目录复制到项目中 3.引入插件文件 定义插件图标 初始化插件&#xff0c;在工具栏中添加插件按钮 效果…
阅读更多...
Java——三层架构

Java——三层架构

在我们进行程序设计以及程序开发时&#xff0c;尽可能让每一个接口、类、方法的职责更单一些&#xff08;单一职责原则&#xff09;。 单一职责原则&#xff1a;一个类或一个方法&#xff0c;就只做一件事情&#xff0c;只管一块功能。 这样就可以让类、接口、方法的复杂度更低…
阅读更多...
贪心 | | 将数组和减半的最少操作数

贪心 | | 将数组和减半的最少操作数

目录 将数组和减半的最少操作数 除 2 将数组和减半的最少操作数 2208. 将数组和减半的最少操作次数 - 力扣&#xff08;LeetCode&#xff09;https://leetcode.cn/problems/minimum-operations-to-halve-array-sum/description/ 由题意可知&#xff0c;我们可以遍历数组&…
阅读更多...
【C++类和对象】初始化列表与隐式类型转换

【C++类和对象】初始化列表与隐式类型转换

&#x1f49e;&#x1f49e; 前言 hello hello~ &#xff0c;这里是大耳朵土土垚~&#x1f496;&#x1f496; &#xff0c;欢迎大家点赞&#x1f973;&#x1f973;关注&#x1f4a5;&#x1f4a5;收藏&#x1f339;&#x1f339;&#x1f339; &#x1f4a5;个人主页&#x…
阅读更多...
OpenLayers6实战，OpenLayers鼠标拖拽方式绘制半圆环形（半圆扇形）

OpenLayers6实战，OpenLayers鼠标拖拽方式绘制半圆环形（半圆扇形）

专栏目录： OpenLayers实战进阶专栏目录 前言 本章讲解如何使用OpenLayers特殊图形绘制，通过鼠标拖拽方式来绘制出半圆环形（半圆扇形）的功能，效果像磁铁一样的半圆弧。 上一章中我们以及实现了四分之一圆环形的特殊图形绘制《OpenLayers6实战，OpenLayers实现鼠标拖拽方式…
阅读更多...
【C++】——类与对象引入和认识

【C++】——类与对象引入和认识

创作不易&#xff0c;多多支持&#xff01; 前言 有了上一篇博客的基础以后&#xff0c;就正式进入C类和对象的领域了&#xff0c;如果看完本篇文章对你有用&#xff0c;还请多多支持&#xff01;&#xff01;&#x1f618;&#x1f618; 一 面向过程和面向对象 1.面向过程 …
阅读更多...
DFS和回溯专题：组合总和

DFS和回溯专题：组合总和

DFS和回溯专题&#xff1a;组合总和 题目链接: 39.组合总和 参考题解&#xff1a;代码随想录 题目描述 代码纯享版 class Solution {public List<List<Integer>> list_all new ArrayList();public List<Integer> list new ArrayList();public List<…
阅读更多...
基于贝叶斯算法的机器学习在自动驾驶路径规划中的应用实例

基于贝叶斯算法的机器学习在自动驾驶路径规划中的应用实例

目录 第一章 引言 第二章 数据准备 第三章 贝叶斯路径规划模型训练 第四章 路径规划预测 第五章 路径执行 第六章 实验结果分析 第一章 引言 自动驾驶技术的发展带来了自动驾驶车辆的出现&#xff0c;而路径规划作为自动驾驶车辆的关键功能之一&#xff0c;对于确定最佳行…
阅读更多...
2024年Q1季度平板电视行业线上市场销售数据分析

2024年Q1季度平板电视行业线上市场销售数据分析

Q1季度平板电视线上市场表现不如预期。 根据鲸参谋数据显示&#xff0c;2024年1月至3月线上电商平台&#xff08;京东天猫淘宝&#xff09;平板电视累计销量约360万件&#xff0c;环比下降12%&#xff0c;同比下降30%&#xff1b;累计销售额约99亿元&#xff0c;环比下降28%&a…
阅读更多...
OSI网络七层协议＜随手笔记＞

OSI网络七层协议＜随手笔记＞

1.OSI OSI&#xff08;Open System Interconnect&#xff09;&#xff0c;即开放式系统互连。 一般都叫OSI参考模型&#xff0c;是ISO组织在1985年研究的网络互连模型。该体系结构标准定义了网络互连的七层框架&#xff08;物理层、数据链路层、网络层、传输层、会话层、表示层…
阅读更多...
Java工程maven中排包exclude的操作

Java工程maven中排包exclude的操作

一、背景 在开发项目时依赖了新的jar包&#xff0c;结果工程启动时报错了&#xff0c;此时应该是包依赖冲突的问题。 二、确定冲突的依赖包 执行mvn clean install&#xff0c;通过报错信息来确定冲突的jar包信息 三、排除冲突包的方案 有两种冲突的情况&#xff1a; 1&am…
阅读更多...
电梯节能的推广意义

电梯节能的推广意义

之前关于电梯能量回馈设备&#xff0c;小伍已经做了很多介绍&#xff0c;那么小伙伴们&#xff0c;他的推广意义你真的了解了么&#xff1f; 第一&#xff1a;节电降耗&#xff0c;电梯在运行过程中会产生大量的惯性能量&#xff0c;这些能量如果不被利用就会浪费。能量回馈技术…
阅读更多...
【C语言】每日一题，快速提升（5）！

【C语言】每日一题，快速提升（5）！

&#x1f525;博客主页&#x1f525;&#xff1a;【 坊钰_CSDN博客 】 欢迎各位点赞&#x1f44d;评论✍收藏⭐ 目录 1. strlen函数 2. strcpy函数 3. strcat函数 题目&#xff1a;模拟实现 strlen--strcpy--strcat--三个函数 1. strlen函数 字符串计算 #include <stdio.h…
阅读更多...
[笔试训练](二)

[笔试训练](二)

004 牛牛的快递_牛客题霸_牛客网 (nowcoder.com) 题目&#xff1a; 题解&#xff1a; 使用向上取整函数ceil()&#xff0c;&#xff08;记得添加头文件#include<cmath>&#xff09; #include <iostream> #include <cmath> using namespace std;int main(…
阅读更多...
TensorFlow文件读取 --TFRecords文件

TensorFlow文件读取 --TFRecords文件

TFRecords文件 是一种二进制文件&#xff0c;能够很好的利用内存&#xff0c;更方便复制和移动&#xff0c;并且不需要单独的标签文件 使用步骤 1&#xff09;获取数据 2&#xff09;将数据填入到Example协议内存块&#xff08;protocol buffer&#xff09; 3&#xff09;将协…
阅读更多...
冯唐成事心法笔记

冯唐成事心法笔记

文章目录 卷首语　管理是一生的日常&#xff0c;成事是一生的修行PART 1　知己　用好自己的天赋如何管理自我用好你的天赋成大事无捷径如何平衡工作和生活做一个真猛人做自己熟悉的行业掌控情绪如何对待妒忌和贪婪如何战胜自己&#xff0c;战胜逆境真正的高手都有破局思维有时候…
阅读更多...
利用动态规划在有向图上实现高效语音识别算法

利用动态规划在有向图上实现高效语音识别算法

在现代语音识别系统中&#xff0c;动态规划是一种非常关键的技术。它能够帮助我们将复杂的语音信号转换为可理解的文字信息。在本文中&#xff0c;我们将探讨如何使用动态规划方法在有向图上实现语音识别。我们将首先介绍问题的背景和基本概念&#xff0c;然后提供一个高效的算…
阅读更多...
基于开源CrashRpt与微软开源Detours技术深度改造的异常捕获库分享

基于开源CrashRpt与微软开源Detours技术深度改造的异常捕获库分享

目录 1、异常捕获模块概述 2、为什么需要异常捕获模块&#xff1f; 3、在有些异常的场景下是没有生成dump文件的 4、开源异常捕获库CrashRpt介绍 5、对开源库CrashRpt的改进 C软件异常排查从入门到精通系列教程&#xff08;专栏文章列表&#xff0c;欢迎订阅&#xff0c;持…
阅读更多...
最新文章

Copyright @ 2022~2023