Question

I need Help PLZ ( Java Code ).

Tomorrow 05.06.2019 I have to hand in my homework.

reachability

Actually, you find flying very good, but you do not trust the whole new-fangled flying stuff and the infrastructure it has built up. As a diehard medieval metal fan you prefer to travel from A to B but rather the good old catapult. Since one can not easily take the favorite cat on vacation with it (cats do not get drafts, which is why ICEs are also eliminated), they let themselves be asked to take a plane on vacation. So you are now looking at the network spanned by airports and existing direct connections and wondering which airports are actually critical. A critical airport is an airport whose sudden disappearance would make it impossible to reach all other (remaining) airports from any (remaining) airport. For example, in the following example, the airports ICT and TXL are critical airports, but not BER:

LAS JAV BER IKT! FNJ

So you decide to write a program that will calculate the amount of critical airports for you. You can assume the following assumptions:

At the beginning, all other airports can be reached from any airport.
If a connection from airport
F1 to F2 airport will also consist of a link from F2 airport back to F1.
In the ads.set3.airports package, write a CriticalAirportFinder class and implement the following method:

/ **
* Finds whose removal causes unrealistic destinations. Thus, the
* result must be a set of airports that, if removed, cause at least one pair of
* other airports to have no path between them.
*
* @param airports set of airports.
* @return set of critical airports. Can it be empty?
* airports without a path between them in the input. Must not be
* {@code null}.
* /
public static set findCriticalAirports (Set airports) {
// TODO Implement me!
}

the class Airport:

package ads.set3.airports;

import java.util.HashSet;
import java.util.Set;
import java.util.regex.Pattern;

/**
* Models an airport. For them to be identifiable, all airports have an
* IATA code and
* two airports are considered equal if their IATA codes match. Since this class
* implements {@link #equals(Object)} and {@link #hashCode()}, it can be used in
* hash-based data structures, such as {@link HashSet}.
*
*

* Each airport has a (possibly empty) set of designations that can be reached
* directly (that is, there are direct flights from this airport to all
* designation airports). If there is a direct flight from this airport to
* another airport, there will be a direct return flight as well.
*

*/
public final class Airport implements Comparable {

/** The airport's IATA designation. */
private final String iataDesignation;
/** Set of airports that can be reached from this airport. */
private final Set destinations = new HashSet<>();

/**
* Creates a new airport with no connected airports.
*
* @param iataCode the airport's non-{@code null} IATA designation.
* @throw IllegalArgumentException if the code is invalid.
*/
public Airport(String iataCode) {
ensureValidIataDesignation(iataCode);
this.iataDesignation = iataCode;
}

/**
* Throws an {@link IllegalArgumentException} if the given String is not a valid
* IATA designation.
*/
public static void ensureValidIataDesignation(String iata) {
if (iata == null) {
throw new IllegalArgumentException("IATA code cannot be null.");
}

if (!Pattern.matches("[a-zA-Z]{3}", iata)) {
throw new IllegalArgumentException("IATA codes must consist of three characters.");
}
}

/**
* Returns this airport's IATA designation.
*/
public String getIataDesignation() {
return iataDesignation;
}

/**
* Returns the airport's set of destinations that can be reached directly, to be
* modified at will.
*/
public Set getDestinations() {
return destinations;
}

@Override
public boolean equals(Object obj) {
if (obj instanceof Airport) {
return ((Airport) obj).getIataDesignation().equals(this.getIataDesignation());
} else {
return false;
}
}

@Override
public int hashCode() {
return getIataDesignation().hashCode();
}

@Override
public int compareTo(Airport o) {
return iataDesignation.compareTo(o.iataDesignation);
}

}

I dont have The airport package mentioned.

Answer 1

// Import the required classes import java.io.*; import java.util.*; //Create the class public class DPriorityQueue { te members variables. //Declare the priva private int type1,type2; private String CostInTime [] [], sVertex, DVertex; private List<String> listofTheNodes; private Set<String> List; private List<Root> ListofVisitedNode; private HashMap<string, Integer> minimalDistance; private HashMap<string, Integer> distofvertices; private PriorityQueue<city> priorityQueue // prove the definition of the function to priority queue of the nodes create public DPriorityQueue (List<string> listofTheNodes) { listofThe Nodes; this.listofTheNodes minimalDistance = new HashMap<String, Integer> (); = new HashMap<String, Integer>(); distofVertices = new HashSet<String> ); List ListofvisitedNode ArrayList<Root>(); PriorityQueue<city>(new City )); = new priorityQueue new

/ Find the neighboring node in the file private void FindTheadjacent (String evaluationNode, Root evaluationNodeList) int d -1; -1; int newd = 0; i<CostInTime.length; i++ for (int i if (!CostInTime [i] [0].equals (evaluationNode)) continue; String target; for (int j = 0; j listofThe Nodes.size (); j++ listofTheNodes.get (j) ; target if (!CostInTime [i] [1].equals (target)) continue; if (!List.contains (target)) d Integer.parseInt(CostInTime [i] [type1]); minimalDistance.get (evaluationNode) d; newd if (newd < minimalDistance.get (target)) minimalDistance.replace (target,newd) distofvertices.replace (target,distofVertices.get (evaluationNode) Integer.parseInt(CostInTime [i] [type2])); ListofvisitedNode) for (Root path if (path.exists (target)) path.delete (target); break } evaluationNodeList.add (target); priorityQueue.add (new City (target,minimalDistance.get (target))); }

// return the node which has the minimum distance private String getVetex () { priorityQueue.remove ).city; String node return node; } // Dijkstra,s algorithm definition public void dijkastra(string costInTime[] [], String requiredPath[)) String vartexEvaluation; requiredPath[0] requiredPath[1] if (requiredPath [2].equalsIgnoreCase ("C")) SVertex DVertex = 2; 3; type1 type2 else 3; type1 type2 = 2; this.CostInTime costInTime; = for (String vertex:listofTheNodes) minimalDistance.put vertex, Integer.MAX VALUE) distofvertices.put(vertex, Integer.MAX VALUE); } priorityQueue.add (new city (SVertex, 0)); minimalDistance.replace (SVertex, 0) distofVertices.replace (SVertex, 0); while priorityQueue.isEmpty()) getVetex ); vartexEvaluation = Root evaluationNodeList = new Root (); evaluationNodeList.setNode (vartexEvaluation); List.add (vartexEvaluation); FindTheadjacent (vartexEvaluation, evaluationNodeList); if (!isThereVertex (ListofvisitedNode, vartexEvaluation)) ListofvisitedNode.add (evaluationNodeList);

//Check the node in the file private boolean isThereVertex (List<Root> listofvisitedVertex, String node) for (Root p :ListofvisitedNode) if (p.getNode () .equals (node)) return true; } return false; } / Find the destination node in the file to complete the path. private static List<String> PathofTheRoot (List<Root> visitedCity, String target) List<String> completePath for Root path ArrayList<String> (); new = visitedCity) if (!path.exists (target)) continue; complete Path = completePath.add(target); return completePath; PathofTheRoot(visitedcity, path.getNode ()); } completePath.add(target) return completePath;

while (data.hasMoreTokens ()) timeCost[i] [j++] = data.nextToken (); i++ i -0; /Make tokens of the data of the requestedFlight Data file while ((string = requestedData.readLine () ) != null) j-0 StringTokenizer data = new StringTokenizer(string,"|"); while (data.hasMoreTokens() PathList[i) [j++] = data.nextToken (); i++ i-1 ; // Check the type of the cost for (String requsetedPath[) : PathList) if (! (listOfThe Node.contains (requsetedPath [0]) && listOfTheNode.contains (requsetedPath[1]))) out.println ("Path can not be find!!!!!"); continue; String type,_otherType; if (requsetedPath [2].equals ("T")) type "Time"; otherType = "Cost"; else type " Cost"; otherType = "Time";

/Call the DijkstraPriorityQueue to make the priority queue. DPriorityQueue priorityQueue new DPriorityQueue (listofTheNode); / Call the dijkstra_algorithm method to priorityQueue.dijkastra (timeCost, requsetedPath) run the Dijkstra's algorithm .println("Flight "+i+": "+priorityQueue.SVertext". priorityQueue.DVertex+" ("+_type+") "); out for (String vertex:listofTheNode) if (!vertex.equals (priorityQueue.DVertex) continue; List<String> list PathofTheRoot (priorityQueue.ListofvisitedNode, priorityQueue.DVertex); for (int k = 0; k < list.size (); k++ list.size()-1) out.print (list.get (k) +". "); if (k else -- "); out.print (list.get (k) ". } - .println(_type+": " + priorityQueue.minimalDistance.get (vertex)". _otherType+": "+priorityQueue.distofvertices.get (vertex)); out break; i++ } }catch (Exception e) System.out.println("Exception has occured:" + e.toString ()) out.close ();

City.java:

// Import the class Comparator import java.util.comparator; / Class class City implements Comparator<city> { public String city; public int cost; public City () 77Compare the nodes @Override public int compare (City node1, city node2) { if (node1.cost <node2.cost) return -1; if (nodel.cost > node2.cost) return 1 return 0 } public City (String city, int cost) city this.city this.cost cost = }

Root.java:

// Import the required classes import java.util.ArrayList; import java.util.List; // Create the class class Root private List<String private String city; /Get the node root public String getNode () { return this.city } / Add the node in the array List public void add (String city) root.add (city); } /Delete the node from the list public void delete (String city) { (city) root.remove /Check if the node exist or not public Boolean exists(String city) if (root.contains (city)) return true; return false; } //Create the arrayList public Root ArrayList<String>(); root new / Set the node public void setNode (String Node) this.city Node; }

Sample output:

output.txt:

Flight 1: Time Dallas, Houston Dallas -> Houston. Time: 51 101 Cost Flight 2: Chicago, Dallas (Cost) Chicago - Austin Time: 250 --> Dallas. Cost: 255

FlightData.txt:

7 Dallas |Austin |98 | 47 Austin | Houston|95|39 Dallas |Houston|101|51 Austin|Chicago|144|192 Chicago| Austin|155|200 Austin | Dallas|100 |50 Houston |Dallas|100|50

Requested.txt:

Code to copy:

DPriorityQueue.java:

// Import the required classes
import java.io.*;
import java.util.*;

//Create the class
public class DPriorityQueue
{
//Declare the private members variables.
private int type1,type2;
private String CostInTime[][], SVertex, DVertex;
private List<String> listOfTheNodes;
private Set<String> List;
private List<Root> ListOfVisitedNode;
private HashMap<String, Integer> minimalDistance;
private HashMap<String, Integer> distOfVertices;
private PriorityQueue<City> priorityQueue;

// prove the definition of the function to create priority queue of the nodes
public DPriorityQueue(List<String> listOfTheNodes)
{   
  this.listOfTheNodes = listOfTheNodes;
  minimalDistance = new HashMap<String,Integer>();
  distOfVertices = new HashMap<String,Integer>();
  List = new HashSet<String>();
  ListOfVisitedNode = new ArrayList<Root>();
  priorityQueue = new PriorityQueue<City>(new City());      
}

// Find the neighboring node in the file
private void FindTheadjacent(String evaluationNode, Root evaluationNodeList)
{
  int d = -1;
  int newd = -1;

  for (int i = 0; i<CostInTime.length; i++)
  {
   if(!CostInTime[i][0].equals(evaluationNode))
    continue;
   String target;
   for (int j = 0; j < listOfTheNodes.size(); j++)
   {
    target = listOfTheNodes.get(j);
    if(!CostInTime[i][1].equals(target))
     continue;
    if (!List.contains(target))
    {
     d = Integer.parseInt(CostInTime[i][type1]);
     newd = minimalDistance.get(evaluationNode) + d;
     if (newd < minimalDistance.get(target))
     {
      minimalDistance.replace(target,newd);
      distOfVertices.replace(target,distOfVertices.get(evaluationNode) +
        Integer.parseInt(CostInTime[i][type2]));
      for (Root path : ListOfVisitedNode)
      {
       if(path.exists(target))
        path.delete(target);
       break;
      }
      evaluationNodeList.add(target);
     }
     priorityQueue.add(new City(target,minimalDistance.get(target)));
    }  
   }
  }
}

// return the node which has the minimum distance
private String getVetex()
{
  String node = priorityQueue.remove().city;
  return node;
}

// Dijkstra,s algorithm definition
public void dijkastra(String costInTime[][], String requiredPath[])
{
  String vartexEvaluation;
  SVertex = requiredPath[0];
  DVertex = requiredPath[1];
  if(requiredPath[2].equalsIgnoreCase("C"))
  {
   type1 = 2;
   type2 = 3;
  }
  else
  {
   type1 = 3;
   type2 = 2;
  }

  this.CostInTime = costInTime;

  for (String vertex:listOfTheNodes)
  {
   minimalDistance.put(vertex, Integer.MAX_VALUE);
   distOfVertices.put(vertex, Integer.MAX_VALUE);
  }

  priorityQueue.add(new City(SVertex, 0));
  minimalDistance.replace(SVertex,0);
  distOfVertices.replace(SVertex, 0);
  while (!priorityQueue.isEmpty())
  {
   vartexEvaluation = getVetex();
   Root evaluationNodeList = new Root();
   evaluationNodeList.setNode(vartexEvaluation);
   List.add(vartexEvaluation);
   FindTheadjacent(vartexEvaluation, evaluationNodeList);
   if(!isThereVertex(ListOfVisitedNode, vartexEvaluation))
    ListOfVisitedNode.add(evaluationNodeList);
  }
}
// Check the node in the file
private boolean isThereVertex(List<Root> listOfVisitedVertex, String node)
{
  for (Root p : ListOfVisitedNode)
  {
   if(p.getNode().equals(node))
    return true;
  }
  return false;
}

// Find the destination node in the file to complete the path.
private static List<String> PathofTheRoot(List<Root> visitedCity, String target)
{
  List<String> completePath = new ArrayList<String>();
  for( Root path : visitedCity)
  {
   if(!path.exists(target))
    continue;
   completePath = PathofTheRoot(visitedCity, path.getNode());
   completePath.add(target);
   return completePath;
  }
  completePath.add(target);
  return completePath;
}

// Start the main method of the program
public static void main(String[] arg) throws FileNotFoundException
{
  //Declare the variables.
  String timeCost[][],PathList[][];
  BufferedReader dataOfTheFlight, requestedData;
  List<String> listOfTheNode;
  PrintWriter out = new PrintWriter("output1.txt");

  try
  {
   // Read the data from the files
   dataOfTheFlight = new BufferedReader(new FileReader("FlightData1.txt"));
   requestedData = new BufferedReader(new FileReader("Requested.txt"));

   String string;

   listOfTheNode = new ArrayList<String>();
   timeCost = new String[Integer.parseInt(dataOfTheFlight.readLine())][4];
   PathList = new String[Integer.parseInt(requestedData.readLine())][3];

   int i=0,j; String _node;

   // Make tokens of the data of the flightData file
   while((string = dataOfTheFlight.readLine()) != null)
   {
    j=0;
    StringTokenizer data = new StringTokenizer(string,"|");
    int k = 1;
    while(k<=2)
    {
     if(!listOfTheNode.contains(_node = data.nextToken()))
     {
      timeCost[i][j++] = _node;
      listOfTheNode.add(_node);
     }
     else
      timeCost[i][j++] = _node;
     k++;
    }

    while(data.hasMoreTokens())
    {
     timeCost[i][j++] = data.nextToken();
    }
    i++;         
   }
   i=0;

   // Make tokens of the data of the requestedFlightData file
   while((string = requestedData.readLine()) != null)
   {
    j=0;
    StringTokenizer data = new StringTokenizer(string,"|");
    while(data.hasMoreTokens())       
     PathList[i][j++] = data.nextToken();
    i++;         
   }       

   i=1;

   // Check the type of the cost
   for(String requsetedPath[] : PathList)
   {
    if(!(listOfTheNode.contains(requsetedPath[0])&& listOfTheNode.contains(requsetedPath[1])))
    {
     out.println("Path can not be find !!!!!");
     continue;
    }
    String _type,_otherType;

    if(requsetedPath[2].equals("T"))
    {
     _type = "Time";
     _otherType = "Cost";
    }

    else
    {
     _type = "Cost";
     _otherType = "Time";
    }

    // Call the DijkstraPriorityQueue to make the priority queue.
    DPriorityQueue priorityQueue = new DPriorityQueue(listOfTheNode);

    // Call the dijkstra_algorithm method to run the Dijkstra's algorithm
    priorityQueue.dijkastra(timeCost, requsetedPath);

    out.println("Flight "+i+": "+priorityQueue.SVertex+", "+
      priorityQueue.DVertex+" ("+_type+")");
    for (String vertex:listOfTheNode)
    {
     if(!vertex.equals(priorityQueue.DVertex))
      continue;
     List<String> list = PathofTheRoot(priorityQueue.ListOfVisitedNode,
       priorityQueue.DVertex);
     for (int k = 0; k < list.size(); k++)
     {
      if(k == list.size()-1 )
       out.print(list.get(k)+". ");
      else
       out.print(list.get(k)+" --> ");
     }                  
     out.println(_type+": " + priorityQueue.minimalDistance.get(vertex)+" "
       +_otherType+": "+priorityQueue.distOfVertices.get(vertex));
     break;
    }
    i++;
   }

  } catch (Exception e)
  {
   System.out.println("Exception has occured:" + e.toString());
  }
  out.close();
}
}

City.java:

//Import the class Comparator
import java.util.Comparator;
// Class
class City implements Comparator<City>
{
public String city;
public int cost;

public City()
{
}

// Compare the nodes.
@Override
public int compare(City node1, City node2)
{
  if (node1.cost < node2.cost)
   return -1;
  if (node1.cost > node2.cost)
   return 1;
  return 0;
}

public City(String city, int cost)
{
  this.city = city;
  this.cost = cost;
}
}

Root.java:

// Import the required classes
import java.util.ArrayList;
import java.util.List;
// Create the class
class Root
{
private List<String> root;
private String city;
// Get the node
public String getNode()
{
  return this.city;
}
// Add the node in the array List
public void add(String city)
{
  root.add(city);
}
//Delete the node from the list
public void delete(String city)
{
  root.remove(city);
}
// Check if the node exist or not
public Boolean exists(String city)
{
  if(root.contains(city))
   return true;
  return false;
}
//Create the arrayList
public Root()
{
  root = new ArrayList<String>();
}
// Set the node
public void setNode(String Node)
{
  this.city = Node;
}
}

FlightData1.txt

7
Dallas|Austin|98|47
Austin|Houston|95|39
Dallas|Houston|101|51
Austin|Chicago|144|192
Chicago|Austin|155|200
Austin|Dallas|100|50
Houston|Dallas|100|50

Requested.txt:

2
Dallas|Houston|T
Chicago|Dallas|C