Longest common subsequence between two strings using Java ..............

here is  the code........

NOTE:- Here the program is printing the length of the longest common           

              subsequence and also the evaluated sequence. 

       
public class LCS {

 public static void main(String[] args) throws Exception {

  Object[] arr = new Object[2];
  arr = evaluateLCS("suman", "paras");
  int t = arr[1].toString().length() - 1;
  System.out.println("length of longest common subsequence is " + Integer.parseInt(arr[0].toString()));
  System.out.println("the required longest subsequence is " + recursion_string(arr[1].toString(), t));
 }

 public static Object[] evaluateLCS(String first, String second) {
  Object[] arr = new Object[2];
  StringBuffer sequence = new StringBuffer();
  int length = 0;
  if (first.length() == 0 || second.length() == 0) {
   arr[0] = new Integer(0);
   arr[1] = "";
   return arr;
  } else {
   if (first.charAt(first.length() - 1) == second.charAt(second
     .length() - 1)) {
    arr = evaluateLCS(first.substring(0, first.length() - 1),
     second.substring(0, second.length() - 1));
    arr[0] = new Integer(1 + Integer.parseInt(arr[0].toString()));
    arr[1] = (Object) sequence.append(
     first.charAt(first.length() - 1)).append(arr[1]);
    return arr;
   } else {
    Object[] arr1 = new Object[2];
    arr = evaluateLCS(first.substring(0, first.length() - 1),
     second);
    arr1 = evaluateLCS(first,
     second.substring(0, second.length() - 1));
    if (Integer.parseInt(arr[0].toString()) >= Integer
     .parseInt(arr1[0].toString()))
     return arr;
    else
     return arr1;
   }

  }

 }

 public static int max(Object[] arr1, Object[] arr2) {
  int max1 = Integer.parseInt(arr1[0].toString());
  int max2 = Integer.parseInt(arr2[0].toString());

  if (max1 >= max2)
   return max1;
  else
   return max2;
 }

 public static String recursion_string(String name, int t) throws Exception {

  if (name.length() == 0) {
   return "";
  }
  if (name.length() == 1) {
   return name;
  }

  String start = name.substring(t);

  String remainder = name.substring(0, t);
  t--;

  return (start + recursion_string(remainder, t));


 }
}

       
 

Breadth First Search of a graph using Java....

NOTE :- while giving input to the adjacency matrix just put "1" against the entry of a[ i ][ j ] if there                  is a path exist between node " i " and " j " or put " 0 " otherwise .

Enter the number of nodes in the graph
4
Enter the adjacency matrix
0 1 0 1
0 0 1 0
0 1 0 1
0 0 0 1
Enter the source for the graph
1
The BFS traversal of the graph is 
1 2 4 3

so here is the code .....

       
import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class BFS {
 private Queue < Integer > queue;
 public BFS() {
  queue = new LinkedList < Integer > ();
 }
 public void bfs(int adjacency_matrix[][], int source) {
  int number_of_nodes = adjacency_matrix[source].length - 1;
  int[] visited = new int[number_of_nodes + 1];
  int i, element;
  visited[source] = 1;
  queue.add(source);
  while (!queue.isEmpty()) {
   element = queue.remove();
   i = element;
   System.out.print(i + "\t");
   while (i <= number_of_nodes) {
    if (adjacency_matrix[element][i] == 1 && visited[i] == 0) {
     queue.add(i);
     visited[i] = 1;
    }
    i++;
   }
  }
 }
 public static void main(String[] arg) {
  int number_no_nodes, source;
  Scanner scanner = null;
  try {
   System.out.println("Enter the number of nodes in the graph");
   scanner = new Scanner(System.in);
   number_no_nodes = scanner.nextInt();
   int adjacency_matrix[][] = new int[number_no_nodes + 1][number_no_nodes + 1];
   System.out.println("Enter the adjacency matrix");
   for (int i = 1; i <= number_no_nodes; i++)
    for (int j = 1; j <= number_no_nodes; j++)
     adjacency_matrix[i][j] = scanner.nextInt();
   System.out.println("Enter the source for the graph");
   source = scanner.nextInt();
   System.out.println("The BFS traversal of the graph is ");
   BFS bfs = new BFS();
   bfs.bfs(adjacency_matrix, source);
  } catch (InputMismatchException inputMismatch) {
   System.out.println("Wrong Input Format");
  }
  scanner.close();
 }
}