C++ 树型简单数据操作

我们的任务是创建一个包含蓝色和白色体素的八叉树。然而，我只能够得到1级和2级输入的正确答案

详情：

p-表示大体素仍然需要划分为八分之一

• 体素是蓝色的
• w-体素是白色的

假设未指定任何颜色的体素为白色

输入：N表示要相互添加多少对

正确输出：

4096
3072
2048
1184

输入：

4
b
w
pbbbbwwww
pbwbwbwbw
pbpbbwwwwbbwwwwpbbwwwwbbb
ppbbwwwwbbbwwwwbpbbwwwwbb
pppbwwwwwbwwwwwwbwwwwwwbw
pwpwpwbwwwwwbwwwwwbwwwwwb

八叉树：

#include <iostream>
#include <queue> 
#include <string>
#include <cmath>
using namespace std; 

int N,lvl;
string s1,s2;
int index_a = 0;
int index_b = 0;
int VCount();

struct Node 
{ 
    char data;
    vector<Node *>child; 
}; 

Node *newNode(char data) 
{ 
    Node *temp = new Node; 
    temp->data = data;
    return temp; 
} 

Node *root;
int Voxels(vector<Node *> _root, int level);


int main() 
{ 
    cin>>N;
    for(int i=0;i<N;i++){
        root = newNode('w');
        cin>>s1;
        cin>>s2;
            lvl = 1;
            for(int j = 0; s1[j] != '\0'; j++){
                if(s1[j] == 'p')
                    lvl++;
            }
        cout<<VCount();
        cout<<'\n';
        index_a = 0;
        index_b = 0;
        lvl = 0;
    }     
return 0;   
}  

int VCount(){

    int _vox = 0;

        for(int l = 0; l < 8; l++)                                                                      //  Level 1
            (root->child).push_back(newNode('w'));   
                if (lvl == 1)
                return Voxels(root->child,1);

            if (lvl >= 2){
                 for(int k = 0; k < 8; k++){                                                             //  Level 2
                    for(int j = 0; j < 8; j++){
                        (root->child[k]->child).push_back(newNode('w'));
                    }
                 }
                _vox = Voxels(root->child,2);


            if (lvl >= 3){
                for(int l = 0; l < 8; ++l){
                    for(int k = 0; k < 8; k++){                                                         //  Level 3
                        for(int j = 0; j < 8; j++){
                            (root->child[l]->child[k]->child).push_back(newNode('w')); 
                        }

                    }
                    _vox += Voxels(root->child[l]->child,3);
                }


                if (lvl == 4){
                    for(int l = 0; l < 8; l++){      
                        for(int k = 0; k < 8; k++){                                                     //  Level 4
                            for(int j = 0; j < 8; j++){
                                for(int i = 0; i < 8; i++)
                                    (root->child[l]->child[k]->child[j]->child).push_back(newNode('w'));   
                            }
                        _vox += Voxels(root->child[l]->child[k]->child,4);
                    }
                  }
                }

            }

        }

    return _vox;  
}

int Voxels(vector<Node *> _root, int level){
int _voxels = 0;
int _ind;
int branch = 0;

        if(s1.size() == 1){
                if(s1[index_a] =='b' || s2[index_b] == 'b')
                    return 4096;
                else
                    return 0;
            }

        index_a++;
        index_b++;
        _ind = index_a;


            if(s1[index_a] != 'p' && s2[index_b] != 'p'){
                for(int i = index_a, j = 0; i < s1.size() && s1[i] != 'p'; i++,j++){
                    if(s1[i] == 'b'){
                        _root[branch]->child[j]->data = 'b';
                        _voxels++;
                    }
                    if(j==7){
                        branch++;
                        j=0;
                    }
                    index_a = i;  
                }
                for(int i = index_b, j = 0; i < s2.size() && s2[i] != 'p'; i++, j++){
                    if(s2[i] == 'b' && s1[_ind] != 'b'){
                        _root[branch]->child[j]->data = 'b';
                        _voxels++;
                    }
                    if(j==7){
                        branch++;
                        j=0;
                    }
                   _ind++;
                }
            }

return (4096/pow(8,level-1))*_voxels;
}

#包括
#包括
#包括
#包括
使用名称空间std；
int N，lvl；
字符串s1、s2；
int索引_a=0；
int索引_b=0；
int VCount（）；
结构节点
{ 
字符数据；
矢量儿童；
}; 
节点*新节点（字符数据）
{ 
Node*temp=新节点；
温度->数据=数据；
返回温度；
} 
节点*根；
int体素（向量_根，int级）；
int main（）
{ 
cin>>N；
对于（int i=0；i>s1；
cin>>s2；
lvl=1；
对于（int j=0；s1[j]！='\0'；j++）{
如果（s1[j]=“p”）
lvl++；
}
coutchild[k]->child.push_-back（newNode（'w'））；
}
}
_体素=体素（根->子体，2）；
如果（lvl>=3）{
对于（int l=0；l<8；++l）{
对于（int k=0；k<8；k++）{//3级
对于（int j=0；j<8；j++）{
（root->child[l]->child[k]->child）；
}
}
_vox+=体素（根->子体[l]->子体，3）；
}
如果（lvl==4）{
对于（int l=0；l<8；l++）{
对于（int k=0；k<8；k++）{//4级
对于（int j=0；j<8；j++）{
对于（int i=0；i<8；i++）
（root->child[l]->child[k]->child[j]->child）；
}
_体素（根->子[l]->子[k]->子，4）；
}
}
}
}
}
返回_vox；
}
整数体素（向量_根，整数级）{
int _体素=0；
国际工业；
int分支=0；
如果（s1.size（）==1）{
if（s1[索引a]=“b”| s2[索引b]=“b”）
返回4096；
其他的
返回0；
}
索引_a++；
索引_b++；
_ind=指数a；
如果（s1[索引a]！='p'和s2[索引b]！='p'）{
对于（int i=index_a，j=0；i子[j]->data='b'；
_体素++；
}
如果（j==7）{
branch++；
j=0；
}
指数a=i；
}
对于（int i=index_b，j=0；i子[j]->data='b'；
_体素++；
}
如果（j==7）{
branch++；
j=0；
}
_ind++；
}
}
返回（4096/pow（8，1级））*体素；
}

我看不出您在哪里读取输入的最后四行。输出代表什么？您成对地读取它们并将它们相加。B+B=B，B+W=B，W+W=W:）如果您谈论的是输入，如果它们没有被读取，那么就没有什么可添加的。如果你说的是输出，这些都是数字——这些数字代表什么？我看不出你在哪里读到输入的最后四行。输出代表什么？您成对地读取它们并将它们相加。B+B=B，B+W=B，W+W=W:）如果您谈论的是输入，如果它们没有被读取，那么就没有什么可添加的。如果你说的是输出，这些都是数字——这些数字代表什么？