public List<String> findWords(char[][] board, String[] words) { if (board == null || words == null) { return new ArrayList<>(); } Trie trie = new Trie(); for (String word : words) { trie.insert(word); } Set<String> wordsList = new HashSet<>(); for (int i = 0; i < board.length; i++) { for (int j = 0; j < board[0].length; j++) { StringBuilder word = new StringBuilder(); boolean[][] used = new boolean[board.length][board[0].length]; word.append(board[i][j]); search(used, board, word, i, j, trie, wordsList); } } return new ArrayList<>(wordsList); }
public List<List<Integer>> palindromePairs(String[] words) { List<List<Integer>> ans = new LinkedList<List<Integer>>(); Trie tree = new Trie(); for (int i = 0; i < words.length; i++) tree.insert(words[i], i); for (int i = 0; i < words.length; i++) tree.searchPalindromePairs(ans, words[i], i); return ans; }
private boolean add(String s, int index) { if (index == s.length()) { if (isWord) { return false; } isWord = true; return true; } char c = s.charAt(index); for (int i = 0; i < numChildren; i++) { if (child[i].ch == c) { return child[i].add(s, index + 1); } } // this code adds from the bottom to the top because the addChild method // checks for cyclic references. This prevents quadratic runtime. int i = s.length() - 1; Trie t = createNode(s.charAt(i--)); t.isWord = true; while (i >= index) { Trie n = createNode(s.charAt(i--)); n.addChild(t); t = n; } addChild(t); return true; }
public static void main(String[] args) throws NumberFormatException, IOException { BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); StringBuilder output = new StringBuilder(); int cases = Integer.parseInt(bf.readLine()); for (int i = 0; i < cases; i++) { bf.readLine(); // blank-line char[][] boogle = new char[4][4]; for (int j = 0; j < 4; j++) { boogle[j] = bf.readLine().trim().toUpperCase().toCharArray(); } String n = ""; while (n.equals("")) { n = bf.readLine().trim(); } int noWords = Integer.parseInt(n); Trie t2 = new Trie(); for (int j = 0; j < noWords; j++) { t2.addWord(bf.readLine().trim().toUpperCase()); } output.append("Score for Boggle game #" + (i + 1) + ": " + calculateScore(boogle, t2) + "\n"); } System.out.print(output); }
/** * get entry from Trie, return null if no entry is present yet * * * @param pos */ List<CalculationNode> get(final int pos) { if (pos == 0) { return list; } final Trie child = children[changeStateNodes[pos - 1]]; if (child == null) { return null; } return child.get(pos - 1); }
/** set entry int Trie, create new entries if no entry is present yet * */ void set(final List<CalculationNode> list, final int pos) { if (pos == 0) { this.list = list; return; } Trie child = children[changeStateNodes[pos - 1]]; if (child == null) { child = new Trie(); children[changeStateNodes[pos - 1]] = child; } child.set(list, pos - 1); }
@Test public void testGetChildren() { Trie trie = new Trie(); trie.add("aa"); trie.add("ab"); trie.add("bb"); Node rootNode = trie.getRoot(); assertEquals(2, rootNode.getChildren().length); assertEquals(2, rootNode.getChildren()[0].getChildren().length); assertEquals(1, rootNode.getChildren()[1].getChildren().length); }
/** * Returns all of the words in the trie that begin with the specified prefix rooted at this node. * An array of length 0 is returned if there are no words that begin with the specified prefix. * * @param prefix String prefix. * @return Array of Strings. */ public String[] getWords(String prefix) { Trie n = getNode(prefix); if (n == null) { return new String[0]; } String[] arr = new String[n.size()]; n.getWords(arr, 0); return arr; }
@Override public void runAlgorithm() throws InterruptedException { setHeader("trieinsert", s.substring(0, s.length() - 1)); if (s.compareTo("$") == 0) { addNote("badword"); } TrieNode v = T.getRoot(); v.mark(); addNote("trieinsertnote"); addStep("trierootstart"); pause(); v.unmark(); hw = new TrieWordNode(T, s); hw.setColor(NodeColor.INSERT); addToScene(hw); hw.goNextTo(v); while (s.compareTo("$") != 0) { final char ch = s.charAt(0); hw.setAndGoNextTo(s, v); TrieNode w = v.getChildWithCH(ch); if (w != null) { addStep("trieinsertwch", "" + ch); } else { addStep("trieinsertwoch", "" + ch); w = v.addChild(ch, hw.x, hw.y); } w.setColor(NodeColor.CACHED); T.reposition(); pause(); v = w; v.setColor(NodeColor.INSERT); T.reposition(); s = s.substring(1); } hw.setAndGoNextTo(s, v); final TrieNode w = v.getChildWithCH('$'); if (w == null) { addStep("trieinserteow"); } else { addStep("trieinsertneow"); } pause(); v.setColor(NodeColor.NORMAL); v = v.addChild('$', hw.x, hw.y); T.reposition(); hw.setAndGoNextTo(s, v); beforeReturn(); }
public List<String> findWords(char[][] board, String[] words) { List<String> res = new ArrayList<String>(); Trie trie = new Trie(); for (String word : words) { trie.insert(word); } boolean[][] visited = new boolean[board.length][board[0].length]; for (int i = 0; i < board.length; i++) { for (int j = 0; j < board[0].length; j++) { searchHelper(board, visited, res, trie, "", i, j); } } return res; }
@Override public void run() { if (s.compareTo("$") == 0) { addNote("badword"); } TrieNode v = T.getRoot(); v.mark(); addNote("trieinsertnote"); addStep("trierootstart"); mysuspend(); v.unmark(); T.hw = new TrieWordNode(T, s); T.hw.setColor(NodeColor.INSERT); T.hw.goNextTo(v); while (s.compareTo("$") != 0) { char ch = s.charAt(0); T.hw.setAndGoNextTo(s, v); TrieNode w = v.getChildWithCH(ch); if (w != null) { addStep("trieinsertwch", "" + ch); } else { addStep("trieinsertwoch", "" + ch); w = v.addChild(ch, T.hw.x, T.hw.y); } w.setColor(NodeColor.CACHED); T.reposition(); mysuspend(); v = w; v.setColor(NodeColor.INSERT); T.reposition(); s = s.substring(1); } T.hw.setAndGoNextTo(s, v); TrieNode w = v.getChildWithCH('$'); if (w == null) { addStep("trieinserteow"); } else { addStep("trieinsertneow"); } mysuspend(); v.setColor(NodeColor.NORMAL); v = v.addChild('$', T.hw.x, T.hw.y); T.reposition(); T.hw.setAndGoNextTo(s, v); beforeReturn(); }
public void initialise() { stateNode = stateNodeInput.get().toArray(new StateNode[0]); for (int i = 0; i < stateNode.length; i++) { stateNode[i].index = i; } // make itself known for (StateNode state : stateNode) { state.state = this; } nrOfStateNodes = stateNode.length; // allocate memory for StateNodes and a copy. stateNodeMem = new StateNode[nrOfStateNodes * 2]; for (int i = 0; i < nrOfStateNodes; i++) { stateNodeMem[i] = stateNode[i]; stateNodeMem[nrOfStateNodes + i] = stateNodeMem[i].copy(); } // set up data structure for encoding which StateNodes change by an operation changeStateNodes = new int[stateNode.length]; // Arrays.fill(changeStateNodes, -1); nrOfChangedStateNodes = 0; trie = new Trie(); // add the empty list for the case none of the StateNodes have changed trie.list = new ArrayList<>(); } // initAndValidate
/** * 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; }
private static void searchWords( char[][] boogle, boolean[][] used, char[] currentWord, int pos, Set<String> foundWords, Trie t, int i, int j) { if (i < 0 || j < 0 || i > 3 || j > 3 || used[i][j]) { // out of bounds return; } char c = boogle[i][j]; used[i][j] = true; currentWord[pos++] = c; SearchResult searchResult = t.searchWord(currentWord, pos); if (searchResult.isDictionaryWord) { String s = getWord(currentWord, pos); foundWords.add(s); } else if (!searchResult.wordBeginning) { used[i][j] = false; return; } searchWords(boogle, used, currentWord, pos, foundWords, t, i - 1, j - 1); searchWords(boogle, used, currentWord, pos, foundWords, t, i - 1, j); searchWords(boogle, used, currentWord, pos, foundWords, t, i - 1, j + 1); searchWords(boogle, used, currentWord, pos, foundWords, t, i, j - 1); searchWords(boogle, used, currentWord, pos, foundWords, t, i, j + 1); searchWords(boogle, used, currentWord, pos, foundWords, t, i + 1, j + 1); searchWords(boogle, used, currentWord, pos, foundWords, t, i + 1, j); searchWords(boogle, used, currentWord, pos, foundWords, t, i + 1, j - 1); used[i][j] = false; }
/** * Define applicable categories in the subString. * * @param subString The substring to define. * @param normalizer The normalizer to use. */ protected void define(StringWrapper.SubString subString, AbstractNormalizer normalizer) { final String string = subString.getNormalizedString(normalizer); if (trie.contains(string)) { subString.addCategory(category); } }
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(); }
private void dfs(char[][] board, int x, int y, Trie root, List<String> result) { char c = board[x][y]; if (c == '#' || root.children[c - 'a'] == null) { return; } root = root.children[c - 'a']; if (root.word != null) { result.add(root.word); root.word = null; } board[x][y] = '#'; if (x > 0) { dfs(board, x - 1, y, root, result); } if (x < board.length - 1) { dfs(board, x + 1, y, root, result); } if (y > 0) { dfs(board, x, y - 1, root, result); } if (y < board[0].length - 1) { dfs(board, x, y + 1, root, result); } board[x][y] = c; }
public void search( boolean[][] used, char[][] board, StringBuilder word, int i, int j, Trie trie, Set<String> wordsList) { if (trie.search(word.toString())) { wordsList.add(word.toString()); return; } if (trie.startsWith(word.toString())) { if (i > 0 && !used[i - 1][j]) { used[i - 1][j] = true; word.append(board[i - 1][j]); search(used, board, word, i - 1, j, trie, wordsList); word.deleteCharAt(word.length() - 1); } if (i < board.length - 1 && !used[i + 1][j]) { used[i + 1][j] = true; word.append(board[i + 1][j]); search(used, board, word, i + 1, j, trie, wordsList); word.deleteCharAt(word.length() - 1); } if (j > 0 && !used[i][j - 1]) { used[i][j - 1] = true; word.append(board[i][j - 1]); search(used, board, word, i, j - 1, trie, wordsList); word.deleteCharAt(word.length() - 1); } if (j < board[0].length - 1 && !used[i][j + 1]) { used[i][j + 1] = true; word.append(board[i][j + 1]); search(used, board, word, i, j + 1, trie, wordsList); word.deleteCharAt(word.length() - 1); } } }
private void addToTrie(Trie root, String word) { for (char c : word.toCharArray()) { int index = c - 'a'; if (root.children[index] == null) { root.children[index] = new Trie(); } root = root.children[index]; } root.word = word; }
/** * 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; }
/** * Sets the character of this trie. * * @param c Character. * @throws IllegalArgumentException if this trie has a sibling with the same character. */ public void setChar(char c) throws IllegalArgumentException { if (c == ch) { return; } if ((parent != null) && parent.hasChar(c)) { throw new IllegalArgumentException("duplicate chars not allowed"); } ch = c; }
/** * 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; }
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); }
/** * Removes the specified string from the trie. Returns true if the string was removed or false if * the string was not a word in the trie. * * @param s String. * @return true or false. */ public boolean remove(String s) { Trie t = getNode(s); if ((t == null) || !t.isWord) { return false; } t.isWord = false; while ((t != null) && (t.numChildren == 0) && !t.isWord) { Trie p = t.parent; if (p != null) { p.removeChild(t); } t = p; } return true; }
public static void main(String[] args) { Trie t = new Trie(); t.insert("are"); t.insert("area"); t.insert("base"); t.insert("cater"); t.insert("cat"); t.insert("basement"); System.out.println(t.searchPrefix("cater")); }
public void searchHelper( char[][] board, boolean[][] visited, List<String> res, Trie trie, String str, int i, int j) { int m = board.length; int n = board[0].length; if (i < 0 || i >= m || j < 0 || j >= n) { return; } if (!trie.startWith(word)) { return; } if (visited[i][j]) { return; } str = str + board[i][j]; if (trie.search(str) && !res.contains(str)) { res.add(str); } visited[i][j] = true; searchHelper(board, visited, res, trie, str, i + 1, j); searchHelper(board, visited, res, trie, str, i - 1, j); searchHelper(board, visited, res, trie, str, i, j + 1); searchHelper(board, visited, res, trie, str, i, j - 1); visited[i][j] = false; }
/** * Removes the specified trie from the child array. Does nothing if the specified trie is not a * child of this trie. Otherwise the parent of the trie is set to null. * * @param t Trie Object. */ public void removeChild(Trie t) { for (int i = 0; i < numChildren; i++) { if (t == child[i]) { for (int j = i + 1; j < numChildren; j++) { child[j - 1] = child[j]; } numChildren--; child[numChildren] = null; t.parent = null; break; } } }
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; }
/** return current set of calculation nodes based on the set of StateNodes that have changed * */ private List<CalculationNode> getCurrentCalculationNodes() { List<CalculationNode> calcNodes = trie.get(nrOfChangedStateNodes); if (calcNodes != null) { // the list is pre-calculated return calcNodes; } // we need to calculate the list of CalculationNodes now try { calcNodes = calculateCalcNodePath(); } catch (Exception e) { e.printStackTrace(); System.exit(1); } trie.set(calcNodes, nrOfChangedStateNodes); // System.err.print(Arrays.toString(changeStateNodes) + ":"); // for (CalculationNode node : calcNodes) { // Log.warning.print(node.m_sID + " "); // } // System.err.println(); return calcNodes; } // getCurrentCalculationNodes