spark primer 计算单源最短路径

edge.txt (边数据)
1 2 2
1 3 5
1 4 1
2 3 2
3 4 2
4 5 3
5 1 2
vertex.txt(顶点数据)
1 2
1 3
1 4
2 3
3 4
4 6
5 1

“`
package main.scala.com.spark.demo.com.spark.graphx

import org.apache.hadoop.hdfs.server.common.Storage
import org.apache.spark.graphx.{Edge, Graph}
import org.apache.spark.rdd.RDD
import org.apache.spark.storage.StorageLevel
import org.apache.spark.{SparkContext, SparkConf}

/**
* Created by root on 15-10-18.
*/
object shortestPathFinal {
def main(args: Array[String]) {
val conf = new SparkConf().setAppName(“shortestpath”).setMaster(“local”)
val sc = new SparkContext(conf)
val edgeFile:RDD[String] = sc.textFile(“hdfs://master:9000/data01/edge.txt”)//加载边长数据
val vertexFile:RDD[String] = sc.textFile(“hdfs://master:9000/data01/vertex.txt”)//加载顶点数据

val edge = edgeFile.map { e =>
  val fields = e.split(" ")
  Edge(fields(0).toLong,fields(1).toLong,fields(2).toLong)
}
//vertex
val vertex = vertexFile.map{e=>
  val fields = e.split(" ")
  (fields(0).toLong,fields(1))

}

val graph = Graph(vertex,edge,"").persist()
println(graph.edges.collect.mkString("\n"))
val sourceId = 1

//用pregel计算最短路径
// Initialize the graph such that all vertices except the root have distance infinity.
//初始化各节点到原点的距离
val initialGraph = graph.mapVertices((id, _) => if (id == sourceId) 0.0 else Double.PositiveInfinity)

val sssp = initialGraph.pregel(Double.PositiveInfinity)(
  // Vertex Program，节点处理消息的函数，dist为原节点属性（Double），newDist为消息类型（Double）
  (id, dist, newDist) => math.min(dist, newDist),

  // Send Message，发送消息函数，返回结果为（目标节点id，消息（即最短距离））
  triplet => {
    if (triplet.srcAttr + triplet.attr < triplet.dstAttr) {
      Iterator((triplet.dstId, triplet.srcAttr + triplet.attr))
    } else {
      Iterator.empty
    }
  },
  //Merge Message，对消息进行合并的操作，类似于Hadoop中的combiner
  (a, b) => math.min(a, b)
)

println(sssp.vertices.collect.mkString("\n"))

}
}

“`/edge
//notice:使用edgeListFile 方法会将顶点 属性置1，在这里使用map方法加载边和定点信息
//若顶点信息 有很多属性 如（1，（stu,tom））,可使用元组
val edge = edgeFile.map { e =>
val fields = e.split(” “)
Edge(fields(0).toLong,fields(1).toLong,fields(2).toLong)
}
//vertex
val vertex = vertexFile.map{e=>
val fields = e.split(” “)
(fields(0).toLong,fields(1))

}

val graph = Graph(vertex,edge,"").persist()
println(graph.edges.collect.mkString("\n"))
val sourceId = 1  //计算顶点1到各边最短路径

//用pregel计算最短路径
// Initialize the graph such that all vertices except the root have distance infinity.
//初始化各节点到原点的距离
val initialGraph = graph.mapVertices((id, _) => if (id == sourceId) 0.0 else Double.PositiveInfinity)

val sssp = initialGraph.pregel(Double.PositiveInfinity)(
  // Vertex Program，节点处理消息的函数，dist为原节点属性（Double），newDist为消息类型（Double）
  (id, dist, newDist) => math.min(dist, newDist),

  // Send Message，发送消息函数，返回结果为（目标节点id，消息（即最短距离））
  triplet => {
    if (triplet.srcAttr + triplet.attr < triplet.dstAttr) {
      Iterator((triplet.dstId, triplet.srcAttr + triplet.attr))
    } else {
      Iterator.empty
    }
  },
  //Merge Message，对消息进行合并的操作，类似于Hadoop中的combiner
  (a, b) => math.min(a, b)
)

println(sssp.vertices.collect.mkString("\n"))