// print floats with n digits after the decimal point

System.out.printf("%.2f", val);

// subsets

int p[20], n = 20;

for (int i = 0; i < n; i++) p[i] = i;

for (int i = 0; i < (1 << n); i++) { // for each subset, O(2^n)

for (int j = 0; j < n; j++) { // check membership, O(n)

if (i & (1 << j)) { // test if bit `j` is turned on in subset `i`

printf("%d ", p[j]);

}

printf("\n");

}

}

// recursively generate permutations of a string

public static void generatePermutations(String perm, String word) {

int n = word.length();

if (word.isEmpty()) {

// System.out.printf("%s %s\n", perm, word);

permutations.add(perm + word);

} else {

for (int i = 0; i < n; i++) {

generatePermutations(perm + word.charAt(i), word.substring(0, i) + word.substring(i+1, n));

}

}

}

// comparable

class Pair implements Comparable<Pair> {

public int l;

public int r;

Pair(int l, int r) {

this.l = l;

this.r = r;

}

@Override

public int compareTo(Pair pair) {

if (this.l > pair.l) {

return 1;

} else if (this.l < pair.l) {

return -1;

} else {

if (this.r > pair.r) {

return 1;

} else {

return -1;

}

}

}

}

// binary search the answer: the monkey and the oiled bambooh

// Java program to print BFS traversal from a given source vertex.

// BFS(int s) traverses vertices reachable from s.

import java.io.*;

import java.util.*;

// This class represents a directed graph using adjacency list

// representation

class Graph

{

private int V; // No. of vertices

private LinkedList<Integer> adj[]; //Adjacency Lists

// Constructor

Graph(int v)

{

V = v;

adj = new LinkedList[v];

for (int i=0; i<v; ++i)

adj[i] = new LinkedList();

}

// Function to add an edge into the graph

void addEdge(int v,int w)

{

adj[v].add(w);

}

// prints BFS traversal from a given source s

void BFS(int s)

{

// Mark all the vertices as not visited(By default

// set as false)

boolean visited[] = new boolean[V];

// Create a queue for BFS

LinkedList<Integer> queue = new LinkedList<Integer>();

// Mark the current node as visited and enqueue it

visited[s]=true;

queue.add(s);

while (queue.size() != 0)

{

// Dequeue a vertex from queue and print it

s = queue.poll();

System.out.print(s+" ");

// Get all adjacent vertices of the dequeued vertex s

// If a adjacent has not been visited, then mark it

// visited and enqueue it

Iterator<Integer> i = adj[s].listIterator();

while (i.hasNext())

{

int n = i.next();

if (!visited[n])

{

visited[n] = true;

queue.add(n);

}

}

}

}

// Driver method to

public static void main(String args[])

{

Graph g = new Graph(4);

g.addEdge(0, 1);

g.addEdge(0, 2);

g.addEdge(1, 2);

g.addEdge(2, 0);

g.addEdge(2, 3);

g.addEdge(3, 3);

System.out.println("Following is Breadth First Traversal "+

"(starting from vertex 2)");

g.BFS(2);

}

}

// Java program to print DFS traversal from a given given graph

import java.io.*;

import java.util.*;

// This class represents a directed graph using adjacency list

// representation

class Graph

{

private int V; // No. of vertices

// Array of lists for Adjacency List Representation

private LinkedList<Integer> adj[];

// Constructor

Graph(int v)

{

V = v;

adj = new LinkedList[v];

for (int i=0; i<v; ++i)

adj[i] = new LinkedList();

}

//Function to add an edge into the graph

void addEdge(int v, int w)

{

adj[v].add(w); // Add w to v's list.

}

// A function used by DFS

void DFSUtil(int v,boolean visited[])

{

// Mark the current node as visited and print it

visited[v] = true;

System.out.print(v+" ");

// Recur for all the vertices adjacent to this vertex

Iterator<Integer> i = adj[v].listIterator();

while (i.hasNext())

{

int n = i.next();

if (!visited[n])

DFSUtil(n, visited);

}

}

// The function to do DFS traversal. It uses recursive DFSUtil()

void DFS(int v)

{

// Mark all the vertices as not visited(set as

// false by default in java)

boolean visited[] = new boolean[V];

// Call the recursive helper function to print DFS traversal

DFSUtil(v, visited);

}

public static void main(String args[])

{

Graph g = new Graph(4);

g.addEdge(0, 1);

g.addEdge(0, 2);

g.addEdge(1, 2);

g.addEdge(2, 0);

g.addEdge(2, 3);

g.addEdge(3, 3);

System.out.println("Following is Depth First Traversal "+

"(starting from vertex 2)");

g.DFS(2);

}

}

// A Java program for Floyd Warshall All Pairs Shortest

// Path algorithm.

import java.util.*;

import java.lang.*;

import java.io.*;

class AllPairShortestPath

{

final static int INF = 99999, V = 4;

void floydWarshall(int graph[][])

{

int dist[][] = new int[V][V];

int i, j, k;

/* Initialize the solution matrix same as input graph matrix.

Or we can say the initial values of shortest distances

are based on shortest paths considering no intermediate

vertex. */

for (i = 0; i < V; i++)

for (j = 0; j < V; j++)

dist[i][j] = graph[i][j];

/* Add all vertices one by one to the set of intermediate

vertices.

---> Before start of a iteration, we have shortest

distances between all pairs of vertices such that

the shortest distances consider only the vertices in

set {0, 1, 2, .. k-1} as intermediate vertices.

----> After the end of a iteration, vertex no. k is added

to the set of intermediate vertices and the set

becomes {0, 1, 2, .. k} */

for (k = 0; k < V; k++)

{

// Pick all vertices as source one by one

for (i = 0; i < V; i++)

{

// Pick all vertices as destination for the

// above picked source

for (j = 0; j < V; j++)

{

// If vertex k is on the shortest path from

// i to j, then update the value of dist[i][j]

if (dist[i][k] + dist[k][j] < dist[i][j])

dist[i][j] = dist[i][k] + dist[k][j];

}

}

}

// Print the shortest distance matrix

printSolution(dist);

}

void printSolution(int dist[][])

{

System.out.println("Following matrix shows the shortest "+

"distances between every pair of vertices");

for (int i=0; i<V; ++i)

{

for (int j=0; j<V; ++j)

{

if (dist[i][j]==INF)

System.out.print("INF ");

else

System.out.print(dist[i][j]+" ");

}

System.out.println();

}

}

// Driver program to test above function

public static void main (String[] args)

{

/* Let us create the following weighted graph

10

(0)------->(3)

| /|\

5 | |

| | 1

\|/ |

(1)------->(2)

3 */

int graph[][] = { {0, 5, INF, 10},

{INF, 0, 3, INF},

{INF, INF, 0, 1},

{INF, INF, INF, 0}

};

AllPairShortestPath a = new AllPairShortestPath();

// Print the solution

a.floydWarshall(graph);

}

}