\begin{algorithm}
                            \caption{Algoritmo GBILI}
                            \begin{algorithmic}
                            \PROCEDURE{GBILI}{}
                                \STATE generar una matriz de distancias $D$
                                \STATE generar una lista de puntos etiquetados $L$
                                \STATE establecer el parámetro $K$
                                \FOR{$i = 1$ \TO $|V|$}
                                    \FOR{$k = 1$ \TO $K$}
                                        \FOR{$j = 1$ \TO $|V|$}
                                            \IF{$D(v_i, v_j)$ es el k-ésimo vecino más cercano}
                                                \STATE Guardar $v_j$ en la \CALL{Lista-kNN}{$v_i$}
                                            \ENDIF
                                        \ENDFOR
                                    \ENDFOR
                                    \FOR{$j = 1$ \TO \CALL{Lista-kNN}{$v_i$}}
                                        \FOR{$k = 1$ \TO $K$}
                                            \IF{$D(v_j, v_i)$ es el k-ésimo vecino más cercano}
                                                \STATE Guardar $v_i$ en la \CALL{M-kNN}{$v_j$}
                                            \ENDIF
                                        \ENDFOR
                                    \ENDFOR
                                    \FOR{$j = 1$ \TO \CALL{M-kNN}{$v_i$}}
                                        \FOR{$l = 1$ \TO $|L|$}
                                            \IF{$D(v_i, v_j) + D(v_j, v_l)$ es mínimo}
                                                \STATE Guardar $e_{ij}$ en $G$
                                            \ENDIF
                                        \ENDFOR
                                    \ENDFOR
                                \ENDFOR
                                \STATE Realizar BFS y devolver \CALL{Componente}{$G$}
                                \FOR{$i = 1$ \TO $|V|$}
                                    \IF{\CALL{Componente}{$v_i$} $\notin L$}
                                        \FOR{$k = 1$ \TO \CALL{Lista-kNN}{$v_i$}}
                                            \IF{\CALL{Componente}{$v_k$} $\in L$}
                                                \STATE Guardar $e_{ik}$ en $G$
                                            \ENDIF
                                        \ENDFOR
                                    \ENDIF
                                \ENDFOR
                                \STATE devolver $G$
                            \ENDPROCEDURE
                            \end{algorithmic}
                            \end{algorithm}
                    

                        \begin{algorithm}
    \caption{Algoritmo RGCLI}
    \begin{algorithmic}
        \STATE \textbf{Input:} número de vecinos más cercanos $k_e$, número de vecinos RGCLI $k_i$, lista de ejemplos etiquetados $L$, conjunto de datos $X$, número de hilos $nt$
        \STATE \textbf{Output:} $GL$
        \STATE $V \leftarrow \text{crear un conjunto de vértices a partir de } X$
        \STATE $E, W \leftarrow \emptyset$
        \STATE $GL \leftarrow (V, E, W)$
        \STATE $kdtree \leftarrow \text{crear un Kd-tree a partir de } X$
        \STATE $kNN \leftarrow \text{dict}$
        \STATE $\mathcal{F} \leftarrow \text{dict}$
        \STATE $\mathcal{L} \leftarrow \text{dict}$
        \STATE $\mathcal{T} \leftarrow \{T_i : \cup_{i=1}^{nt} T_i = V, \cap_{i=1}^{nt} T_i = \emptyset \}$
        \FOR{$T_i \in \mathcal{T}$}
            \STATE $t \leftarrow \text{Thread}(\text{SearchKNN}(T_i, k_e, kdtree, kNN, \mathcal{L}))$
            \STATE $t.$\CALL{start}{}
        \ENDFOR
        \FOR{$T_i \in \mathcal{T}$}
            \STATE $t \leftarrow \text{Thread}(\text{SearchRGCLI}(GL, T_i, k_i, kNN, \mathcal{L}))$
            \STATE $t.\text{start}()$
        \ENDFOR
        \PROCEDURE{SearchKNN}{$T$, $k_e$, $kdtree$, $kNN$, $\mathcal{L}$}
            \FOR{vertex $v_i \in T$}
                \STATE $kNN[v_i] \leftarrow \text{kdtree.query}(v_i, k_e)$
                \STATE $\mathcal{L}[v_i] \leftarrow \text{encontrar puntos etiquetados más cercanos en } \mathcal{L}$
                \STATE $\mathcal{F}[v_i] \leftarrow \text{encontrar el k-ésimo vecino más lejano de } v_i$
            \ENDFOR
        \ENDPROCEDURE
        \PROCEDURE{SearchRGCLI}{$GL$, $T$, $k_i$, kNN, $\mathcal{L}$}
            \FOR{vertex $v_i \in T$}
                \STATE $\mathcal{E} \leftarrow \text{dict}$
                \FOR{vertex $v_j \in kNN[v_i]$}
                    \IF{$\text{dist}(v_i, v_j) \leq \text{dist}(v_j, \mathcal{F}[v_j])$}
                        \STATE $e \leftarrow (v_i, v_j)$
                        \STATE $\mathcal{E}[e] \leftarrow \text{dist}(v_i, v_j) + \text{dist}(v_j, \mathcal{L}[v_j])$
                    \ENDIF
                \ENDFOR
                \STATE $E^* \leftarrow \text{obtener } k_i \text{ aristas con menor puntuación de } \mathcal{E}$
                \STATE $E \leftarrow E^* \cup E$
                \STATE $ w(e) \leftarrow 1 \quad \forall \, e = (v_i, v_j) \in E^* $
            \ENDFOR
        \ENDPROCEDURE
    \end{algorithmic}
\end{algorithm}
                    

                            \begin{algorithm}
                            \caption{Algoritmo Local and Global Consistency}
                            \begin{algorithmic}
                                \PROCEDURE{LGC}{}
                                    \STATE Construir la matriz de similitud $W$.
                                    \STATE Construir la matriz $S = D^{-1/2}WD^{-1/2}$ donde $D$ es una matriz diagonal con su elemento $(i,i)$ igual a la suma de la fila $i$-ésima de $W$.
                                    \STATE Iterar $F(t+1) = \alpha SF(t) + (1-\alpha)Y$ hasta la convergencia, donde $\alpha$ es un parámetro en $(0, 1)$.
                                    \STATE Asumir un $F^*$ como el límite de la secuencia $\{F(t)\}$. Etiquetar cada punto $x_i$ con etiqueta $y_i = \arg \max_{j \leq c} F^*_{ij}$.
                                \ENDPROCEDURE
                            \end{algorithmic}
                        \end{algorithm}