Mobile Computing（UVA 1354）

网址如下：

Mobile Computing - UVA 1354 - Virtual Judge (vjudge.net)

（第三方网站）

 

一道关于二叉树的题

一种是从上到下构建二叉树，但是要枚举子集

另一种是从下到上构建二叉树

 

我用的是从下到上构建二叉树的方法

说实话，我觉得从上到下构建二叉树但是要枚举子集会比较简单，用二进制枚举法就可以解决快速枚举子集的问题

而从下到上构建二叉树嘛……

 

这里可以讲一下我的思考的经过：

刚开始我是直接设结点，然后用一个容器来储存枚举的二叉树的根节点，然后每次递归枚举的时候选取两个随机结点结合成一个树，直到最后只剩下一个结点

但是遇到了储存的问题，因为我选择的是list容器，所以最好不要对目前要操作的根节点列进行改变，因为会涉及迭代器失效的问题。这意味着每一层递归枚举都要复制上一层的根节点列。然后又遇上了储存的问题，因为传统二叉树是用数组或new或者内存池来使用内存的，这个的话，每次复制都要把上一层的根节点下面的“树枝”也全部复制，当时我就在烦恼怎么释放内存（现在倒是有思路了）。但是可以想见，大量的复制，会对内存的使用和效率造成巨大影响，不是一个好的算法。

然后我就根据从上到下构建二叉树想到了从下到上构建二叉树的更有效率的做法：

先想想从上到下构建二叉树的特点是什么，我想出来的就是：可以根据根节点得到已经组成的整个树，因此只需要在每次递归枚举的时候记下根节点的地址，而且在继续构建树的时候，只要在原有的树的基础上加上新的叶子结点就行了，而取消造成的变化只需要删除新的叶子结点就行了

现在我们把这个特点用在从下到上构建二叉树上：我们可以根据叶子结点得到已经组成的整个树，因此只需要在每次递归枚举的时候记下所有的叶子结点的地址，而且在继续构建树的时候，只要在原有的多个树的基础上把两个树的根节点连到新的一个根节点就行了，而取消造成的变化只需要删除新的根节点就行了

如何实现？

结构如下：

const int maxn = 6;
struct Node{
    int w, c;//重量 颜色
    double d;//到根结点的距离，负号代表在左边，正号代表在右边
    Node * f, * l, * r;//父节点，左子节点，右子节点
    Node(){d = 0.0; f = l = r = NULL;}
}nodes[maxn];

没错，只要在每个结点记录父节点的地址就可以实现

而Node中的color特质是用来一定程度上防止重复枚举的

 

相关的操作如下：

Node * newnode(void){return new Node();}
void paintcolor(Node * u, int c){
    if(u == NULL) return;
    u->c = c;
    paintcolor(u->l, c); paintcolor(u->r, c);
}
void dupdate(Node * u, double _d){
    if(u == NULL) return;
    u->d += _d;
    dupdate(u->l, _d); dupdate(u->r, _d);
}
Node * getroot(Node * v){
    if(v->f == NULL) return v;
    return getroot(v->f);
}
void deletenode(Node * root){
    root->l->f = root->r->f = NULL;
    paintcolor(root->r, freecolor.top()); freecolor.pop();
    //更新子节点到根节点的距离
    double ld = 1.0 * root->r->w / (root->l->w + root->r->w), rd = 1.0 - ld;
    dupdate(root->l, ld); dupdate(root->r, -rd);
    delete root;
}
Node * newroot(Node * rootl, Node * rootr){
    Node * root = newnode();
    root->l = rootl; root->r = rootr; rootl->f = rootr->f = root;//结点之间的关系构建
    root->w = rootl->w + rootr->w;//重量初始化
    //颜色的处理
    root->c = rootl->c; freecolor.push(rootr->c);
    paintcolor(rootr, rootl->c);
    //更新子节点到根节点的距离
    double ld = 1.0 * rootr->w / (rootl->w + rootr->w), rd = 1.0 - ld;
    dupdate(rootl, -ld); dupdate(rootr, rd);
    return root;
}

 

最后是整个的代码：

#include<cstdio>
#include<stack>
#include<set>
using namespace std;
const int maxn = 6;
struct Node{
    int w, c;//重量 颜色
    double d;//到根结点的距离，负号代表在左边，正号代表在右边
    Node * f, * l, * r;//父节点，左子节点，右子节点
    Node(){d = 0.0; f = l = r = NULL;}
}nodes[maxn];
stack<int> freecolor;
double r, ans;
int s;

Node * newnode(void){return new Node();}
void paintcolor(Node * u, int c){
    if(u == NULL) return;
    u->c = c;
    paintcolor(u->l, c); paintcolor(u->r, c);
}
void dupdate(Node * u, double _d){
    if(u == NULL) return;
    u->d += _d;
    dupdate(u->l, _d); dupdate(u->r, _d);
}
Node * getroot(Node * v){
    if(v->f == NULL) return v;
    return getroot(v->f);
}
void deletenode(Node * root){
    root->l->f = root->r->f = NULL;
    paintcolor(root->r, freecolor.top()); freecolor.pop();
    //更新子节点到根节点的距离
    double ld = 1.0 * root->r->w / (root->l->w + root->r->w), rd = 1.0 - ld;
    dupdate(root->l, ld); dupdate(root->r, -rd);
    delete root;
}
Node * newroot(Node * rootl, Node * rootr){
    Node * root = newnode();
    root->l = rootl; root->r = rootr; rootl->f = rootr->f = root;//结点之间的关系构建
    root->w = rootl->w + rootr->w;//重量初始化
    //颜色的处理
    root->c = rootl->c; freecolor.push(rootr->c);
    paintcolor(rootr, rootl->c);
    //更新子节点到根节点的距离
    double ld = 1.0 * rootr->w / (rootl->w + rootr->w), rd = 1.0 - ld;
    dupdate(rootl, -ld); dupdate(rootr, rd);
    return root;
}

void envm(void){
    //检测是否超出房间宽度
    double mind = 6.0, maxd = -6.0, newr;
    for(int i = 0; i < s; i++){
        mind = min(mind, nodes[i].d);
        maxd = max(maxd, nodes[i].d);
    }
    newr = maxd - mind;
    if(newr >= r) return;
    //树构建完成，更新答案
    if(freecolor.size() == s - 1){ans = (ans > newr) ? ans : newr; return;}
    //树未构建完，继续枚举构建
    set<int> cl;
    for(int i = 0; i < s; i++){
        if(cl.count(nodes[i].c)) continue;
        cl.insert(nodes[i].c);
        set<int> cr;
        for(int j = 0; j < s; j++){
            if(nodes[j].c == nodes[i].c || cr.count(nodes[j].c)) continue;
            cr.insert(nodes[j].c);
            //往上构建树
            Node * root = newroot(getroot(&nodes[i]), getroot(&nodes[j]));
            envm();
            deletenode(root);
        }
    }
}

int main(void)
{
    int kase; scanf("%d", &kase);
    while(kase--){
        scanf("%lf%d", &r, &s);
        for(int i = 0; i < s; i++){
            scanf("%d", &nodes[i].w);
            nodes[i].c = i; nodes[i].d = 0.0;
            nodes[i].f = nodes[i].l = nodes[i].r = NULL;
        }
        ans = -1.0;
        envm();
        if(ans + 1 < 1e-5) printf("-1\n");
        else printf("%.16lf\n", ans);
    }

    return 0;
}

不过说实话，我最后提交的时候给我的结果是WA。题目说我的答案不能与标准答案的误差超过1e-8，但是debug的时候，我的答案基本上都满足条件

为什么说基本上呢？

因为，他比较debug的时候，并没有考虑这个误差，是考虑是不是完全相等的

而且，他一个测试点中样例个数都是50000个，放到我的电脑里面，跑了10分钟才跑了5000个（虽然提交代码用时是330ms，是因为我电脑太拉了？）

所以他并没有把误差超过1e-8的样例给我，而是把所有的不同的给了我，而这些样例，有5000多个。。。

虽然我可以写个代码来比较，但是想到我的电脑甚至没跑完50000个样例，还是算了

 

写了挺久的，找个时间再把从上到下构建二叉树写了

 

补充：在颜色判重的时候可以使用哈希表，因为用set集合的效率相对较慢