HHUOJ 1321

1321: 恶搞指数

时间限制: 1 Sec  内存限制: 32 MB
提交: 129  解决: 61
[提交][状态][讨论版][命题人:外部导入]

题目描述

小明的朋友过生日，小明准备了一件礼物，不过小明想恶搞一下他的朋友，所以他准备了一堆盒子，其中有一个盒子里面装了礼物。盒子里面可以再放零个或者多个盒子。假设放礼物的盒子里不再放其他盒子。
用()表示一个盒子，B表示礼物，小明想让你帮他算出恶搞指数，即最少需要拆多少个盒子才能拿到礼物。

输入

输入包含多组测试数据。每组测试数据是一个长度不大于1000,只包含（，）和 B 三种字符的字符串，代表小明设计的礼物透视图。
题目保证每个透视图都是合法的。

输出

对于每组测试，请在一行里面输出恶搞指数。

样例输入

((((B)()))())
(B)

样例输出4

1



括号嵌套的扩展题。
经历了多次优化，终于把内存压榨到最小。



思路一：利用STL栈。
调用封装好的STL非常舒服，但内存用量排名垫底。

#include <iostream>
#include <stack>
#include <string>
using namespace std;
int main(void)
{
    string exp;
    while (cin >> exp)
    {
        stack<char> S;
        for (int i = 0; i < exp.size(); ++i)
        {
            if (exp[i] == 'B')
                break;
            else
            {
                switch (exp[i]) {
                case '(':
                    S.push(exp[i]);
                    break;
                case ')':
                    S.pop();
                    break;
                }
            }
        }
        printf("%d
", S.size());
    }
    return 0;
}

思路一优化：手写链表模拟栈

本以为会比现成的STL好一点，但貌似还不如STL（境界太低）。可能异常处理占了一部分内存。

代码取自数据结构应用 - 栈，真的从头实现的话太不划算了。

#include <iostream>
#include <string>
using namespace std;
struct Node
{
    int value;
    Node *next;
};

//创建了一个头节点为S的链栈,S将一直表示栈顶元素
Node *CreatStack()
{
    Node *S = new Node;
    S->next = NULL;
    return S;
}

int IsEmpty(Node *S)
{
        return S->next == NULL;
}
void Pop(Node *S)
{
    Node *FirstCell;
    if(IsEmpty(S))//空栈，将返回异常
        cout << "Empty Stack" << endl;
    else
    {
        FirstCell = S->next;//取出栈顶
        S->next = S->next->next;//使S指向新的栈顶
        delete FirstCell;//删除原栈顶，完成出栈
    }
}
void Push(int x, Node *S)
{
    Node *TempCell = new Node;
    if (TempCell == NULL)
        cout << "Out of space" << endl;
    else
    {
        TempCell->value = x;//把x赋值给value
        TempCell->next = S->next;//将新节点设为栈顶
        S->next = TempCell;//使S指向新的栈顶
    }
}
int Print(Node *S)
{
    int cnt = 0;
    Node *p = S->next;//将p初始化为栈顶
    while (p != NULL)
    {
        cnt++;
        p = p->next;
    }
    return cnt;
}

int main(void)
{
    string exp;
    while (cin >> exp)
    {
        Node *S = CreatStack();
        for (int i = 0; i < exp.size(); ++i)
        {
            if (exp[i] == 'B')
                break;
            else
            {
                switch (exp[i]) {
                case '(':
                    Push(exp[i],S);
                    break;
                case ')':
                    Pop(S);
                    break;
                }
            }
        }
        printf("%d
", Print(S));
    }
    return 0;
}

思路二：重新思考。

想不通前面的人怎么能把内存压缩到那么小，肯定是算法本身不够优（甩锅给STL失败...）

前面的思路基本是基于括号嵌套这一母题来做的，借鉴的是栈混洗。

而这道题与母题不同的是，这次给出的表达式一定是括号匹配的，而且多出了一个礼物B。这不就是天然的二分法吗...

前面的思路中，要拆开的层数就是最后留在栈中的左括号的数量，但其实仔细观察，B前面的左括号数和B后面的右括号数应该是一样多的。

实现如下：

#include <stdio.h>
#include <iostream>
#include <string>
using namespace std;
int main()
{
    string s;
    int num, i;
    while (cin>>s)
    {
        num = 0;
        for (i = 0; i < s.size(); i++)
        {
            if (s[i] == 'B')break;
            else if (s[i] == '(')num++;
            else num--;
        }
        printf("%d
", num);
    }
    return 0;
}

思路二优化：string及cin优化

对于dalao来说根本不存在这一步优化。

但实际上思路二实现后与思路一相比进步还不够。

完全抛弃C++改用纯C后能进一步优化。

#include <stdio.h>
#include <string.h>
int main()
{
    char exp[1000];
    while (scanf_s("%s",exp) != EOF)
    {
        int num = 0;
        int i;
        for (i = 0; i < strlen(exp); i++)
        {
            if (exp[i] == 'B')break;
            else if (exp[i] == '(')num++;
            else num--;
        }
        printf("%d
", num);
    }
    return 0;
}

这样应该是把C的效率压榨到头了。

题是水题，但还是有一点启发的，那就是，我再也不要手写STL了（逃