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