class Solution {

public:

    vector<vector<int>> levelOrder(Node* root) {

        vector<vector<int>> R;

        if (root != NULL)

        {

            //根进入队列

            queue<Node> q;

            q.push(Node(root->val, root->children));

            vector<int> L;

            L.push_back(root->val);

            R.push_back(L);

            vector<Node> N;

            while (!q.empty())

            {

                L.clear();

                N.clear();

                //清空队列，放入L

                while (!q.empty())

                {

                    Node livenode;

                    livenode = q.front();//取出队头元素作为当前扩展结点livenode

                    q.pop(); //队头元素出队

                    //将当前节点的所有孩子都放入L中

                    for (auto c : livenode.children)

                    {

                        L.push_back(c->val);

                        N.push_back(Node(c->val, c->children));

                    }

                }

                if (L.size() != )

                {

                    R.push_back(L);

                }

                //处理并入队

                for (int i = ; i < N.size(); i++)

                {

                    q.push(Node(N[i].val, N[i].children));

                }

            }

        }

        return R;

    }

};

class Solution {

public:

    vector<vector<int>> levelOrder(Node* root) {

        vector<vector<int>> res;

        if (!root)

            return res;

        queue<Node*> q;

        q.push(root);

        while (!q.empty())

        {

            vector<int> tmp;

            int n = q.size();

            for (int i = ; i<n; ++i)

            {

                Node* t = q.front(); q.pop();

                tmp.push_back(t->val);

                for (int j = ; j<t->children.size(); ++j)

                {

                    q.push(t->children[j]);

                }

            }

            res.push_back(tmp);

        }

        return res;

    }

};