answer:Here's a simple C# program that calculates the area and perimeter of a circle using `Math.PI`: ```csharp using System; class Program { static void Main() { Console.Write(Enter the radius of the circle: ); string input = Console.ReadLine(); if (double.TryParse(input, out double radius)) { if (radius <= 0) { Console.WriteLine(Radius must be greater than zero.); } else { double area = CalculateArea(radius); double perimeter = CalculatePerimeter(radius); Console.WriteLine(Area of the circle: {area:F2}); Console.WriteLine(Perimeter of the circle: {perimeter:F2}); } } else { Console.WriteLine(Invalid input. Please enter a valid number.); } } static double CalculateArea(double radius) { return Math.PI * Math.Pow(radius, 2); } static double CalculatePerimeter(double radius) { return 2 * Math.PI * radius; } } ``` In this program, we first prompt the user to input the radius of the circle. We then validate the input to ensure it's a positive number. If the input is valid, we calculate the area and perimeter using the `CalculateArea` and `CalculatePerimeter` methods, respectively. Finally, we display the results with two decimal places.

answer:Here is a Python implementation of a cycle detection algorithm using Depth-First Search (DFS) in a graph: ```python class Graph: def __init__(self, num_vertices): self.num_vertices = num_vertices self.adj_list = [[] for _ in range(num_vertices)] def add_edge(self, src, dest): self.adj_list[src].append(dest) def is_cyclic_util(self, vertex, visited, rec_stack): visited[vertex] = True rec_stack[vertex] = True for neighbor in self.adj_list[vertex]: if not visited[neighbor]: if self.is_cyclic_util(neighbor, visited, rec_stack): return True elif rec_stack[neighbor]: return True rec_stack[vertex] = False return False def is_cyclic(self): visited = [False] * self.num_vertices rec_stack = [False] * self.num_vertices for i in range(self.num_vertices): if not visited[i]: if self.is_cyclic_util(i, visited, rec_stack): return True return False # Test the implementation if __name__ == __main__: num_vertices = 4 edges = [(0, 1), (1, 2), (2, 3), (3, 0)] graph = Graph(num_vertices) for src, dest in edges: graph.add_edge(src, dest) if graph.is_cyclic(): print(Graph contains cycle) else: print(Graph does not contain cycle) ``` In this solution, the `Graph` class represents the graph using an adjacency list. The `is_cyclic_util` function performs the actual DFS traversal, checking if a cycle is detected by maintaining a recursion stack (`rec_stack`). The `is_cyclic` function initializes the visited and recursion stack arrays and calls `is_cyclic_util` for each unvisited vertex. In the test code, a sample graph with a cycle is created, and the `is_cyclic` method is called to detect the cycle.

answer:The provided solution is specifically designed for Directed Acyclic Graphs (DAGs) and will not work correctly for undirected graphs. To modify the solution to work with undirected graphs, we can update the `add_edge` method to add edges in both directions between two nodes. This will effectively create an undirected graph where each edge has a mirrored counterpart. Here's how we can modify the solution to work with both directed and undirected graphs: ```python class Graph: def __init__(self, num_vertices, directed=True): self.num_vertices = num_vertices self.adj_list = [[] for _ in range(num_vertices)] self.directed = directed def add_edge(self, src, dest): self.adj_list[src].append(dest) if not self.directed: self.adj_list[dest].append(src) def is_cyclic_util(self, vertex, visited, parent): visited[vertex] = True for neighbor in self.adj_list[vertex]: if not visited[neighbor]: if self.is_cyclic_util(neighbor, visited, vertex): return True elif neighbor != parent: return True return False def is_cyclic(self): visited = [False] * self.num_vertices for i in range(self.num_vertices): if not visited[i]: if self.is_cyclic_util(i, visited, -1): return True return False # Test the implementation if __name__ == __main__: num_vertices = 4 edges = [(0, 1), (1, 2), (2, 3)] directed_graph = Graph(num_vertices) for src, dest in edges: directed_graph.add_edge(src, dest) directed_graph.add_edge(3, 0) # Adding cycle in directed graph if directed_graph.is_cyclic(): print(Directed Graph contains cycle) else: print(Directed Graph does not contain cycle) undirected_graph = Graph(num_vertices, directed=False) for src, dest in edges: undirected_graph.add_edge(src, dest) if undirected_graph.is_cyclic(): print(Undirected Graph contains cycle) else: print(Undirected Graph does not contain cycle) ``` In this modified solution, the `Graph` class now takes an additional `directed` parameter in its constructor, which defaults to `True` for directed graphs. The `add_edge` method has been modified to add edges in both directions if the graph is undirected. In the `is_cyclic_util` method, we check if the neighbor is equal to the parent node before returning `True` for a cycle. This ensures that we don't incorrectly detect a cycle in an undirected graph due to the mirrored edges. The test code now demonstrates both a directed graph and an undirected graph, with the undirected graph being created by passing `directed=False` to the `Graph` constructor.

answer:Let point B (x, y, z) be the point symmetric to point A (-2, 4, 3) with respect to the coordinate plane yOz. Since points A and B are symmetric with respect to the coordinate plane yOz, the segment AB is bisected by the plane yOz, and AB is perpendicular to the plane yOz. From this, we can conclude x=2, y=4, z=3, so B (2, 4, 3). Therefore, the answer is: boxed{text{A}}