1.

Program to implement Fibonacci series

import java.io.*;
class FibonacciExample1{
public static void main(String args[])
{
int n1=0,n2=1,n3,i,count=10;

for(i=0;i<count;++i)//loop starts from 2 because 0 and 1 are already

printed
{ System.out.print(n1+" ");
n3=n1+n2;

n1=n2;
n2=n3;
}

}}

OUTPUT:
2.Program to check whether a number is palindrome or not

import java.io.*;

import java.util.*;
class Palindrome{
public static void main(String args[]){
int n;
int rev=0;int rem;
Scanner sc=new Scanner(System.in);
n=sc.nextInt();
int num=n;
while(n>0){
rem=n%10;
rev=rev*10+rem;
n=n/10;
}
if(rev==num){System.out.print("Palindrome");}
else{
System.out.print("Non Palindrome");
}
}
}

OUTPUT:
3.Program to print prime series

import java.io.*;
import java.util.*;
class Prime{
public static void main(String[] args){
int n;int count;
Scanner sc= new Scanner(System.in);
n=sc.nextInt();
System.out.println(n);
for(int i=2;i<n;i++){
count=0;
for(int j=1;j<=i;j++){
if(i%j==0) count++;
}
if(count==2){ System.out.print(i+" ");}
}
}
}

OUTPUT:
4.Program to print pascal triangle:

public class Pascal

{
public static void main(String[] args)
{
int row=5, i, j, space, num;
for(i=0; i<row; i++)
{
for(space=row; space>i; space--)
{
System.out.print(" ");
}
num=1;
for(j=0; j<=i; j++)
{
System.out.print(num+ " ");
num = num*(i-j)/(j+1);
}
System.out.print("\n");
}
}
}

OUTPUT:
5.Program to implement abstraction
import java.util.*;
abstract class Car{
abstract void accelerate();
}
//concrete class
class Suzuki extends Car{
void accelerate(){
System.out.println("Suzuki::accelerate");

}
}
class abstraction{
public static void main(String args[]){
Car obj = new Suzuki(); //Car object =>contents of Suzuki
obj.accelerate(); //call the method
}
}

OUTPUT:
6.ABSTRACTION USING INTERFACE

import java.util.*;
interface Car{
void accelerate();
}
//concrete class
class Suzuki implements Car{
public void accelerate(){
System.out.println("Suzuki::accelerate");

}
}
class abst{
public static void main(String args[]){
Suzuki obj = new Suzuki(); //Car object =>contents of
Suzuki
obj.accelerate(); //call the method
}
}

OUTPUT:
7.Program to implement inheritance

import java.util.*;
class Animal{
void eat(){System.out.println("eating...");}
}
class cheetah extends Animal{
void run(){System.out.println("running...");}
}
class inh{
public static void main(String args[]){
cheetah d=new cheetah();
d.run();
d.eat();
}}

OUTPUT:
8.Program to implement method Polymorphism
a)Overloading:

class help{
static int multiply(int a,int b){
return a*b;
}
static double multiply(double a,double b){
return a*b;
}
static int multiply(int a,int b,int c){
return a*b*c;
}
}

class polymorphism{
public static void main(String[] args){
System.out.println(help.multiply(2,4));
System.out.println(help.multiply(5.5,6.6));
System.out.println(help.multiply(5,4,6));
}
}

OUTPUT:
b)overriding

class Parent{
void Print(){
System.out.println("Parent");
}
}

class subclass1 extends Parent{

void Print(){
System.out.println("subclass1");
}

class subclass2 extends Parent{

void Print(){
System.out.println("subclass2");
}

public class overriding{

public static void main(String[] args){
Parent a;
a=new subclass1();
a.Print();
a=new subclass2();
a.Print();
}
}
OUTPUT:
9.Program to implement Encapsulation

class Person {
private String name;
private int age;

public String getName() { return name; }

public void setName(String name) { this.name = name; }

public int getAge() { return age; }

public void setAge(int age) { this.age = age; }

}

public class Encap {

public static void main(String[] args)
{
Person person = new Person();
person.setName("John");
person.setAge(30);

System.out.println("Name: " + person.getName());

System.out.println("Age: " + person.getAge());
}
}

OUTPUT:
10.Program to implement static keyword

import java.io.*;

public class GFG {

static int a = 40;
int b = 50;

void simpleDisplay()
{ a=a+10;
System.out.println(a);
System.out.println(b);
}
static void staticDisplay()
{
System.out.println(a);
}
public static void main(String[] args)
{
GFG obj = new GFG();
obj.simpleDisplay();
staticDisplay();
}
}

OUTPUT:
11.Program to implement final keyword

class Bike{
final void run(){System.out.println("running");}
}

class Honda extends Bike{

void run(){System.out.println("running safely with 100kmph");}

public static void main(String args[]){

Honda honda= new Honda();
honda.run();
}
}

OUTPUT:
12.Program to implement abstract keyword

abstract class fg {
abstract void printInfo();
}

class employee extends fg {

void printInfo() {
String name = "aakanksha";
int age = 21;
float salary = 55552.2F;

System.out.println(name);
System.out.println(age);
System.out.println(salary);

class base {
public static void main(String args[]) {
fg s = new employee();
s.printInfo();
}
}

OUTPUT:
13. Write a program to implement Multi threading

class MultithreadingDemo extends Thread {

public void run()
{
try {
// Displaying the thread that is running
System.out.println(
"Thread " + Thread.currentThread().getId()
+ " is running");
}
catch (Exception e) {
// Throwing an exception
System.out.println("Exception is caught");
}
}
}

// Main Class
public class Multithread {
public static void main(String[] args)
{
int n = 8; // Number of threads
for (int i = 0; i < n; i++) {
MultithreadingDemo object
= new MultithreadingDemo();
object.start();
}
}
}
Output:
14. Write a program to implement String Reverse.

import java.io.*;
import java.util.Scanner;

class StringReverse {
public static void main (String[] args) {

String str, nstr="";

char ch;
Scanner sc = new Scanner(System.in);
str = sc.nextLine();

for (int i=0; i<str.length(); i++)

{
ch= str.charAt(i); //extracts each character
nstr= ch+nstr; //adds each character in front of the existing string
}
System.out.println("Reversed word: "+ nstr);
}
}
OUTPUT:
15.Write a program to implement Binary Search:

import java.util.*;
class BinarySearch{

static void merge(int[] a , int l, int m, int h)

{
int i = l, j = m+1;
int k = 0;
int[] c = new int[10] ;
while(i<=m && j<= h)
{
if(a[i]>a[j])
{
c[k] = a[j];
k++;
j++;
}
else{
c[k] = a[i];
k++;
i++;
}
}
while(i<=m){
c[k] = a[i];
k++;
i++;

}
while(j<=h){
c[k] = a[j];
k++;
j++;

}
k = 0;
for(i = l; i<=h;i++)
 { a[i] = c[k]; k++;}
}
static void Merge_Sort(int[] a,int l, int h){
int mid = (l+h)/2;
if(l<h){
Merge_Sort(a,l,mid);
Merge_Sort(a,mid+1,h);
merge(a,l,mid ,h);
}
}

static int Bin_Search(int[] a, int key, int l, int h){

if(l<=h){
int mid = (l + h)/2;
if(a[mid]==key)
return mid + 1;
else if(a[mid]>key)
return Bin_Search(a,key,l, mid - 1);
else

return Bin_Search(a,key,mid+1, h);

}
else
return -1;
}
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int n,key ;
int a[] = new int[10];
System.out.println("Enter the number of elements ");

n = sc.nextInt();

for(int i = 0; i<n;i++){
a[i] = sc.nextInt();
}
 System.out.println("Enter the key ");
key = sc.nextInt();
Merge_Sort(a,0,n-1);
int pos =Bin_Search(a,key ,0,n-1);
if(pos == -1)
System.out.println("Not found");
else
System.out.println(" the key is found at " + String.valueOf(pos));

OUTPUT:
16.Write a program to implement Merge Sort:

import java.util.*;
class MergeSort{
static void merge(int[] a , int l, int m, int h)
{
int i = l, j = m+1;
int k = 0;
int[] c = new int[10] ;
while(i<=m && j<= h)
{
if(a[i]>a[j])
{
c[k] = a[j];
k++;
j++;
}
else{
c[k] = a[i];
k++;
i++;
}
}
while(i<=m){
c[k] = a[i];
k++;
i++;

}
while(j<=h){
c[k] = a[j];
k++;
j++;

}
k = 0;
for(i = l; i<=h;i++)
 { a[i] = c[k]; k++;}
}
static void Merge_Sort(int[] a,int l, int h){
int mid = (l+h)/2;
if(l<h){
Merge_Sort(a,l,mid);
Merge_Sort(a,mid+1,h);
merge(a,l,mid ,h);
}
}
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int n ;
int a[] = new int[10];
System.out.println("Enter the number of elements ");

n = sc.nextInt();

for(int i = 0; i<n;i++){
a[i] = sc.nextInt();
}
Merge_Sort(a,0,n-1);
System.out.println("The array after sorting ");
for(int i = 0; i<n;i++){
System.out.println(a[i]);
}
}
}
Output:
17. Write a program to implement n-Queen’s problem:

import java.util.*;
public class NQueenProblem{

Scanner sc=new Scanner(System.in);

int N=sc.nextInt();
void printSol(int board[][]){
for(int i=0;i<N;i++){
for(int j=0;j<N;j++){
if(board[i][j]==1)
System.out.print(" "+'Q'+" ");
else System.out.print(" "+'-'+" ");

}
System.out.println();
}
}

boolean isSafe(int board[][],int row,int col){

int i,j;
for(i=0;i<col;i++){
if(board[row][i]==1){
return false;
}
}

for(i=row,j=col;i>=0 && j>=0;i--,j--){

if(board[i][j]==1) return false;
}

for(i=row,j=col;i<N && j>=0;i++,j--){

if(board[i][j]==1) return false;
}
return true;
}

boolean solveNQUtil(int board[][],int col){

if(col>=N) return true;

for(int i=0;i<N;i++){
if(isSafe(board,i,col)){
board[i][col]=1;

if(solveNQUtil(board,col+1)==true) return true;

board[i][col]=0;
}
}
return false;
}

boolean solveNQ(){
int board[][]=new int[N][N];
for(int i=0;i<N;i++){
for(int j=0;j<N;j++){
board[i][j]=0;
}
}
if(solveNQUtil(board,0)==false){
System.out.println("No solution");
return false;
}
printSol(board);
return true;
}
public static void main(String args[]){
NQueenProblem Queen=new NQueenProblem();
Queen.solveNQ();
}
}

OUTPUT:
18.Write a program to implement SUBSET-SUM:

import java.util.*;
class sumOfSubsets {
static void sum(int ind,int s,int[] a,int n,int
target,List<Integer>subset){
if(ind==n ){
if(s==target)
System.out.println("The subset is:"+subset);

return;
}
subset.add(a[ind]);

s+=a[ind];
sum(ind+1,s,a,n,target,subset);
s-=a[ind];
subset.remove(subset.size()-1);
sum(ind+1,s,a,n,target,subset);

public static void main(String[] args) {

int n,target;
Scanner sc=new Scanner(System.in);
System.out.println("Enter no. of elements in array");
n=sc.nextInt();
System.out.println("Enter target sum");
target=sc.nextInt();
int[] a=new int[n];

List<Integer>subset=new ArrayList<Integer>();

System.out.println("Enter array elements");

 for(int i=0;i<n;i++){
a[i]=sc.nextInt();
}

sum(0,0,a,n,target,subset);

}
}

OUTPUT:
19. Program implementing Optimal Binary Search tree:

import java.util.*;
import java.io.*;
import java.lang.*;
class Main{
static int Find(int c[][],int[][] r , int i, int j){
int min = Integer.MAX_VALUE;
int m,l;
l=0;
for(m = r[i][j-1] ;m<=r[i+1][j] ;m++){
if(min>c[i][m-1] + c[m][j])
{ min = c[i][m-1] + c[m][j];
l = m;
}
}
return l;
}

public static void main(String args[]){

Scanner sc = new Scanner(System.in);
System.out.println("Enter the number of nodes :");
int n = sc.nextInt();
int[] p = new int[n+1];
int[] q = new int[n+1];
int[][] r = new int[n+1][n+1] ;
int[][] c = new int[n+1][n+1] ;
int[][] w = new int[n+1][n+1] ;
int mincost,i,j,m,k;
System.out.println("Enter the success frequencies ");
for(i=1;i<=n;i++)
p[i] = sc.nextInt();
System.out.println("Enter the failure frequencies ");
for(i=0;i<=n;i++)
q[i] = sc.nextInt();
for(i=0;i<=n-1;i++){
w[i][i]= q[i];
r[i][i] = 0;
 31

c[i][i] = 0;
w[i][i+1] = w[i][i]+p[i+1]+q[i+1];
c[i][i+1] = w[i][i+1];
r[i][i+1] = i+1;
}
w[n][n] =q[n];c[n][n] =0; r[n][n] =0;
for(m=2;m<=n;m++){
for(i=0;i<=n-m;i++){j
= i+m;
w[i][j] = w[i][j-1]+p[j] + q[j];k
= Find(c,r,i,j);
c[i][j] = w[i][j] + c[i][k-1]+c[k][j];
r[i][j] = k;
}
}
System.out.println("the min cost is : " + c[0][n]);
}
}
Output:

20. Write a program to implement 0/1 Knapsack problem by

 32

using Dynamic Programming:

import java.util.*;
public class main
{
public static void main(String[] args)
{Scanner sc=new Scanner(System.in);
System.out.println("Enter no of instances");
int n=sc.nextInt();
int[] p=new int[n+1];
int[] wt=new int[n+1];
int[] x=new int[n+1];
System.out.println("enter capacity");

int m =sc.nextInt();
int i,w,j;
p[0]=0;
wt[0]=0;
System.out.println("Enter profits");
for(i=1;i<=n;i++){
p[i]=sc.nextInt();
}
System.out.println("Enter weights");
for(i=1;i<=n;i++){
wt[i]=sc.nextInt();
}
int[][] k=new int[n+1][m+1];
for(i=0;i<=n;i++){
for(w=0;w<=m;w++){
if(i==0 || w==0){
k[i][w]=0;
}
else if(wt[i]<=w){
if(p[i]+k[i-1][w-wt[i]] >= k[i-1][w]){
k[i][w]=p[i]+k[i-1][w-wt[i]];
}
else{
k[i][w]=k[i-1][w];
 33

}
}
else{
k[i][w]=k[i-1][w];
}
}
}
System.out.println("Maxprofit:"+k[n][m]);
i=n;
j=m;
while(i>0 && j>0)
{if(k[i][j]==k[i-1][j]){
x[i]=0;
i--;
}
else{
x[i]=1;
j=j-wt[i];
i--;
}
}
for(i=1;i<=n;i++){
System.out.print(x[i]+" ");
}
}
}

Output:
 34

21. Write a program to implement Greedy Knapsack problem:

import java.io.*;
import java.util.*;

class knapsack{
public static void main(String[] args){
int i,j;
float t,profit=0;
Scanner sc=new Scanner(System.in);
System.out.print("enter the number:");
int n=sc.nextInt();
float[] p=new float[n];
float[] w=new float[n];
float[] temp=new float[n];
float[] x=new float[n];
System.out.println("enter the weights:");
for(i=0;i<n;i++){
w[i]=sc.nextInt();
}
System.out.println("Enter the profits:");
for(i=0;i<n;i++){
p[i]=sc.nextInt();
}
for(i=0;i<n;i++){
temp[i]=(float)p[i]/w[i];
}
for(i=0;i<n;i++){
for(j=0;j<n-i-1;j++){
if(temp[j]<temp[j+1]){

t=temp[j];
temp[j]=temp[j+1];
temp[j+1]=t;
 35

t=w[j];
w[j]=w[j+1];
w[j+1]=t;

t=p[j];
p[j]=p[j+1];
p[j+1]=t;
}
}
}
for(i=0;i<n;i++){
System.out.print(p[i]+" ");
}
System.out.println();
for(i=0;i<n;i++){
System.out.print(w[i]+" ");
}
System.out.println();
for(i=0;i<n;i++){
System.out.print(temp[i]+" ");
}
System.out.println();
System.out.print("Enter the capacity:");
int c=sc.nextInt();
for(i=0;i<n;i++){
if(w[i]<=c){
x[i]=1;
c-=w[i];
profit+=p[i];
}
else{
break;
}
 36

}
if(i<=n){
x[i]=c/w[i];
profit+=p[i]*(x[i]);
}

for(i=0;i<n;i++){
System.out.print(x[i]+" ");
}
System.out.println(profit);

OUTPUT:
 37

22. Write a program to implement Prim’s minimum cost

spanning tree by using Greedy Method:

import java.io.*;
importjava.lang.*;
import java.util.*;
class Prims{
int V;
int mincost;
int graph[][] = new int[100][100] ;

int[][] tree=new int[99][2];

void getgraph(){
Scanner sc = new Scanner(System.in);
System.out.println("Enter the value of n :”);
V = sc.nextInt();
System.out.println("Enter the cost matrix“);
int i,j;

for(i = 0;i<V;i++){
for(j = 0;j<V;j++)
{
graph[i][j] = sc.nextInt();
if(graph[i][j] ==0)
graph[i][j] =Integer.MAX_VALUE;
}

void findMST(){
getgraph();
int i,j,k,l;
int min,m,minval,mindex;
 38

int[] near = new int[V];

min=Integer.MAX_VALUE;
k=0;l=0;
for(i=0;i<V;i++){
for(j=0;j<V;j++){
if(graph[i][j]<min)
{

min=graph[i][j];
k = i;
l =j;

}
}
}

tree[0][0]= k;
tree[0][1] = l;

mincost = 0;
mincost+=graph[k][l];
for(i=0;i<V;i++){
if(graph[i][l]<graph[i][k])
near[i] = l;

else near[i] = k;
}
near[k] = near[l] = -1;

mindex = 0
for(i=1;i<V-1;i++)
{
minval = Integer.MAX_VALUE;
for(j=0;j<V;j++){
if(near[j]!=-1 &&
graph[j][near[j]]<minval)
 39

{minval =graph[j][near[j]] ;
mindex = j;
}
}

tree[i][0] = mindex;
tree[i][1]=near[mindex];
mincost+= graph[mindex][near[mindex]];
near[mindex] = -1;
for(m=0;m<V;m++){
if(near[m]!=-1 &&
graph[m][near[m]]>graph[m][mindex])
near[m] = mindex;
}
}
for(i=0;i<V-1;i++){
for(j=0;j<2;j++){
System.out.print(tree[i][j]+ " " );
}
System.out.println();
}
System.out.println("Mincost:"+mincost);
}
}
class Main{
public static void main(String args[]){
Prims g = new Prims();
g.FindMST();
}
}
 40

Output:
 41

23. Write a program to implement Kruskal’s minimum cost

spanning tree by using Greedy Method:

import java.util.*;
import java.io.*;
import java.lang.*;
class Kruskals{
int V;
int mincost;
int graph[][] = new int[100][100] ;

int[][] tree = new int[99][2];

void getgraph(){
Scanner sc = new Scanner(System.in);

System.out.println("Enter the number of nodes ");

V = sc.nextInt();
System.out.println("Enter the cost matrix ");int
i,j;

for(i = 0;i<V;i++){
for(j = 0;
j<V;j++){
graph[i][j]= sc.nextInt();
if(graph[i][j] ==0)
graph[i][j] =Integer.MAX_VALUE;
}

int find(int i,int[] parent){

if(parent[i]==-1)
return -1;
while(parent[i]!=-1){
i=parent[i];}
return i;
 42

void FindMST(){
getgraph();
int i,j,k,l,min,m,minval,mindex;

int[] initial=new int[V*V];

int[] fin=new int[V*V];
int[] cost=new int[V*V];

k=0;
for(i=0;i<V;i++){
for(j=0;j<V;j++){
cost[k]=graph[i][j];
initial[k]=i;
fin[k]=j;
k++;
}
}

for(i=0;i<(V*V)-1;i++){
for(j=0;j<(V*V)-i-1;j++){
if(cost[j]>cost[j+1]){
int temp=cost[j];
cost[j]=cost[j+1];
cost[j+1]=temp;
temp=initial[j];
initial[j]=initial[j+1];
initial[j+1]=temp;
temp=fin[j];
fin[j]=fin[j+1];
 43

fin[j+1]=temp;

}
}
}

System.out.println();

int[] parent=new int[V*V];

for(i=0;i<V*V;i++) parent[i]=-1;
int mincost=0;

int ptr=0;
i=0;
while(i<V-1){
k=initial[ptr];
l=fin[ptr];
/ System.out.print(k+" "+l);
int p1=find(k,parent);
int p2=find(l,parent);
/ System.out.println("p1:"+p1+" p2:"+p2);
if((p1!=p2 && p1!=l && p2!=k) || (p1==-1 && p2==-1)){
mincost+=cost[ptr];
tree[i][0]=initial[ptr];
tree[i][1]=fin[ptr];
parent[k]=l;
i++;
}
ptr++;
}

for(i=0;i<V-1;i++){
 44

for(j=0;j<2;j++){
System.out.print(tree[i][j]+ " " );
}
System.out.println();
}
System.out.println("Mincost:"+mincost);
}
}
class Main{
public static void main(String args[]){
Kruskals g = new Kruskals();
g.FindMST();
}
}
OUTPUT:
 45

24. Write a program to implement Job sequencing with

deadlines by using Greedy Method:
import java.io.*;
import java.util.*;
class jobScheduling{
public static void main(String args[]){
int i,j,t,k,r,q,profit=0;
Scanner sc=new Scanner(System.in);
System.out.print("enter the number:");
int n=sc.nextInt();
int[] d=new int[n+1];
int[] p=new int[n+1];
int[] J=new int[n+1];
int[] t1=new int[n+1];

d[0]=0;
J[0]=0;
p[0]=0;
J[1]=1;
System.out.println("enter the deadlines:");
for(i=1;i<n+1;i++){
d[i]=sc.nextInt();
}
System.out.println("Enter the profits:");
for(i=1;i<n+1;i++){
p[i]=sc.nextInt();
}
for(i=0;i<n+1;i++){
t1[i]=p[i];
}
for(i=1;i<n+1;i++){
for(j=1;j<n-i;j++){
if(p[j]<p[j+1]){
t=d[j];
d[j]=d[j+1];
d[j+1]=t;

t=p[j];
p[j]=p[j+1];
p[j+1]=t;
 46

}
}
}
for(i=0;i<n+1;i++){
System.out.print(d[i]+" ");
}
System.out.println();
for(i=0;i<n+1;i++){
System.out.print(p[i]+" ");
}
System.out.println();
k=1;
for(i=2;i<n;i++){
r=k;
while((d[J[r]]>d[i]) && (d[J[r]]!=r)){
r=r-1;
}
if((d[J[r]]<=d[i]) && (d[i]>r)){
for(q=k;q>r+1;q--){
J[q+1]=J[q];
}
J[r+1]=i;
k++;

}
System.out.println();
for(i=0;i<=n;i++){
System.out.println(J[i]+" ");
}
System.out.println();
for(i=0;i<n;i++){
if(J[i]!=0){

System.out.print(J[i]+" ");
profit+=t1[J[i]];
}
}
System.out.println(profit);
 47

}
}Output:

25. Write a program to implement Single source shortest

path problem by using Greedy Method:

import
java.io.*;
import
java.util.*;class
Main{
public static void main(String args[]){
int n , v,u,i,j;

int min;
Scanner sc = new Scanner(System.in);
System.out.println("Enter the value of n :");
n = sc.nextInt();
int[][] cost = new int[n][n];
int[] dist = new int[n+1];
int[] prev=new int[n];
boolean[] visited = new boolean[n];
System.out.println("Enter the adjacency matrix :");
for (i=0;i<n;i++){
for(j=0;j<n;j++){
cost[i][j]=sc.nextInt();
 48

if(cost[i][j]==0)
cost[i][j] = Integer.MAX_VALUE;
}
}
System.out.println("Enter v");
v = sc.nextInt();
for(i=0;i<n;i++){
visited[i] =false;
dist[i]=cost[v][i];
prev[i]=-1;
}
visited[v]=true;
dist[v] = 0;
dist[n]=integer.MAX_VALUE;
for(i=0;i<n-1;i++){
min = n;
for(j=0;j<n ;j++)
{
if(visited[j]==false){
if(dist[j]<=dist[min])
{
min = j;

}
}
}

visited[min]=true;
for(u=0;u<n;u++)
{
if(visited[u]==false){

if(dist[min]!= Integer.MAX_VALUE&&cost[min][u]!= Integer.MAX_VALUE

&&dist[u]>dist[min]+cost[min][u]){
dist[u]=dist[min]+cost[min][u];
prev[u]=min;
}
 49

}
}
}

for(i=0;i<n;i++){
System.out.println("Distance from source to "+i+":"+dist[i]);
List<Integer>path=new ArrayList<>();
int cur=i;
while(cur!=-1){
path.add(0,cur);
cur=prev[cur];
}
path.add(0,v);
System.out.println("shortest path from "+v+" to "+i+":"+path);
}

}
}
Output: