Breaking News: Grepper is joining You.com. Read the official announcement!

Feature #3: Plot and Select Path

Sumit Rawal answered on May 24, 2023 Popularity 1/10 Helpfulness 1/10

answer Feature #3: Plot and Select Path

Feature #3: Plot and Select Path

Comment

The main problem comes down to finding a path between two nodes, if it exists. If the path exists, return the cumulative sums along the path as the result. Given the problem, it seems that we need to track the nodes where we come from. DFS (Depth-First Search), also known as the backtracking algorithm, will be applicable in this case.

Here is how the implementation will take place:

Build the graph using the city map list G_map.

Assign the cost to each edge while building the graph.

Once the graph is built, evaluate each driver’s path in the drivers list by searching for a path between the driver node and the user node.

Return the accumulated sum if the path exists. Otherwise, return -1.

Let’s look at the code for the solution:

import scala.collection.immutable.List
import scala.collection.mutable
import scala.collection.mutable.{HashMap, HashSet}

object Main {
  def getTotalCost(GMap: List[List[String]], pathCosts: Array[Double], drivers: List[String], user: String): Array[Double] = {
    var city = new HashMap[String, HashMap[String, Double]]
    // Step 1). build the city from the GMap
    for (i <- 0 until GMap.size) {
      var checkPoints = GMap(i)
      var sourceNode = checkPoints(0)
      var destNode = checkPoints(1)
      var pathCost = pathCosts(i)
      if (!city.contains(sourceNode))
        city(sourceNode) = new HashMap[String, Double]()
      if (!city.contains(destNode))
        city(destNode) = new HashMap[String, Double]()
      (city(sourceNode))(destNode) = pathCost
      (city(destNode))(sourceNode) = pathCost
    }
    // Step 2). Evaluate each driver via bactracking (DFS)
    // by verifying if there exists a path from driver to user
    var results = new Array[Double](drivers.size)
    for (i <- 0 until drivers.size) {
      val driver = drivers(i)
      if (!city.contains(driver) || !city.contains(user)) results(i) = -1.0
      else {
        val visited = new HashSet[String]
        results(i) = backtrackEvaluate(city, driver, user, 0, visited)
      }
    }
    results
  }

  def backtrackEvaluate(city: HashMap[String, HashMap[String, Double]], currNode: String, targetNode: String, accSum: Double, visited: mutable.HashSet[String]): Double  = { // mark the visit
    visited.add(currNode)
    var ret = -1.0
    val neighbors = city(currNode)
    if (neighbors.contains(targetNode))
      ret = accSum + neighbors(targetNode)
    else {
      var keys = neighbors.keys.toList
      var i:Int = 0
      var breakit = true
      while (i<keys.size && breakit==true) {
        var nextNode = keys(i)
        if (visited.contains(nextNode)) {
          //--- do nothing
        }
        ret = backtrackEvaluate(city, nextNode, targetNode, accSum + neighbors(nextNode), visited)
        if (ret != -1.0)
          breakit = false
        i += 1
      }
    }
    // unmark the visit, for the next backtracking
    visited.remove(currNode)
    ret
  }

  def main(args: Array[String]): Unit = { // Driver code
    val GMap = List(List("a", "b"), List("b", "c"), List("a", "e"), List("d", "e"))
    val pathCosts = Array(12.0, 23.0, 26.0, 18.0)
    val drivers = List("c", "d", "e", "f")
    val user = "a"
    val allPathCosts = getTotalCost(GMap, pathCosts, drivers, user)
    print("Total cost of all paths: [")
    allPathCosts.foreach({
      el => print(el + ", ")
    })
    print("]")
  }
}

Popularity 1/10 Helpfulness 1/10 Language scala

Source: Grepper

Tags: path plot scala select

Link to this answer
Share Copy Link

Contributed on May 24 2023

Sumit Rawal

0 Answers Avg Quality 2/10

Feature #3: Plot and Select Path

Contents

More Related Answers

Feature #3: Plot and Select Path

Grepper

Documentation

Social

Legal

Contact

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