DS实验题 最大最小

题目：

算法设计：

计算最小值算法：
设置一个flag，flag为1的时候代表遇到*号；

遇到数字时：
flag为0进栈；
flag为1的时候，从栈顶提出一个元素和当前元素运算，结果进栈

最后对栈进行加法运算，得到结果，mod。

计算最大值算法：

设置一个flag，flag为1的时候代表遇到+号；
设置一个累加器pt；

遇到数字时
1.flag为0进栈；
2.flag为1的时候，需要对之前flag的状态进行判断：
flag_pre若为1，更新累加器；
flag_pre若为0，从栈顶压出一个元素，更新累加器；

遇到乘号时
1.flag为0，continue；
2.flag为1，将flag置0，累加器结果进栈，累加器置0；

遍历字符串结束时，特判累加器是否为0，不为0进栈；

最后对栈进行乘法运算，得到结果，mod。

代码：

//
//  main.cpp
//  最大最小
//
//  Created by wasdns on 16/11/10.
//  Copyright © 2016年 wasdns. All rights reserved.
//

#include <iostream>
#include <cstdio>
#include <string>
#include <string.h>
#include <stack>
using namespace std;

#define modn 870764322

char str[505];                      //字符串

/*
 计算最小值算法：
    设置一个flag，flag为1的时候代表遇到*号；
 
    遇到数字时：
        flag为0进栈；
        flag为1的时候，从栈顶提出一个元素和当前元素运算，结果进栈
    
    最后对栈进行加法运算，得到结果，mod。
 */

int Nomalcal()
{
    stack<int> ins;
    
    int i, cal_result = 0;
    
    int flag = 0;
    
    for (i = 0; i < strlen(str); i++)
    {
        if (str[i] == '(' || str[i] == ')') continue;   //遇到括号略过
        
        if (str[i] >= '0' && str[i] <= '9')             //遇到数字
        {
            int pt = str[i] - '0';
            
            if (flag == 1) {                            //flag=1
                
                int pre = ins.top();
                ins.pop();
                
                int64_t temp = pt;                      //为防止溢出，进行转换
                temp *= pre;
                temp %= modn;
                
                pt = (int)temp;
                
                flag = 0;
            }
            
            ins.push(pt);
        }
        
        else if (str[i] == '*') {                       //遇到乘号
            
            flag = 1;
            
            continue;
        }
        
        else continue;                                  //遇到加号
    }
    
    while (!ins.empty()) {                              //计算结果
        
        cal_result += ins.top();
        cal_result %= modn;
        
        ins.pop();
    }
    
    return cal_result;
}

/*
 计算最大值算法：
 
 设置一个flag，flag为1的时候代表遇到+号；
 设置一个累加器pt；
 
 遇到数字时
 1.flag为0进栈；
 2.flag为1的时候，需要对之前flag的状态进行判断：
    flag_pre若为1，更新累加器；
    flag_pre若为0，从栈顶压出一个元素，更新累加器；
 
 遇到乘号时
 1.flag为0，continue；
 2.flag为1，将flag置0，累加器结果进栈，累加器置0；
 
 遍历字符串结束时，特判累加器是否为0，不为0进栈；
 
 最后对栈进行乘法运算，得到结果，mod。
 */

int maxcal()
{
    stack<int> ins;
    
    int i, cal_result = 1;                              //注意，结果初始置1
    
    int flag = 0;
    
    int pt = 0;
    
    for (i = 0; i < strlen(str); i++)
    {
        if (str[i] == '(' || str[i] == ')') continue;   //遇到括号
        
        if (str[i] >= '0' && str[i] <= '9')             //遇到数字
        {
            if (flag == 1) {                            //1.flag=1
                
                pt += (str[i] - '0');
                
            }
            
            else {                                      //2.flag=0
                
                pt = (str[i] - '0');
                
                ins.push(pt);
                
                pt = 0;
                
            }
            
            continue;
        }
        
        else if (str[i] == '*') {                       //遇到乘号
            
            if (flag == 1) {                            //flag=1时
                
                flag = 0;
                
                ins.push(pt);
                
                pt = 0;
                
            }
            
            continue;
        }
        
        else {                                          //遇到加号时
            
            if (flag == 0) {
                
                int pre = ins.top();
                ins.pop();
                
                pt += pre;
            }
            
            flag = 1;
            
            continue;
        }
    }
    
    if (pt != 0) {                                      //特判
        ins.push(pt);
    }
    
    int64_t temp = 1;
    
    while (!ins.empty()) {                              //计算结果，防止溢出
        
        temp *= (ins.top());
        temp %= modn;
        
        ins.pop();
    }
    
    cal_result = (int)temp;
    
    return cal_result;
}

int main()
{
    scanf("%s", str);
    
    getchar();
    
    cout << maxcal() << endl;
    
    cout << Nomalcal() << endl;
    
    return 0;
}

结果：

小结：

上面的代码交上去是编译错误，需要把里面的int64_t类型换成__int64

注意：防止溢出；因此在计算结果的时候(一般在乘法的地方)，进行一次类型的转换，用int64存储，取mod之后再转为int。

2016/11/10