private static void solve(State initState) { Set<State> visited = new HashSet<State>(); Map<State, State> pred = new HashMap<State, State>(); Map<State, Integer> dist = new HashMap<State, Integer>(); Deque<State> bfs = new ArrayDeque<State>(); bfs.offer(initState); dist.put(initState, 0); while (bfs.size() > 0) { State s = bfs.poll(); int n = dist.get(s); visited.add(s); if (s.isFinal()) { outputState(s, pred); return; } for (State child : s.getChildren()) { if (visited.contains(child)) continue; if (!pred.containsKey(child)) pred.put(child, s); if (!dist.containsKey(child)) { dist.put(child, n + 1); bfs.offer(child); } } } System.out.printf("%d %d %d\n", initState.a, initState.b, initState.c); System.out.println("============"); }
void releaseConnection(ImapConnection connection) { if (connection != null && connection.isConnected()) { synchronized (connections) { connections.offer(connection); } } }
public int[] maxSlidingWindow(int[] nums, int k) { if (nums == null || k == 0) { return new int[0]; } int n = nums.length; int[] res = new int[n - k + 1]; Deque<Integer> dq = new ArrayDeque<>(); int pointer = 0; for (int i = 0; i < n; i++) { while (!dq.isEmpty() && dq.peek() < i - k + 1) { dq.poll(); } while (!dq.isEmpty() && nums[dq.peekLast()] < nums[i]) { dq.pollLast(); } dq.offer(i); if (i >= k - 1) { res[pointer++] = nums[dq.peek()]; } } return res; }
/** Returns a mapping from each vertex to its betweenness centrality measure. */ public <E extends Edge> double[] compute(Graph<E> g) { // Perform a quick test for whether the vertices of g are a contiguous // sequence starting at 0, which makes the vertex mapping trivial if (!hasContiguousVertices(g)) throw new IllegalArgumentException("Vertices must be in continugous order"); double[] centralities = new double[g.order()]; IntIterator vertexIter = g.vertices().iterator(); while (vertexIter.hasNext()) { int s = vertexIter.nextInt(); Deque<Integer> S = new ArrayDeque<Integer>(); // Initialize P to an empty list for each vertex List<List<Integer>> P = new ArrayList<List<Integer>>(g.order()); for (int i = 0; i < g.order(); ++i) P.add(new ArrayList<Integer>()); double[] sigma = new double[g.order()]; sigma[s] = 1; double[] d = new double[g.order()]; Arrays.fill(d, -1); d[s] = 0; Queue<Integer> Q = new ArrayDeque<Integer>(); Q.add(s); while (!Q.isEmpty()) { int v = Q.poll(); S.offer(v); IntIterator neighborIter = g.getNeighbors(v).iterator(); while (neighborIter.hasNext()) { int w = neighborIter.nextInt(); // Check whether this is the first time we've seen vertex w if (d[w] < 0) { Q.offer(w); d[w] = d[v] + 1; } // Check whether the shortest path to w is through v if (d[w] == d[v] + 1) { sigma[w] += sigma[v]; P.get(w).add(v); } } } double[] delta = new double[g.order()]; // S as a stack returns vertices in order of their non-increasing // distance from vertex s while (!S.isEmpty()) { int w = S.pollLast(); // get the top of the stack for (int v : P.get(w)) { delta[v] += (sigma[v] / sigma[w]) * (1 + delta[w]); } if (w != s) { centralities[w] += delta[w]; } } } return centralities; }
// https://www.hackerrank.com/challenges/bfsshortreach public static String shortestReach(int[][] edges, int n, int e, int start) { Map<Integer, List<Integer>> map = new HashMap<>(); int[] nodes = new int[n]; Arrays.fill(nodes, -1); for (int i = 0; i < e; i++) { int a = edges[i][0], b = edges[i][1]; List<Integer> al = map.get(a); if (al == null) { al = new ArrayList<>(); map.put(a, al); } al.add(b); al = map.get(b); if (al == null) { al = new ArrayList<>(); map.put(b, al); } al.add(a); } Deque<Integer> q = new ArrayDeque<>(); q.offer(start); nodes[start - 1] = 0; while (q.size() > 0) { int s = q.poll(); List<Integer> al = map.get(s); for (int i = 0; al != null && i < al.size(); i++) { int v = al.get(i); if (nodes[v - 1] == -1) { q.offer(v); nodes[v - 1] = nodes[s - 1] + 6; } } } StringBuilder sb = new StringBuilder(); for (int i = 0; i < n; i++) { if (nodes[i] != 0) { sb.append(nodes[i]).append(' '); } } return sb.substring(0, sb.length() - 1); }