Find the optimal path for the driver to get to the passenger in scala

Comment

0

import scala.collection.mutable

class Graph {
  private val adjacencyList: mutable.Map[Int, List[(Int, Double)]] = mutable.Map.empty

  def addEdge(u: Int, v: Int, weight: Double): Unit = {
    adjacencyList.getOrElseUpdate(u, List.empty) match {
      case edges => adjacencyList.update(u, (v, weight) :: edges)
    }
    adjacencyList.getOrElseUpdate(v, List.empty) match {
      case edges => adjacencyList.update(v, (u, weight) :: edges)
    }
  }

  def findShortestPath(start: Int, end: Int): Option[(List[Int], Double)] = {
    val queue = mutable.PriorityQueue.empty[(Int, Double)].reverse
    val visited = mutable.Set.empty[Int]
    val distance = mutable.Map.empty[Int, Double]
    val parent = mutable.Map.empty[Int, Int]

    queue.enqueue((start, 0.0))
    distance(start) = 0.0

    while (queue.nonEmpty) {
      val (current, currentDist) = queue.dequeue()
      if (current == end) {
        val path = reconstructPath(parent, end)
        return Some((path, currentDist))
      }

      if (!visited.contains(current)) {
        visited += current
        for ((neighbor, weight) <- adjacencyList.getOrElse(current, List.empty)) {
          val newDist = currentDist + weight
          if (!visited.contains(neighbor) && (distance.get(neighbor).isEmpty || newDist < distance(neighbor))) {
            distance(neighbor) = newDist
            parent(neighbor) = current
            queue.enqueue((neighbor, newDist))
          }
        }
      }
    }

    None
  }

  private def reconstructPath(parent: mutable.Map[Int, Int], end: Int): List[Int] = {
    val path = mutable.ListBuffer.empty[Int]
    var current = end
    while (parent.contains(current)) {
      path.prepend(current)
      current = parent(current)
    }
    path.prepend(current)
    path.toList
  }
}

object Main {
  def main(args: Array[String]): Unit = {
    val graph = new Graph()
    graph.addEdge(0, 1, 5.0)
    graph.addEdge(0, 2, 3.0)
    graph.addEdge(1, 2, 2.0)
    graph.addEdge(1, 3, 6.0)
    graph.addEdge(2, 3, 7.0)
    graph.addEdge(2, 4, 4.0)
    graph.addEdge(3, 4, 2.0)

    val startLocation = 0
    val passengerLocation = 4

    graph.findShortestPath(startLocation, passengerLocation) match {
      case Some((path, distance)) =>
        println(s"Optimal path from $startLocation to passenger at $passengerLocation: ${path.mkString(" -> ")}")
        println(s"Total distance: $distance")
      case None =>
        println(s"No path found from $startLocation to passenger at $passengerLocation")
    }
  }
}

Popularity 1/10 Helpfulness 1/10 Language scala

Source: chat.openai.com

Tags: driver find get optimal passenger path scala

Share

Link to this answer
Share Copy Link

Contributed on Sep 02 2023

Sumit Rawal

0 Answers Avg Quality 2/10

Find the optimal path for the driver to get to the passenger in scala

Comment

0

import scala.collection.mutable

class Graph {
  private val adjacencyList: mutable.Map[Int, List[(Int, Double)]] = mutable.Map.empty

  def addEdge(u: Int, v: Int, weight: Double): Unit = {
    adjacencyList.getOrElseUpdate(u, List.empty) match {
      case edges => adjacencyList.update(u, (v, weight) :: edges)
    }
    adjacencyList.getOrElseUpdate(v, List.empty) match {
      case edges => adjacencyList.update(v, (u, weight) :: edges)
    }
  }

  def findShortestPath(start: Int, end: Int): Option[(List[Int], Double)] = {
    val queue = mutable.PriorityQueue.empty[(Int, Double)].reverse
    val visited = mutable.Set.empty[Int]
    val distance = mutable.Map.empty[Int, Double]
    val parent = mutable.Map.empty[Int, Int]

    queue.enqueue((start, 0.0))
    distance(start) = 0.0

    while (queue.nonEmpty) {
      val (current, currentDist) = queue.dequeue()
      if (current == end) {
        val path = reconstructPath(parent, end)
        return Some((path, currentDist))
      }

      if (!visited.contains(current)) {
        visited += current
        for ((neighbor, weight) <- adjacencyList.getOrElse(current, List.empty)) {
          val newDist = currentDist + weight
          if (!visited.contains(neighbor) && (distance.get(neighbor).isEmpty || newDist < distance(neighbor))) {
            distance(neighbor) = newDist
            parent(neighbor) = current
            queue.enqueue((neighbor, newDist))
          }
        }
      }
    }

    None
  }

  private def reconstructPath(parent: mutable.Map[Int, Int], end: Int): List[Int] = {
    val path = mutable.ListBuffer.empty[Int]
    var current = end
    while (parent.contains(current)) {
      path.prepend(current)
      current = parent(current)
    }
    path.prepend(current)
    path.toList
  }
}

object Main {
  def main(args: Array[String]): Unit = {
    val graph = new Graph()
    graph.addEdge(0, 1, 5.0)
    graph.addEdge(0, 2, 3.0)
    graph.addEdge(1, 2, 2.0)
    graph.addEdge(1, 3, 6.0)
    graph.addEdge(2, 3, 7.0)
    graph.addEdge(2, 4, 4.0)
    graph.addEdge(3, 4, 2.0)

    val startLocation = 0
    val passengerLocation = 4

    graph.findShortestPath(startLocation, passengerLocation) match {
      case Some((path, distance)) =>
        println(s"Optimal path from $startLocation to passenger at $passengerLocation: ${path.mkString(" -> ")}")
        println(s"Total distance: $distance")
      case None =>
        println(s"No path found from $startLocation to passenger at $passengerLocation")
    }
  }
}

Popularity 1/10 Helpfulness 1/10 Language scala

Source: chat.openai.com

Tags: find get optimal passenger path scala driver

Share

Link to this answer
Share Copy Link

Contributed on Sep 02 2023

Sumit Rawal

0 Answers Avg Quality 2/10

Find the optimal path for the driver to get to the passenger in scala

Comment

0

import scala.collection.mutable

class Graph {
  private val adjacencyList: mutable.Map[Int, List[(Int, Double)]] = mutable.Map.empty

  def addEdge(u: Int, v: Int, weight: Double): Unit = {
    adjacencyList.getOrElseUpdate(u, List.empty) match {
      case edges => adjacencyList.update(u, (v, weight) :: edges)
    }
    adjacencyList.getOrElseUpdate(v, List.empty) match {
      case edges => adjacencyList.update(v, (u, weight) :: edges)
    }
  }

  def findShortestPath(start: Int, end: Int): Option[(List[Int], Double)] = {
    val queue = mutable.PriorityQueue.empty[(Int, Double)].reverse
    val visited = mutable.Set.empty[Int]
    val distance = mutable.Map.empty[Int, Double]
    val parent = mutable.Map.empty[Int, Int]

    queue.enqueue((start, 0.0))
    distance(start) = 0.0

    while (queue.nonEmpty) {
      val (current, currentDist) = queue.dequeue()
      if (current == end) {
        val path = reconstructPath(parent, end)
        return Some((path, currentDist))
      }

      if (!visited.contains(current)) {
        visited += current
        for ((neighbor, weight) <- adjacencyList.getOrElse(current, List.empty)) {
          val newDist = currentDist + weight
          if (!visited.contains(neighbor) && (distance.get(neighbor).isEmpty || newDist < distance(neighbor))) {
            distance(neighbor) = newDist
            parent(neighbor) = current
            queue.enqueue((neighbor, newDist))
          }
        }
      }
    }

    None
  }

  private def reconstructPath(parent: mutable.Map[Int, Int], end: Int): List[Int] = {
    val path = mutable.ListBuffer.empty[Int]
    var current = end
    while (parent.contains(current)) {
      path.prepend(current)
      current = parent(current)
    }
    path.prepend(current)
    path.toList
  }
}

object Main {
  def main(args: Array[String]): Unit = {
    val graph = new Graph()
    graph.addEdge(0, 1, 5.0)
    graph.addEdge(0, 2, 3.0)
    graph.addEdge(1, 2, 2.0)
    graph.addEdge(1, 3, 6.0)
    graph.addEdge(2, 3, 7.0)
    graph.addEdge(2, 4, 4.0)
    graph.addEdge(3, 4, 2.0)

    val startLocation = 0
    val passengerLocation = 4

    graph.findShortestPath(startLocation, passengerLocation) match {
      case Some((path, distance)) =>
        println(s"Optimal path from $startLocation to passenger at $passengerLocation: ${path.mkString(" -> ")}")
        println(s"Total distance: $distance")
      case None =>
        println(s"No path found from $startLocation to passenger at $passengerLocation")
    }
  }
}

Popularity 1/10 Helpfulness 1/10 Language scala

Source: chat.openai.com

Tags: passenger path scala driver find get optimal

Share

Link to this answer
Share Copy Link

Contributed on Sep 02 2023

Sumit Rawal

0 Answers Avg Quality 2/10

Find the optimal path for the driver to get to the passenger in scala

Comment

0

import scala.collection.mutable

class Graph {
  private val adjacencyList: mutable.Map[Int, List[(Int, Double)]] = mutable.Map.empty

  def addEdge(u: Int, v: Int, weight: Double): Unit = {
    adjacencyList.getOrElseUpdate(u, List.empty) match {
      case edges => adjacencyList.update(u, (v, weight) :: edges)
    }
    adjacencyList.getOrElseUpdate(v, List.empty) match {
      case edges => adjacencyList.update(v, (u, weight) :: edges)
    }
  }

  def findShortestPath(start: Int, end: Int): Option[(List[Int], Double)] = {
    val queue = mutable.PriorityQueue.empty[(Int, Double)].reverse
    val visited = mutable.Set.empty[Int]
    val distance = mutable.Map.empty[Int, Double]
    val parent = mutable.Map.empty[Int, Int]

    queue.enqueue((start, 0.0))
    distance(start) = 0.0

    while (queue.nonEmpty) {
      val (current, currentDist) = queue.dequeue()
      if (current == end) {
        val path = reconstructPath(parent, end)
        return Some((path, currentDist))
      }

      if (!visited.contains(current)) {
        visited += current
        for ((neighbor, weight) <- adjacencyList.getOrElse(current, List.empty)) {
          val newDist = currentDist + weight
          if (!visited.contains(neighbor) && (distance.get(neighbor).isEmpty || newDist < distance(neighbor))) {
            distance(neighbor) = newDist
            parent(neighbor) = current
            queue.enqueue((neighbor, newDist))
          }
        }
      }
    }

    None
  }

  private def reconstructPath(parent: mutable.Map[Int, Int], end: Int): List[Int] = {
    val path = mutable.ListBuffer.empty[Int]
    var current = end
    while (parent.contains(current)) {
      path.prepend(current)
      current = parent(current)
    }
    path.prepend(current)
    path.toList
  }
}

object Main {
  def main(args: Array[String]): Unit = {
    val graph = new Graph()
    graph.addEdge(0, 1, 5.0)
    graph.addEdge(0, 2, 3.0)
    graph.addEdge(1, 2, 2.0)
    graph.addEdge(1, 3, 6.0)
    graph.addEdge(2, 3, 7.0)
    graph.addEdge(2, 4, 4.0)
    graph.addEdge(3, 4, 2.0)

    val startLocation = 0
    val passengerLocation = 4

    graph.findShortestPath(startLocation, passengerLocation) match {
      case Some((path, distance)) =>
        println(s"Optimal path from $startLocation to passenger at $passengerLocation: ${path.mkString(" -> ")}")
        println(s"Total distance: $distance")
      case None =>
        println(s"No path found from $startLocation to passenger at $passengerLocation")
    }
  }
}

Popularity 1/10 Helpfulness 1/10 Language scala

Source: chat.openai.com

Tags: passenger path scala driver find get optimal

Share

Link to this answer
Share Copy Link

Contributed on Sep 02 2023

Sumit Rawal

0 Answers Avg Quality 2/10

Find the optimal path for the driver to get to the passenger in scala

Comment

0

import scala.collection.mutable

class Graph {
  private val adjacencyList: mutable.Map[Int, List[(Int, Double)]] = mutable.Map.empty

  def addEdge(u: Int, v: Int, weight: Double): Unit = {
    adjacencyList.getOrElseUpdate(u, List.empty) match {
      case edges => adjacencyList.update(u, (v, weight) :: edges)
    }
    adjacencyList.getOrElseUpdate(v, List.empty) match {
      case edges => adjacencyList.update(v, (u, weight) :: edges)
    }
  }

  def findShortestPath(start: Int, end: Int): Option[(List[Int], Double)] = {
    val queue = mutable.PriorityQueue.empty[(Int, Double)].reverse
    val visited = mutable.Set.empty[Int]
    val distance = mutable.Map.empty[Int, Double]
    val parent = mutable.Map.empty[Int, Int]

    queue.enqueue((start, 0.0))
    distance(start) = 0.0

    while (queue.nonEmpty) {
      val (current, currentDist) = queue.dequeue()
      if (current == end) {
        val path = reconstructPath(parent, end)
        return Some((path, currentDist))
      }

      if (!visited.contains(current)) {
        visited += current
        for ((neighbor, weight) <- adjacencyList.getOrElse(current, List.empty)) {
          val newDist = currentDist + weight
          if (!visited.contains(neighbor) && (distance.get(neighbor).isEmpty || newDist < distance(neighbor))) {
            distance(neighbor) = newDist
            parent(neighbor) = current
            queue.enqueue((neighbor, newDist))
          }
        }
      }
    }

    None
  }

  private def reconstructPath(parent: mutable.Map[Int, Int], end: Int): List[Int] = {
    val path = mutable.ListBuffer.empty[Int]
    var current = end
    while (parent.contains(current)) {
      path.prepend(current)
      current = parent(current)
    }
    path.prepend(current)
    path.toList
  }
}

Popularity 1/10 Helpfulness 1/10 Language scala

Source: chat.openai.com

Tags: get optimal passenger path scala driver find

Share

Link to this answer
Share Copy Link

Contributed on Sep 02 2023

Sumit Rawal

0 Answers Avg Quality 2/10

Find the optimal path for the driver to get to the passenger in scala

Contents

More Related Answers

Find the optimal path for the driver to get to the passenger in scala

Closely Related Answers

Find the optimal path for the driver to get to the passenger in scala

Find the optimal path for the driver to get to the passenger in scala

Find the optimal path for the driver to get to the passenger in scala

Find the optimal path for the driver to get to the passenger in scala

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.