1.

BELLMAN FORD
import java.util.*;
import java.lang.*;
import java.io.IOException;
public class BF
{
private int dis[];
private int nv;
public static final int MAX = 999;
public BF(int nv)
{
this.nv=nv;
dis=new int[nv+1];
}
public void bfe(int s,int adj[][])
{
for(int n=1;n<=nv;n++)
dis[n]=MAX;
dis[s]=0;
try
{
Thread.sleep(1000);
/*//TimeUnit.SECONDS.sleep(100);*/
}catch(InterruptedException c){ }
for(int n=1;n<=nv-1;n++)
{
for(int sn=1;sn<=nv;sn++)
{

for(int dn=1;dn<=nv;dn++)
{
if(adj[sn][dn]!=MAX)
{
if(dis[dn]>dis[sn]+adj[sn][dn])
dis[dn]=dis[sn]+adj[sn][dn];
}
}
}
}
for(int sn=1;sn<=nv;sn++)
{
for(int dn=1;dn<=nv;dn++)
{
if(adj[sn][dn]!=MAX)
{
if(dis[dn]>dis[sn]+adj[sn][dn])
System.out.println("graph contains
negative edge cycles");
}
}
}
for(int v=1;v<=nv;v++)
{
System.out.println("dis of source" + s + "to" + v + "is" + dis[v]);
}
}
public static void main(String[] args) throws IOException

{
int nv;
int s,sn,dn;
Scanner scanner = new Scanner(System.in);
System.out.println("enter number of vertices");
nv=scanner.nextInt();
int adj [ ][ ] = new int[nv+1][nv+1];
System.out.println("enter adj matrix");
for(sn=1;sn<=nv;sn++)
{
for(dn=1;dn<=nv;dn++)
{
adj [sn][dn]=scanner.nextInt();
/*if(adj[sn][dn]==0)
adj[sn][dn]=MAX;*/
}

}
System.out.println("enter source vertex");
s=scanner.nextInt();
long stime=System.nanoTime();
System.out.println("\nstarting time ="+(stime));
BF bf=new BF(nv);
try

{
Thread.sleep(1000);
/*//TimeUnit.SECONDS.sleep(100);*/
}catch(InterruptedException c){ }
bf.bfe(s,adj);
long etime=System.nanoTime();
System.out.println("\nending time ="+(etime));
System.out.println("\ntime taken="+((etime-stime)/10000));
scanner.close();
}
}

Output:
enter number of vertices
5
enter adj matrix
0 3 999 5 3
999 0 6 2 999
999 999 0 999 2
999 1 4 0 6
999 999 7 999 0
enter source vertex
1
starting time =539392514225
dis of source1to1is0

dis of source1to2is3
dis of source1to3is9
dis of source1to4is5
dis of source1to5is3
ending time =541442572375
time taken=205005

2. MONTE CARLO
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.Random;
import java.io.IOException;
import java.util.Scanner;
public class MillerRabin
{
MillerRabin(int number)
{
boolean n=isprime(number);
if (n== true)
System.out.println("prime");
else
System.out.println("not prime");
}

public boolean isprime(int number)

{
if (number == 1)
return false;
if (number == 2)
return true;
if (number % 2 == 0)
return false;
for (int d = 3; d <= (int) Math.sqrt(number); d++)
if (number % d == 0)
return false;
return true;
}
public static void main(String args[]) throws IOException
{
int number;
Scanner scanner = new Scanner(System.in);
System.out.println("enter number");
number=scanner.nextInt();
long stime=System.nanoTime();
System.out.println("\nstarting time ="+(stime));
MillerRabin mc = new MillerRabin(number);
long etime=System.nanoTime();
System.out.println("\nending time ="+(etime));
System.out.println("\ntime taken="+((etime-stime)));
}
}

Output:
enter number
787
starting time =1220556504361
prime
ending time =1220556798294
time taken=29

3. NAVE
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.*;
public class na
{
public na(String text,String pat)
{
int f=0;
int n=text.length();
int m=pat.length();
for (int i=0;i<=n-m;i++)
{
int j;

for(j=0;j<m;j++)
{
if(text.charAt(i+j) != pat.charAt(j))
break;
}
if(j==m)
{
f=1;
System.out.println("pat found at index" + i );
}
}
if(f==0)
System.out.println("Pattern not Found");
}
public static void main(String args[]) throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("enter text");
String text = br.readLine();
System.out.println("enter pattern");
String pattern = br.readLine();
long stime=System.nanoTime();
System.out.println("\nstarting time ="+(stime)+" ns");
na n=new na(text,pattern);
long etime=System.nanoTime();
System.out.println("\nending time ="+(etime)+" ns");
System.out.println("\ntime taken="+((etime-stime))+" ns");
}

}
Output:
enter text
hello welcome to DAA lab
enter pattern
lo
starting time =2071181110517 ns
pat found at index3
ending time =2071181430724 ns
time taken=320207 ns

4.DFA
package ujyg;
import java.util.Scanner;
public class SearchStringUsingDFA
{
public static final int NO_OF_CHARS = 256;
public static int getNextState(char[] pat, int M, int state, int x)
{
if (state < M && x == pat[state])
return state + 1;
int ns, i;

for (ns = state; ns > 0; ns--)

{
if (pat[ns - 1] == x)
{
for (i = 0; i < ns - 1; i++)
{
if (pat[i] != pat[state - ns + 1 + i])
break;
}
if (i == ns - 1)
return ns;
}
}
return 0;
}

public static void computeTF(char[] pat, int M, int[][] TF)

{
int state, x;
for (state = 0; state <= M; ++state)
for (x = 0; x < NO_OF_CHARS; ++x)
TF[state][x] = getNextState(pat, M, state, x);
}

public static void search(char[] pat, char[] txt)

{

int M = pat.length;
int N = txt.length;
int[][] TF = new int[M + 1][NO_OF_CHARS];
computeTF(pat, M, TF);
int i, state = 0;
for (i = 0; i < N; i++)
{
state = TF[state][txt[i]];
if (state == M)
{
System.out.print(pat);
System.out.print(" found at " + (i - M + 1));
}
}
}
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
System.out.println("Enter the main string: ");
String main = sc.nextLine();
System.out.println("Enter the pattern string: ");
String pattern = sc.nextLine();
search(pattern.toCharArray(), main.toCharArray());
sc.close();
}
}

Output:
Enter the main string:
DAA lab is too BAD
Enter the pattern string:
BAD
BAD found at 15
5.RABIN KARP
import java.io.*;
import java.math.BigInteger;
import java.util.Random;
import java.util.Scanner;
public class RK
{
private String pat;
private long pathash;
private int m;
private long q;
private int r;
private long rm;
public RK(int r,String pat)
{
throw new UnsupportedOperationException("operation not supported
yet");
}
public RK(String pat)
{
this.pat=pat;
r=256;

m=pat.length();
q=lrp();
rm=1;
for(int i=1;i<=m-1;i++)
rm=(r*rm)%q;
pathash=hash(pat,m);
}
private long hash(String key,int m)
{
long h=0;
for(int j=0;j<m;j++)
h=(r*h+key.charAt(j))%q;
return h;
}
private boolean chk(String text,int i)
{
for(int j=0;j<m;j++)
if(pat.charAt(j) != text.charAt(i+j))
return false;
return true;
}
private boolean chk(int i)
{
return true;
}
public int search(String text)
{

int n=text.length();
if(n<m)
return n;
long txthash=hash(text,m);
if((pathash == txthash) && chk(text,0))
return 0;
for(int i=m;i<n;i++)
{
txthash=(txthash+q-rm*text.charAt(i-m)%q)%q;
txthash=(txthash*r+text.charAt(i))%q;
int offset=i-m+1;
if((pathash == txthash) && chk(text,offset))
return offset;
}
return n;
}
private static long lrp()
{
BigInteger prime=BigInteger.probablePrime(31,new Random());
return prime.longValue();
}
public static void main(String args[])
{
Scanner sc = new Scanner(System.in);
System.out.println("Enter the main string: ");
String text = sc.nextLine();
System.out.println("Enter the pattern string: ");
String pat = sc.nextLine();

long stime=System.nanoTime();
System.out.println("\nstarting time ="+(stime));
RK s=new RK(pat);
int offset=s.search(text);
System.out.println("text:

" + text);

System.out.print("pattern: ");
for(int i=0;i<offset;i++)
System.out.println(" ");
System.out.println(pat);
if(offset== text.length())
System.out.println("not found");
else
System.out.println("found at position" + offset);
long etime=System.nanoTime();
System.out.println("\nending time ="+(etime));
System.out.println("\ntime taken="+((etime-stime))+" ns");
}
}
Output:
Enter the pattern string:
shrilata
Enter the main string:
shri
starting time =2897947853527
text:

shrilata

pattern: shri
found at position0

ending time =2897957983141

time taken=10129614 ns