Database System Concepts
7th Edition
ISBN: 9780078022159
Author: Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Publisher: McGraw-Hill Education
expand_more
expand_more
format_list_bulleted
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](https://content.bartleby.com/qna-images/question/4cd5838b-3f34-487e-9642-7770197fe05c/79634c60-80ea-4b68-a935-181b01cf9d6b/fz1z65k_processed.png)
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](https://content.bartleby.com/qna-images/question/4cd5838b-3f34-487e-9642-7770197fe05c/79634c60-80ea-4b68-a935-181b01cf9d6b/lqtpvw_processed.png)
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
This question has been solved!
Explore an expertly crafted, step-by-step solution for a thorough understanding of key concepts.
This is a popular solution
Trending nowThis is a popular solution!
Step by stepSolved in 2 steps with 5 images
Knowledge Booster
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
- Implement the Board class. Make sure to read through those comments so that you know what is required. import java.util.Arrays; import java.util.Random; public class Board { // You don't have to use these constants, but they do make your code easier to read public static final byte UR = 0; public static final byte R = 1; public static final byte DR = 2; public static final byte DL = 3; public static final byte L = 4; public static final byte UL = 5; // You need a random number generator in order to make random moves. Use rand below private static final Random rand = new Random(); private byte[][] board; /** * Construct a puzzle board by beginning with a solved board and then * making a number of random moves. Note that making random moves * could result in the board being solved. * * @param moves the number of moves to make when generating the board. */ public Board(int moves) { // TODO } /** * Construct a puzzle board using a 2D array of bytes to indicate the contents *…arrow_forwardTHIS IS MEANT TO BE IN JAVA. What we've learned so far is variables, loops, and we just started learning some array today. The assignment is to get an integer from input, and output that integer squared, ending with newline. But i've been given some instructions that are kind of confusing to me. Please explain why and please show what the end result is. Here are some extra things i've been told to do with the small amount of code i've already written... Type 2 in the input box, then run the program so I can note that the answer is 4 Type 3 in the input box instead, run, and note the output is 6. Change the output statement to output a newline: System.out.println(userNumSquared);. Type 2 in the input box Change the program to use * rather than +, and try running with input 2 (output is 4) and 3 (output is now 9, not 6 as before). This is what I have so far... import java.util.Scanner; public class NumSquared {public static void main(String[] args) {Scanner scnr = new…arrow_forwardPlease help and thank you in advance. The language is Java. I have to write a program that takes and validates a date but it won't output the full date. Here is my current code: import java.util.Scanner; public class P1 { publicstaticvoidmain(String[]args) { // project 1 // date input // date output // Create a Scanner object to read from the keyboard. Scannerkeyboard=newScanner(System.in); // Identifier declarations charmonth; intday; intyear; booleanisLeapyear; StringmonthName; intmaxDay; // Asks user to input date System.out.println("Please enter month: "); month=(char)keyboard.nextInt(); System.out.println("Please enter day: "); day=keyboard.nextInt(); System.out.println("Please enter year: "); year=keyboard.nextInt(); // Formating months switch(month){ case1: monthName="January"; break; case2: monthName="February"; break; case3: monthName="March"; break; case4: monthName="April"; break; case5: monthName="May"; break; case6: monthName="June"; break; case7:…arrow_forward
- Utilize Salary.java. The file contains a program that shows how a manager decides an employee’s salary. Two input values are read in: an employee’s current salary a rating of the employee’s performance // ************************************************************// Salary.java// ************************************************************import java.util.Scanner;import java.text.NumberFormat;public class Salary{ public static void main (String[] args) { double currentSalary; // employee's current salary double raise; // amount of the raise double newSalary; // new salary for the employee int rating; // performance rating Scanner scan = new Scanner(System.in); System.out.print ("Enter the current salary: "); currentSalary = scan.nextDouble(); System.out.print ("Enter the performance rating (3 is Excellent, 2 is Good, or 1 is Poor): "); rating = scan.nextInt(); // Enter the code here:…arrow_forwardI need help with Java code. I'm not sure how to start...arrow_forwardWrite in Java! Write the Widget class. a. A widget has a name and price. b. The default for name should be “widget” c. Write a constructor (not the no-args), all getters and setters. d. Add a toString method. e. Create an object of type Widget.arrow_forward
- Using the Card.java class file, write a program to simulate a Deck of Cards. See Programming Project 8.7 (PP 8.7) from page 403 of your textbook (or view the attached image) for a description of what your program needs to do. Note that although the book description of the problem states that you should write the Card class, I do not want you to do that. You must use the Card file exactly as it is provided (NO modifications) and only write the DeckOfCards and Driver classes. public class Card{public final static int ACE = 1;public final static int TWO = 2;public final static int THREE = 3;public final static int FOUR = 4;public final static int FIVE = 5;public final static int SIX = 6;public final static int SEVEN = 7;public final static int EIGHT = 8;public final static int NINE = 9;public final static int TEN = 10;public final static int JACK = 11;public final static int QUEEN = 12;public final static int KING = 13; public final static int CLUBS = 1;public final static int DIAMONDS =…arrow_forwardFind out about Java’s switch-case statement. What is its -purpose? How is it used? Write an example. (This is also a control flow -statement, so you will find information in similar locations as for the do-while loop.)arrow_forwardWrite Java source code to take an integer n and returns the sum of all odd positive integers less than or equals to n. Please implement a sumOddo method for major functionality and a main method with input data for testing cases. Please pay attention to the neat coding style in Java, including grammar, indentations, naming of variables and methods, and comments. a) Conduct an experimental study regarding the running time of your Java code in nanoseconds. Please draw on a separate sheet of paper for the chart/figure on the evaluation results.arrow_forward
arrow_back_ios
arrow_forward_ios
Recommended textbooks for you
- Database System ConceptsComputer ScienceISBN:9780078022159Author:Abraham Silberschatz Professor, Henry F. Korth, S. SudarshanPublisher:McGraw-Hill Education
Starting Out with Python (4th Edition)Computer ScienceISBN:9780134444321Author:Tony GaddisPublisher:PEARSON
Digital Fundamentals (11th Edition)Computer ScienceISBN:9780132737968Author:Thomas L. FloydPublisher:PEARSON 
C How to Program (8th Edition)Computer ScienceISBN:9780133976892Author:Paul J. Deitel, Harvey DeitelPublisher:PEARSON
Database Systems: Design, Implementation, & Manag...Computer ScienceISBN:9781337627900Author:Carlos Coronel, Steven MorrisPublisher:Cengage Learning
Programmable Logic ControllersComputer ScienceISBN:9780073373843Author:Frank D. PetruzellaPublisher:McGraw-Hill Education
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)
Computer Science
ISBN:9780134444321
Author:Tony Gaddis
Publisher:PEARSON
Digital Fundamentals (11th Edition)
Computer Science
ISBN:9780132737968
Author:Thomas L. Floyd
Publisher:PEARSON
C How to Program (8th Edition)
Computer Science
ISBN:9780133976892
Author:Paul J. Deitel, Harvey Deitel
Publisher:PEARSON
Database Systems: Design, Implementation, & Manag...
Computer Science
ISBN:9781337627900
Author:Carlos Coronel, Steven Morris
Publisher:Cengage Learning
Programmable Logic Controllers
Computer Science
ISBN:9780073373843
Author:Frank D. Petruzella
Publisher:McGraw-Hill Education