MapReduce -- 最短路径

示例：

给出各个节点到相邻节点的距离，要求算出初始节点到各个节点的最短路径。

数据：

A    (B,10)    (D,5)
B    (C,1)    (D,2)
C    (E,4)
D    (B,3)    (C,9)    (E,2)
E    (A,7)    (C,6)

A节点为初始节点，A到B的距离为10，A到D的距离为5。

B节点到C的距离为1，B到D的距离为2，其他类推。

MapReduce计算最短路径

Map阶段

如：

A　　(B,10)　　(D,5)     

　　=> 

A　　0　　(B,10)　　(D,5)    #A到A的最短距离为0

B　　10                              #存在A到B的距离为10

D　　5                                #存在A到D的距离为5

从初始节点开始，将节点到其他相连节点的距离列举出来，然后传递给reduce，找到距离最短的。

记住从初始节点开始，从A开始，找到B和D，然后再找B和D的相邻节点，依次类推，这个就是广度优先搜索。

从A节点出发，A节点没有到达的节点默认的距离为inf表示无穷大。

Reduce阶段

找到所有存在的距离中最短的，并更新记录中的最短距离。

如：针对key值为B的

B　　inf　　(C,1)　　(D,2)       #inf为最远距离，

B　　10　　                            

=>

B　　10　　(C,1)　　(D,2)　　#A到B的最短距离为10

MapReduce过程中数据的变化：

原始数据：
A    (B,10)    (D,5)
B    (C,1)    (D,2)
C    (E,4)
D    (B,3)    (C,9)    (E,2)
E    (A,7)    (C,6)

第一次mr结果：
A    0    (B,10)    (D,5)                #从初始节点A出发，找到A到B节点和D节点的距离
B    10    (C,1)    (D,2)　　　　　　　　　 #找到B节点，且更新值，A到B节点目前的最短距离
C    inf    (E,4)
D    5    (B,3)    (C,9)    (E,2)        #找到D节点，且更新值，A到D节点目前的最短距离
E    inf    (A,7)    (C,6)

第二次mr结果
A    0    (B,10)    (D,5)
B    8    (C,1)    (D,2)
C    11    (E,4)
D    5    (B,3)    (C,9)    (E,2)
E    7    (A,7)    (C,6)

第三次mr结果
A    0    (B,10)    (D,5)
B    8    (C,1)    (D,2)
C    9    (E,4)
D    5    (B,3)    (C,9)    (E,2)
E    7    (A,7)    (C,6)


第四次mr结果
A    0    (B,10)    (D,5)
B    8    (C,1)    (D,2)
C    9    (E,4)
D    5    (B,3)    (C,9)    (E,2)
E    7    (A,7)    (C,6)

接下来还要考虑，什么时候所有节点的最短距离都计算完成？

我的计算方式，假设如果所有节点没有距离进行更新，说明所有节点的最短距离都已经计算完成，则完成计算。

源代码：

RunJob.java

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.KeyValueTextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.StringUtils;


/**
 * Created by Edward on 2016/7/15.
 */
public class RunJob {

    static enum eInf {
        COUNTER
    }

    public static void main(String[] args) {
        Configuration conf = new Configuration();

        conf.set("fs.defaultFS", "hdfs://node1:8020");

        try {
            FileSystem fs = FileSystem.get(conf);
            int i = 0;
            long num = 1;
            long tmp = 0;
            while (num > 0) {
                i++;
                conf.setInt("run.counter", i);
                Job job = Job.getInstance(conf);
                job.setJarByClass(RunJob.class);
                job.setMapperClass(ShortestPathMapper.class);
                job.setReducerClass(ShortestPathReducer.class);
                job.setMapOutputKeyClass(Text.class);
                job.setMapOutputValueClass(Text.class);

                //key value 的格式   第一个item为key，后面的item为value
                job.setInputFormatClass(KeyValueTextInputFormat.class);

                if (i == 1)
                    FileInputFormat.addInputPath(job, new Path("/test/shortestpath/input/"));
                else
                    FileInputFormat.addInputPath(job, new Path("/test/shortestpath/output/sp" + (i - 1)));

                Path outPath = new Path("/test/shortestpath/output/sp" + i);
                if (fs.exists(outPath)) {
                    fs.delete(outPath, true);
                }
                FileOutputFormat.setOutputPath(job, outPath);

                boolean b = job.waitForCompletion(true);

                if (b) {
                    num = job.getCounters().findCounter(eInf.COUNTER).getValue();
                    if (num == 0) {
                        System.out.println("执行了" + i + "次，完成最短路径的计算");
                    }
                }
            }

        } catch (Exception e) {

            e.printStackTrace();
        }

    }

    /**
     * @author Edward
     *
     *         @1 A (B,10) (D,5) =>
     *            A 0 (B,10) (D,5)
     *            B 10
     *            D 5
     *         @2 B 10 (C,1) (D,2) =>
     *         B 10 (C,1) (D,2)
     *         C 11
     *         D 13
     */
    public static class ShortestPathMapper extends Mapper<Text, Text, Text, Text> {

        protected void map(Text key, Text value, Context context) throws IOException, InterruptedException {
            int conuter = context.getConfiguration().getInt("run.counter", 1);

            Node node = new Node();
            String distance = null;
            String str = null;

            // 第一次计算，填写默认距离 A:0 其他:inf
            if (conuter == 1) {
                if (key.toString().equals("A") || key.toString().equals("1")) {
                    distance = "0";
                } else {
                    distance = "inf";
                }
                str = distance + "	" + value.toString();
            } else {
                str = value.toString();
            }

            context.write(key, new Text(str));

            node.FormatNode(str);

            // 没走到此节点 退出
            if (node.getDistance().equals("inf"))
                return;

            // 重新计算源点A到各点的距离
            for (int i = 0; i < node.getNodeNum(); i++) {
                String k = node.getNodeKey(i);
                String v = new String(
                        Integer.parseInt(node.getNodeValue(i)) + Integer.parseInt(node.getDistance()) + "");
                context.write(new Text(k), new Text(v));
            }
        }
    }

    /**
     * @author Edward
     *
     *         B 10 (C,1) (D,2)
     *         B 8              =>
     *         B 8 (C,1) (D,2)
     *
     */
    public static class ShortestPathReducer extends Reducer<Text, Text, Text, Text> {

        protected void reduce(Text arg0, Iterable<Text> arg1, Context arg2) throws IOException, InterruptedException {
            String min = null;
            int i = 0;
            String dis = "inf";
            Node node = new Node();
            for (Text t : arg1) {
                i++;
                dis = StringUtils.split(t.toString(), '	')[0];

                // 如果存在inf节点，表示存在没有计算距离的节点。
                // if(dis.equals("inf"))
                // arg2.getCounter(eInf.COUNTER).increment(1L);

                // 判断是否存在相邻节点，如果是则需要保留信息，并找到最小距离进行更新。
                String[] strs = StringUtils.split(t.toString(), '	');
                if (strs.length > 1) {
                    node.FormatNode(t.toString());
                }

                // 第一条数据默认是最小距离
                if (i == 1) {
                    min = dis;
                } else {
                    if (dis.equals("inf"))
                        ;
                    else if (min.equals("inf"))
                        min = dis;
                    else if (Integer.parseInt(min) > Integer.parseInt(dis)) {
                        min = dis;
                    }
                }
            }

            // 有新的最小值，说明还在进行优化计算，需要继续循环计算
            if (!min.equals("inf")) {
                if (node.getDistance().equals("inf"))
                    arg2.getCounter(eInf.COUNTER).increment(1L);
                else {
                    if (Integer.parseInt(node.getDistance()) > Integer.parseInt(min))
                        arg2.getCounter(eInf.COUNTER).increment(1L);
                }
            }

            node.setDistance(min);

            arg2.write(arg0, new Text(node.toString()));
        }
    }
}

Node.java

import org.apache.hadoop.util.StringUtils;


/**
 * Created by Edward on 2016/7/15.
 */
public class Node {
    private String distance;
    private String[] adjs;


    public String getDistance() {
        return distance;
    }


    public void setDistance(String distance) {
        this.distance = distance;
    }

    public String getKey(String str)
    {
        return str.substring(1, str.indexOf(","));
    }

    public String getValue(String str)
    {
        return str.substring(str.indexOf(",")+1, str.indexOf(")"));
    }

    public String getNodeKey(int num)
    {
        return getKey(adjs[num]);
    }

    public String getNodeValue(int num)
    {
        return getValue(adjs[num]);
    }

    public int getNodeNum()
    {
        return adjs.length;
    }

    public void FormatNode(String str)
    {
        if(str.length() == 0)
            return ;

        String[] strs =  StringUtils.split(str, '	');

        adjs = new String[strs.length-1];
        for(int i=0; i<strs.length; i++)
        {
            if(i == 0)
            {
                setDistance(strs[i]);
                continue;
            }
            this.adjs[i-1]=strs[i];
        }
    }

    public String toString()
    {
        String str = this.distance+"" ;

        if(this.adjs == null)
            return str;

        for(String s:this.adjs)
        {
            str = str+"	"+s;
        }
        return str;
    }

    public static void main(String[] args)
    {
        Node node  = new Node();
        node.FormatNode("1    (A,20)    (B,30)");
        System.out.println(node.distance+"|"+node.getNodeNum()+"|"+node.toString());
    }
}