// ???????????????
        private SortedDictionary<int, int> AmountConnectedSubGraphsPerLevel(int numberNode,
            int level)
        {
            var retArray = new SortedDictionary<int, int>();

            if (level == container.Level)
            {
                retArray[1] = 1;
                return retArray;
            }
            BitArray node = container.TreeNode(level, numberNode);

            int powPK = Convert.ToInt32(Math.Pow(container.BranchIndex,
                container.Level - level - 1));
            var engForConnectedComponent = new EngineForConnectedComp();
            ArrayList arrConnComp =
                engForConnectedComponent.GetCountConnSGruph(container.nodeMatrixList(node),
                    container.BranchIndex);
            for (int i = 0; i < arrConnComp.Count; i++)
            {
                var countConnCompi = (int)arrConnComp[i];
                if (retArray.Keys.Contains(countConnCompi * powPK))
                    retArray[countConnCompi * powPK] += 1;
                else
                    retArray.Add(countConnCompi * powPK, 1);
            }

            return retArray;
        }
        private SortedDictionary<int, int> AmountConnectedSubGraphs(int level, int numberNode)
        {
            SortedDictionary<int, int> retArray = new SortedDictionary<int, int>();

            if (level == container.Level)
            {
                retArray[1] = 1;
                return retArray;
            }

            int branchSize = container.Branches[level][numberNode];
            int branchStart = container.FindBranches(level, numberNode);
            BitArray node = container.TreeNode(level, numberNode);

            bool haveOne = false;
            for (int i = 0; i < branchSize; ++i)
            {
                if (container.CountConnectedBlocks(node, branchSize, i) == 0)
                {
                    SortedDictionary<int, int> array = AmountConnectedSubGraphs(level + 1, branchStart + i);

                    foreach (KeyValuePair<int, int> kvt in array)
                    {
                        if (retArray.Keys.Contains(kvt.Key))
                            retArray[kvt.Key] += kvt.Value;
                        else
                            retArray.Add(kvt.Key, kvt.Value);
                    }
                }
                else
                {
                    haveOne = true;
                }
            }

            if (haveOne)
            {
                EngineForConnectedComp engForConnectedComponent = new EngineForConnectedComp();
                Dictionary<int, ArrayList> nodeMadrixList = container.nodeMatrixList(node, branchSize);

                Dictionary<int, ArrayList> connComp = engForConnectedComponent.
                    GetConnSGruph(nodeMadrixList, branchSize);
                int countConnElements = 0;
                for (int i = 0; i < connComp.Count; ++i)
                {
                    if (connComp[i].Count > 1)
                    {
                        countConnElements = 0;
                        for (int j = 0; j < connComp[i].Count; ++j)
                        {
                            countConnElements += container.CountLeaves(level + 1, branchStart + (int)connComp[i][j]);
                        }

                        if (retArray.Keys.Contains(countConnElements))
                        {
                            retArray[countConnElements] += 1;
                        }
                        else
                        {
                            retArray.Add(countConnElements, 1);
                        }
                    }
                }
            }

            return retArray;
        }
        private SortedDictionary<int, int> AmountConnectedSubGraphs(int numberNode, int level)
        {
            var retArray = new SortedDictionary<int, int>();

            if (level == container.Level)
            {
                retArray[1] = 1;
                return retArray;
            }
            BitArray node = container.TreeNode(level, numberNode);

            bool haveOne = false;
            for (int i = 0; i < container.BranchIndex; i++)
            {
                if (container.CountConnectedBlocks(node, i) == 0)
                {
                    SortedDictionary<int, int> array = AmountConnectedSubGraphs(numberNode * container.BranchIndex + i,
                        level + 1);

                    foreach (var kvt in array)
                    {
                        if (retArray.Keys.Contains(kvt.Key))
                            retArray[kvt.Key] += kvt.Value;
                        else
                            retArray.Add(kvt.Key, kvt.Value);
                    }
                }
                else
                    haveOne = true;
            }

            if (haveOne)
            {
                int powPK = Convert.ToInt32(Math.Pow(container.BranchIndex, container.Level - level - 1));
                var engForConnectedComponent = new EngineForConnectedComp();
                ArrayList arrConnComp = engForConnectedComponent.GetCountConnSGruph(container.nodeMatrixList(node),
                    container.BranchIndex);
                for (int i = 0; i < arrConnComp.Count; i++)
                {
                    var countConnCompi = (int)arrConnComp[i];
                    if (retArray.Keys.Contains(countConnCompi * powPK))
                        retArray[countConnCompi * powPK] += 1;
                    else
                        retArray.Add(countConnCompi * powPK, 1);
                }
            }

            return retArray;
        }