UVa #12219 Common Subexpression Elimination (例题11-1)

这题和普通的表达式树很像,但如果按照一般的做法(用L、R代表范围),会TLE,因为重复了太多无用的扫描


这题树中的结点对应的子树都是二叉树,不存在只有一个儿子的情况。输入的字符串中也只有两种情况,结点名字后面紧跟一个左括号的,和不跟括号的。

因此很容易判断一个结点是否为叶子结点:只要在原字符串中看他后面有没有紧跟着左括号就行了。如果有,立刻递归建树作为左子树。因为有左子树就一定有右子树,所以左子树建完后就可以从字符串中左子树结束的位置开始建右子树了。因此不需要从左到右扫描寻找逗号来分割左右子树。


至于树的判重,参考UVa #12096 The SetStack Computer (例题5-5)


另外字符串的对比是缓慢的。鉴于这道题最多只有四个小写字母,也就是最多26*4种情况,我们完全可以用整数来代替字符串。一种比较简单的做法是把字符串看成一个四位的27进制数,并抛弃0,因为0和0000相等。


Run Time: 1.075s

#define UVa  "LT11-1.12219.cpp"		//Common Subexpression Elimination
char fileIn[30] = UVa, fileOut[30] = UVa;

#include<cstring>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<iostream>
#include<map>

using namespace std;

void decode(int a) {
    vector<char> result;
    while(a) { result.push_back(a%27+'a'-1); a/=27; }       //%27+1
    for(int i = result.size() - 1; i >= 0; i --) {
        cout<<result[i];
    }
}

struct Tree {
    int rcode, lch, rch;        //code of root. treeid of left and right sub-tree.
    Tree(){}
    Tree(int a, int b, int c):rcode(a), lch(b), rch(c) { }
    bool operator < (const Tree& rhs) const {
        if(rcode == rhs.rcode){
            if(lch == rhs.lch) return rch < rhs.rch;
            return lch < rhs.lch;
        }
        return rcode < rhs.rcode;
    }
};

//Global Variables. Reset upon Each Case!
const int maxn = 50000+5;
int T, treecnt, vis[maxn], ans[maxn], cnt;
char str[5*(maxn+10000)], *p;
Tree trees[maxn];
map<Tree, int> tree_map;
/////

int getTreeID(Tree& t) {
    if(tree_map.count(t)) return tree_map[t];
    else {
        Tree& v = trees[treecnt];
        v = t;
        return tree_map[t] = treecnt++;
    }
}

int parse() {
    int lch = -1, rch = -1;
    int name = 0;
    while(isalpha(*p)) {
        name = name*27 + (*p-'a'+1);
        p ++;
    }
    if(*p == '(') {
        p++;
        lch = parse();
        p ++;
        rch = parse();
        p ++;
    }
    Tree tmp = Tree(name, lch, rch);
    return getTreeID(tmp);
}

void print_ans(int id) {
    if(ans[id] != -1) cout<<ans[id];
    else {
        ans[id] = ++cnt;
        decode(trees[id].rcode);
        if(trees[id].lch != -1) {
            cout<<"(";
            print_ans(trees[id].lch);
            cout<<",";
            print_ans(trees[id].rch);
            cout<<")";
        }
    }
}

int main() {
    memset(vis, -1, sizeof(vis));
    cin>>T;
    while(T--) {
        treecnt = cnt = 0;;
        tree_map.clear();
        scanf("%s", str);
        p = str;
        memset(ans, -1, sizeof(ans));
        print_ans(parse());
        cout<<endl;
    }

    return 0;
}


`-O2` 是 GCC(GNU Compiler Collection)中的一个优化选项,用于在编译时对代码进行较高级别的优化。它在性能与编译时间之间取得了良好的平衡,是生产环境中常用的优化级别之一。 ### `-O2` 优化做了什么? GCC 的 `-O2` 优化选项会启用以下类型的优化(但不仅限于): 1. **指令调度(Instruction Scheduling)**:重新排列指令以更好地利用 CPU 流水线。 2. **循环展开(Loop Unrolling)**:减少循环的控制开销。 3. **常量传播(Constant Propagation)**:将变量替换为已知常量。 4. **死代码消除(Dead Code Elimination)**:移除不会被执行的代码。 5. **函数内联(Inlining)**:将小函数的代码直接插入调用处,减少函数调用开销。 6. **寄存器分配优化(Register Allocation)**:尽可能将变量放在寄存器中,而不是栈上。 7. **公共子表达式消除(Common Subexpression Elimination)**:避免重复计算相同的表达式### 示例代码与编译对比 #### 示例 C 代码: ```c #include <stdio.h> int compute(int a, int b) { int result = 0; for (int i = 0; i < 1000; i++) { result += a * b + i; } return result; } int main() { printf("%d\n", compute(5, 10)); return 0; } ``` #### 编译命令: - **不优化**: ```bash gcc -O0 -S code.c -o code_O0.s ``` - **使用 `-O2` 优化**: ```bash gcc -O2 -S code.c -o code_O2.s ``` 你可以通过对比生成的汇编代码(`code_O0.s` 和 `code_O2.s`)看到优化带来的变化,例如循环被展开、不必要的操作被删除等。 ### 使用 `-O2` 的建议 - **适用场景**:适用于大多数性能敏感的项目,尤其是发布版本。 - **调试问题**:由于优化会改变代码结构,可能导致调试困难,建议调试时使用 `-O0`。 - **编译时间**:比 `-O1` 更耗时,但比 `-O3` 更快。 --- ### 相关问题 1. `-O1`, `-O2`, `-O3` 优化级别之间的区别是什么? 2. 如何查看 GCC 编译时启用了哪些优化选项? 3. `-O2` 优化会影响调试信息的准确性吗? 4. 在 CMake 中如何设置 `-O2` 作为默认优化级别?
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值