/// <summary>
        /// Verifica se dois pares linha/coluna são compatíveis.
        /// </summary>
        /// <param name="first">O primeiro par.</param>
        /// <param name="second">O segundo par.</param>
        /// <returns>Verdadeiro caso os pares sejam compatíveis e falso caso contrário.</returns>
        private bool AreCompatible(CoordsElement first, CoordsElement second)
        {
            if (first.Row == second.Column)
            {
                if (second.Row < first.Row)
                {
                    return(true);
                }
            }

            if (first.Column == second.Column)
            {
                if (second.Row < first.Row)
                {
                    return(true);
                }
            }

            if (first.Column == second.Row)
            {
                if (second.Column > first.Column)
                {
                    return(true);
                }
            }

            return(false);
        }
        /// <summary>
        /// Obtém a matriz de compatiblidade através dos custos.
        /// </summary>
        /// <param name="costsMatrix">A matriz dos custos.</param>
        /// <param name="sortedElements">
        /// O contentor para o conjunto de elementos ordenados por custo.
        /// </param>
        /// <returns>
        /// A matriz de compatibilidade ordenada de acordo como os elementos se encontram na matriz.
        /// </returns>
        private BitArraySymmetricMatrix GetCompatibilityMatrix(
            ILongSparseMathMatrix <CostsType> costsMatrix,
            InsertionSortedCollection <CoordsElement> sortedElements)
        {
            // Efectua a contagem de elementos atribuídos na matriz.
            var elementsNumber = 0;

            foreach (var line in costsMatrix.GetLines())
            {
                foreach (var column in line.Value)
                {
                    ++elementsNumber;
                }
            }

            var result           = new BitArraySymmetricMatrix(elementsNumber, elementsNumber, false);
            var processedColumns = new List <CoordsElement> [costsMatrix.GetLength(0)];

            for (int i = 0; i < processedColumns.Length; ++i)
            {
                processedColumns[i] = new List <CoordsElement>();
            }

            var currentIndex = 0;

            foreach (var line in costsMatrix.GetLines())
            {
                foreach (var column in line.Value)
                {
                    if (column.Key != line.Key)
                    {
                        var element = new CoordsElement(line.Key, column.Key, currentIndex, column.Value);
                        sortedElements.Add(element);
                        var processedColumn = processedColumns[column.Key];
                        foreach (var processed in processedColumn)
                        {
                            result[processed.CompatibilityIndex, currentIndex] = true;
                        }

                        processedColumn.Add(element);

                        // Processa o pivor
                        processedColumn = processedColumns[line.Key];
                        foreach (var processed in processedColumn)
                        {
                            result[processed.CompatibilityIndex, currentIndex] = true;
                        }

                        ++currentIndex;
                    }
                }
            }


            return(result);
        }