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);
}
