public static void main(String[] args) {
Trie trie = new Trie();
trie.add("Causal");
trie.add("absurd");
trie.add("crappy");
trie.add("spooky");
trie.add("bullcrap");
trie.add("bullshit");
trie.add("Africa");
trie.add("Asia");
trie.add("Osiris");
trie.add("Heman");
trie.add("OhMyGod");
trie.printAll();
}
/**
* 11) Colección de profesores distintos que trabajan para algún departamento de una universidad.
*
* @param universidad - universidad de la que buscar profesores que trabajan para algún
* departamento suyo
* @return una lista enlazada de las entidades que son profesores que trabajan en algún
* departamento del parámetro universidad
*/
public ListaEnlazada<String> profesoresDeUniversidad(String universidad) {
ListaEnlazada<String> resultado = new ListaEnlazada<String>();
int idUniversidad = arbolSujetosObjetos.obtenerValor(universidad);
if (idUniversidad != -1) {
Arista a;
int nodoDepartamento;
boolean recorridos[] = new boolean[sujetos + objetos];
for (int i = 0; i < sujetos + objetos; ++i) recorridos[i] = false;
// Búsqueda las aristas entrantes de idUniversidad con peso 'departamentoDe'
for (int i = 0; i < nodosEntrantes.get(idUniversidad).size(); i++) {
a = nodosEntrantes.get(idUniversidad).get(i);
if (a.propiedad == idPropiedadDepartamentoDe && !recorridos[a.verticeObjetivo]) {
nodoDepartamento = a.verticeObjetivo;
recorridos[nodoDepartamento] = true;
// El nodo es un departamento, buscar las aristas entrantes con peso 'trabajaPara'
for (int j = 0; j < nodosEntrantes.get(nodoDepartamento).size(); j++) {
a = nodosEntrantes.get(nodoDepartamento).get(j);
if (a.propiedad == idPropiedadTrabajaPara && !recorridos[a.verticeObjetivo]) {
recorridos[a.verticeObjetivo] = true;
resultado.insertLast(listaSujetosObjetos.get(a.verticeObjetivo));
}
}
}
}
}
return resultado;
}
/**
* 10) Colección de estudiantes distintos que cursan alguna asignatura de la que es encargado un
* determinado profesor.
*
* @param profesor - profesor encargado de las asignaturas de las que se buscan los estudiantes
* @return una lista enlazada de las entidades que son estudiantes de asignaturas que imparte el
* parámetro profesor
*/
public ListaEnlazada<String> estudiantesDelProfesor(String profesor) {
ListaEnlazada<String> resultado = new ListaEnlazada<String>();
int idProfesor = arbolSujetosObjetos.obtenerValor(profesor);
if (idProfesor != -1) {
Arista a;
int nodoAsignatura;
boolean recorridos[] = new boolean[sujetos + objetos];
for (int i = 0; i < sujetos + objetos; ++i) recorridos[i] = false;
// Búsqueda las aristas salientes de idProfesor con peso 'encargadoDe'
for (int i = 0; i < nodosSalientes.get(idProfesor).size(); ++i) {
a = nodosSalientes.get(idProfesor).get(i);
if (a.propiedad == idPropiedadEncargadoDe && !recorridos[a.verticeObjetivo]) {
nodoAsignatura = a.verticeObjetivo;
recorridos[nodoAsignatura] = true;
// El nodo es una asignatura, buscar las aristas entrantes con peso 'cursa'
for (int j = 0; j < nodosEntrantes.get(nodoAsignatura).size(); ++j) {
a = nodosEntrantes.get(nodoAsignatura).get(j);
if (a.propiedad == idPropiedadCursa && !recorridos[a.verticeObjetivo]) {
recorridos[a.verticeObjetivo] = true;
resultado.insertLast(listaSujetosObjetos.get(a.verticeObjetivo));
}
}
}
}
}
return resultado;
}
public List<String> findWords(char[][] board, String[] words) {
Trie trie = new Trie();
for (String word : words) {
trie.insert(word);
}
int m = board.length;
int n = board[0].length;
boolean[][] visited = new boolean[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
dfs(board, visited, "", i, j, trie);
}
}
return new ArrayList<String>(result);
}
/**
* 8) Colección de entidades que son de una determinada clase.
*
* @param clase - clase de la que se buscan las entidades
* @return una lista enlazada de las entidades que son del parámetro clase
*/
public ListaEnlazada<String> entidadesDeClase(String clase) {
ListaEnlazada<String> resultado = new ListaEnlazada<String>();
int idClase = arbolSujetosObjetos.obtenerValor(clase);
if (idClase != -1) {
boolean recorridos[] = new boolean[sujetos + objetos];
for (int i = 0; i < sujetos + objetos; ++i) recorridos[i] = false;
// Búsqueda en profundidad hacia atrás
DFSinversa(idClase, recorridos, resultado);
}
return resultado;
}
/**
* 7b) Colección de las clases que son superclase de una clase.
*
* @param clase - clase de la que se buscan las superclases
* @return una lista enlazada de las superclases del parámetro clase
*/
public ListaEnlazada<String> superClasesDe(String clase) {
ListaEnlazada<String> resultado = new ListaEnlazada<String>();
int idClase = arbolSujetosObjetos.obtenerValor(clase);
if (idClase != -1) {
boolean recorridos[] = new boolean[sujetos + objetos];
for (int i = 0; i < sujetos + objetos; ++i) recorridos[i] = false;
// Búsqueda en profundidad
DFS(idClase, idPropiedadSubClaseDe, recorridos, resultado);
}
return resultado;
}
public void dfs(char[][] board, boolean[][] visited, String str, int i, int j, Trie trie) {
int m = board.length;
int n = board[0].length;
if (i >= m || j >= n || i < 0 || j < 0) return;
if (visited[i][j]) return;
str = str + board[i][j];
// System.out.println(str);
if (!trie.startsWith(str)) return;
if (trie.search(str)) {
result.add(str);
}
visited[i][j] = true;
dfs(board, visited, str, i - 1, j, trie);
dfs(board, visited, str, i + 1, j, trie);
dfs(board, visited, str, i, j - 1, trie);
dfs(board, visited, str, i, j + 1, trie);
visited[i][j] = false;
}
/**
* 2) Colección de sentencias distintas del almacén que tienen un sujeto determinado.
*
* @param sujeto - sujeto cuyas sentencias han de devolverse
* @return Una lista enlazada de sentencias sin repeticiones que tienen Sujeto como sujeto
*/
public ListaEnlazada<String> sentenciasDistintasPorSujeto(String sujeto) {
ListaEnlazada<String> coleccionSentencias = new ListaEnlazada<String>();
int index = arbolSujetosObjetos.obtenerValor(sujeto);
if (index != -1) {
// Si el sujeto no existe, devuelve una lista vacía
Arista prov;
for (int i = 0; i < nodosSalientes.get(index).size(); ++i) {
prov = nodosSalientes.get(index).get(i);
coleccionSentencias.insertLast(
listaSujetosObjetos.get(index)
+ " "
+ listaPropiedades.get(prov.propiedad)
+ " "
+ listaSujetosObjetos.get(prov.verticeObjetivo)
+ " .");
}
}
return coleccionSentencias;
}
/**
* 6) Colección ordenada de todas las sentencias que aparecen en el almacén.
*
* @return Un array con las sentencias del almacén según el orden descrito en el enunciado
*/
public ListaArray<String> sentenciasOrdenadas() {
ListaArray<Integer> valores = arbolSujetosObjetos.recorrerEnProfundidad();
ListaArray<String> sentenciasEnOrden = new ListaArray<String>(sentencias);
int nodo;
Arista arista;
for (int i = 0; i < valores.size(); ++i) {
nodo = valores.get(i);
for (int j = 0; j < nodosSalientesOrdenados.get(nodo).size(); ++j) {
arista = nodosSalientes.get(nodo).get(nodosSalientesOrdenados.get(nodo).get(j));
for (int k = 0; k < arista.repeticiones; ++k)
sentenciasEnOrden.insertLast(
listaSujetosObjetos.get(nodo)
+ " "
+ listaPropiedades.get(arista.propiedad)
+ " "
+ listaSujetosObjetos.get(arista.verticeObjetivo)
+ " .");
}
}
return sentenciasEnOrden;
}
/**
* Constructora Carga las sentencias en el almacén desde el fichero especificado.
*
* @param nombreDeArchivo de texto desde el que leer las entidades
*/
private Almacen(String nombreDeArchivo) throws IOException {
// Inicializa los atributos de la clase
nodosEntrantes = new ListaArray<ListaArray<Arista>>();
nodosSalientes = new ListaArray<ListaArray<Arista>>();
sujetos = objetos = propiedades = sentencias = 0;
arbolSujetosObjetos = new Trie();
arbolPropiedades = new Trie();
listaSujetosObjetos = new ListaArray<String>();
listaPropiedades = new ListaArray<String>();
// Variables auxiliares
int tempArista;
Arista a;
// Lee las sentencias desde el fichero y las añade al trie y a la lista de nodos del grafo
Fichero.abrir(nombreDeArchivo, false, false);
String sentencia, sujeto, propiedad, objeto;
int idSujeto, idPropiedad, idObjeto;
StringTokenizer tokenizador;
sentencia = Fichero.leerSentencia();
while (sentencia != null) {
tokenizador = new StringTokenizer(sentencia);
sujeto = tokenizador.nextToken();
propiedad = tokenizador.nextToken();
objeto = tokenizador.nextToken();
sentencias++;
// Insertar sujeto en el trie
idSujeto = arbolSujetosObjetos.insertar(sujeto, sujetos + objetos);
if (idSujeto == sujetos + objetos) {
// Agregar al array de int -> String
listaSujetosObjetos.insertLast(sujeto);
// Añadir su hueco en las listas de adyacencia
nodosEntrantes.insertLast(new ListaArray<Arista>());
nodosSalientes.insertLast(new ListaArray<Arista>());
// Incrementar contador
sujetos++;
}
// Insertar propiedad en el trie
idPropiedad = arbolPropiedades.insertar(propiedad, propiedades);
if (idPropiedad == propiedades) {
// Agregar al array de int -> String
listaPropiedades.insertLast(propiedad);
// En caso de ser una propiedad especial, guardar su valor entero
if (propiedad.equals(propiedadEs)) idPropiedadEs = idPropiedad;
else if (propiedad.equals(propiedadSubClaseDe)) idPropiedadSubClaseDe = idPropiedad;
else if (propiedad.equals(propiedadCursa)) idPropiedadCursa = idPropiedad;
else if (propiedad.equals(propiedadEncargadoDe)) idPropiedadEncargadoDe = idPropiedad;
else if (propiedad.equals(propiedadDepartamentoDe)) idPropiedadDepartamentoDe = idPropiedad;
else if (propiedad.equals(propiedadTrabajaPara)) idPropiedadTrabajaPara = idPropiedad;
// Incrementar contador
propiedades++;
}
// Insertar objeto en el trie
idObjeto = arbolSujetosObjetos.insertar(objeto, sujetos + objetos);
if (idObjeto == sujetos + objetos) {
// Agregar al array de int -> String
listaSujetosObjetos.insertLast(objeto);
// Añadir su hueco en las listas de adyacencia
nodosEntrantes.insertLast(new ListaArray<Arista>());
nodosSalientes.insertLast(new ListaArray<Arista>());
// Incrementar contador
objetos++;
}
// Inserta la arista en la primera lista de adyacencia, o añade una repetición
tempArista = nodosSalientes.get(idSujeto).find(new Arista(idObjeto, idPropiedad));
if (tempArista == -1)
nodosSalientes.get(idSujeto).insertLast(new Arista(idObjeto, idPropiedad));
else nodosSalientes.get(idSujeto).get(tempArista).repeticiones++;
// Lee la siguiente sentencia
sentencia = Fichero.leerSentencia();
}
Fichero.cerrar();
// Crear la segunda lista de adyacencia a partir de la primera
for (int i = 0; i < nodosSalientes.size(); i++) {
for (int j = 0; j < nodosSalientes.get(i).size(); j++) {
a = nodosSalientes.get(i).get(j);
nodosEntrantes
.get(a.verticeObjetivo)
.insertLast(new Arista(i, a.propiedad, a.repeticiones));
}
}
// Ordenar las aristas salientes de cada nodo
nodosSalientesOrdenados = new ListaArray<ListaArray<Integer>>(nodosSalientes.size());
for (int i = 0; i < nodosSalientes.size(); ++i)
nodosSalientesOrdenados.set(i, nodosSalientes.get(i).sort());
}
