Homework Help is Here – Start Your Trial Now!
Engineering
Computer Science
Java Program using Replit, please help. I circled the problem with red, because whenever I run the program, the entire output doesn't show and it tells me that "./Main.java uses unchecked or unsafe operations". How can I stop that from happening? Program in the photos.

Java Program using Replit, please help. I circled the problem with red, because whenever I run the program, the entire output doesn't show and it tells me that "./Main.java uses unchecked or unsafe operations". How can I stop that from happening? Program in the photos.

Database System Concepts
Database System Concepts
7th Edition
ISBN:9780078022159
Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Chapter1: Introduction
Section: Chapter Questions
Problem 1PE
See similar textbooks
icon
Related questions
Question

Java Program using Replit, please help. I circled the problem with red, because whenever I run the program, the entire output doesn't show and it tells me that "./Main.java uses unchecked or unsafe operations". How can I stop that from happening?

Program in the photos.

```java 57 for (int u = 0; u < V; u++) 58 59 // Doesn't recur if already visited 60 if (!visited[u]) 61 if (isCyclicUtil(u, visited, -1)) 62 return true; 63 return false; 64 } 65 66 // Driver Method 67 public static void main(String[] args) { 68 // Creates a graph 69 Main g1 = new Main(5); 70 g1.addEdge(1, 0); 71 g1.addEdge(0, 2); 72 g1.addEdge(2, 0); 73 g1.addEdge(0, 3); 74 g1.addEdge(3, 4); 75 if (g1.isCyclic()) 76 System.out.println("Graph contains a cycle"); 77 else 78 System.out.println("Graph doesn't contain a cycle"); 79 Main g2 = new Main(3); 80 g2.addEdge(0, 1); 81 g2.addEdge(1, 2); 82 if (g2.isCyclic()) 83 System.out.println("Graph contains a cycle"); 84 else 85 System.out.println("Graph doesn't contain a cycle"); 86 } 87 } 88 ``` ### Description This Java code snippet is part of a program designed to detect cycles in a graph. The cycle detection is performed using Depth First Search (DFS). - **Lines 57-64:** This loop iterates through all vertices and checks if a cycle exists in the graph using a utility function `isCyclicUtil`. - **Lines 66-88:** The `main` method is the entry point of the program. It creates two graphs, `g1` and `g2`, using the `Main` class constructor which seems to represent the number of vertices. - **Graph `g1`:** Contains 5 vertices. Edges are added between vertices, creating potential cycles. - **Graph `g2`:** Contains 3 vertices. Edges are added sequentially, making it acyclic. After adding edges, the `isCyclic` method checks each graph for cycles and outputs the results to the console. This example demonstrates
Transcribed Image Text:```java 57 for (int u = 0; u < V; u++) 58 59 // Doesn't recur if already visited 60 if (!visited[u]) 61 if (isCyclicUtil(u, visited, -1)) 62 return true; 63 return false; 64 } 65 66 // Driver Method 67 public static void main(String[] args) { 68 // Creates a graph 69 Main g1 = new Main(5); 70 g1.addEdge(1, 0); 71 g1.addEdge(0, 2); 72 g1.addEdge(2, 0); 73 g1.addEdge(0, 3); 74 g1.addEdge(3, 4); 75 if (g1.isCyclic()) 76 System.out.println("Graph contains a cycle"); 77 else 78 System.out.println("Graph doesn't contain a cycle"); 79 Main g2 = new Main(3); 80 g2.addEdge(0, 1); 81 g2.addEdge(1, 2); 82 if (g2.isCyclic()) 83 System.out.println("Graph contains a cycle"); 84 else 85 System.out.println("Graph doesn't contain a cycle"); 86 } 87 } 88 ``` ### Description This Java code snippet is part of a program designed to detect cycles in a graph. The cycle detection is performed using Depth First Search (DFS). - **Lines 57-64:** This loop iterates through all vertices and checks if a cycle exists in the graph using a utility function `isCyclicUtil`. - **Lines 66-88:** The `main` method is the entry point of the program. It creates two graphs, `g1` and `g2`, using the `Main` class constructor which seems to represent the number of vertices. - **Graph `g1`:** Contains 5 vertices. Edges are added between vertices, creating potential cycles. - **Graph `g2`:** Contains 3 vertices. Edges are added sequentially, making it acyclic. After adding edges, the `isCyclic` method checks each graph for cycles and outputs the results to the console. This example demonstrates
```java import java.util.LinkedList; import java.util.Iterator; class Main { // Number of Vertices private int V; // Adjacency Lists private LinkedList<Integer> adj[]; // Constructor Main(int v) { V = v; adj = new LinkedList[v]; for (int i = 0; i < v; ++i) adj[i] = new LinkedList(); } // Function that adds an edge to the graph void addEdge(int v, int w) { adj[v].add(w); adj[w].add(v); } // A recursive function that uses visited[] and parent to detect cycle in subgraph reachable from vertex v. Boolean isCyclicUtil(int v, Boolean visited[], int parent) { // Marks the current node as visited visited[v] = true; Integer i; // Recur for all the vertices adjacent to this vertex Iterator<Integer> it = adj[v].iterator(); while (it.hasNext()) { i = it.next(); // If an adjacent is not visited, then recur for that adjacent if (!visited[i]) { if (isCyclicUtil(i, visited, v)) return true; } // If an adjacent is visited and not parent of current vertex, then there is a cycle else if (i != parent) return true; } return false; } // Returns true if the graph contains a cycle, else false. Boolean isCyclic() { // Mark all the vertices as not visited and not part of recursion stack Boolean visited[] = new Boolean[V]; for (int i = 0; i < V; i++) visited[i] = false; // Call the recursive helper function to detect cycle in different DFS trees ``` ### Explanation This code defines a structure and methods to represent a graph using adjacency lists and includes functionality to detect cycles within the graph. Key components include: - **Vertices and Adjacency Lists:** The graph's vertices and their connections are stored using an array of `LinkedList` objects where each index represents a vertex and the linked list at that index contains the vertices adjacent to it. - **Constructor:** Initializes the graph with a specified number of vertices and creates adjacency lists for each vertex. - **addEdge
Transcribed Image Text:```java import java.util.LinkedList; import java.util.Iterator; class Main { // Number of Vertices private int V; // Adjacency Lists private LinkedList<Integer> adj[]; // Constructor Main(int v) { V = v; adj = new LinkedList[v]; for (int i = 0; i < v; ++i) adj[i] = new LinkedList(); } // Function that adds an edge to the graph void addEdge(int v, int w) { adj[v].add(w); adj[w].add(v); } // A recursive function that uses visited[] and parent to detect cycle in subgraph reachable from vertex v. Boolean isCyclicUtil(int v, Boolean visited[], int parent) { // Marks the current node as visited visited[v] = true; Integer i; // Recur for all the vertices adjacent to this vertex Iterator<Integer> it = adj[v].iterator(); while (it.hasNext()) { i = it.next(); // If an adjacent is not visited, then recur for that adjacent if (!visited[i]) { if (isCyclicUtil(i, visited, v)) return true; } // If an adjacent is visited and not parent of current vertex, then there is a cycle else if (i != parent) return true; } return false; } // Returns true if the graph contains a cycle, else false. Boolean isCyclic() { // Mark all the vertices as not visited and not part of recursion stack Boolean visited[] = new Boolean[V]; for (int i = 0; i < V; i++) visited[i] = false; // Call the recursive helper function to detect cycle in different DFS trees ``` ### Explanation This code defines a structure and methods to represent a graph using adjacency lists and includes functionality to detect cycles within the graph. Key components include: - **Vertices and Adjacency Lists:** The graph's vertices and their connections are stored using an array of `LinkedList` objects where each index represents a vertex and the linked list at that index contains the vertices adjacent to it. - **Constructor:** Initializes the graph with a specified number of vertices and creates adjacency lists for each vertex. - **addEdge
Expert Solution
trending now

Trending now

This is a popular solution!

steps

Step by step

Solved in 2 steps with 5 images

SEE SOLUTIONCheck out a sample Q&A here
Blurred answer
Knowledge Booster
Top down approach design
Learn more about
Need a deep-dive on the concept behind this application? Look no further. Learn more about this topic, computer-science and related others by exploring similar questions and additional content below.
Similar questions
Recommended textbooks for you
Database System Concepts
Database System Concepts
Computer Science
ISBN:
9780078022159
Author:
Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Publisher:
McGraw-Hill Education
Starting Out with Python (4th Edition)
Starting Out with Python (4th Edition)
Computer Science
ISBN:
9780134444321
Author:
Tony Gaddis
Publisher:
PEARSON
Digital Fundamentals (11th Edition)
Digital Fundamentals (11th Edition)
Computer Science
ISBN:
9780132737968
Author:
Thomas L. Floyd
Publisher:
PEARSON
C How to Program (8th Edition)
C How to Program (8th Edition)
Computer Science
ISBN:
9780133976892
Author:
Paul J. Deitel, Harvey Deitel
Publisher:
PEARSON
Database Systems: Design, Implementation, & Manag…
Database Systems: Design, Implementation, & Manag…
Computer Science
ISBN:
9781337627900
Author:
Carlos Coronel, Steven Morris
Publisher:
Cengage Learning
Programmable Logic Controllers
Programmable Logic Controllers
Computer Science
ISBN:
9780073373843
Author:
Frank D. Petruzella
Publisher:
McGraw-Hill Education
SEE MORE TEXTBOOKS