tripassignment.cs

交通分配算法

using System;
using System.Collections.Generic;
using System.Text;

//交通分配算法
//[e-mail],QQ:445194766
    class TripAssignment
    {
        //******************************************************************************************************
        //求两个点之间的最短距离
        public static void TwoNodesShortestPath
            (
            int startNode,            //IN,起始节点
            int endNode,              //IN,终止节点
            double[,] weight,         //IN,各节点之间的路权
            out double shortestLength,//OUT,两节点之间的最短路长
            out string shortestPath   //OUT,两节点之间的最短路径
            )
        {
            int dimensions=weight .GetLength (0);
            double [] L=new double [dimensions ];
            int [] p=new int [dimensions ];
            Dijkstra (startNode ,weight ,L,p);
            shortestLength =L[endNode ];
            shortestPath =(endNode+1) .ToString ();
            int flag = endNode;
            while (p[flag] != -1)
            {
                shortestPath  = (p[flag] + 1)+"->" + shortestPath ;
                flag = p[flag];
            }
        }
        //******************************************************************************************************


        //*****************************************************************************************************
        //求一个点到其余所有节点的最短路的Dijkstra算法
        public static void Dijkstra
            (
            int startNode,        //IN,需要求到其余所有节点的最短路的节点编号
            double[,] weight,     //IN,各节点之间的路权
            double[] L,           //OUT,startNode节点到其余所有节点之间的最短路长
            int[] p               //OUT,startNode节点到其余所有节点之间的最短路径
            )
        {
            int dimensions=weight .GetLength (0);
            List<int> S = new List<int>(dimensions);
            int currentNode;
            S.Add(startNode);
            currentNode = startNode;
            L[startNode] = 0;
            p[startNode] = -1;
            for (int i = 0; i < dimensions; i++)
            {
                if (i != startNode)
                {
                    L[i] = double.MaxValue;
                    p[i] = -1;
                }
            }
            for (int r = 0; r < dimensions; r++)
            {
                for (int j = 0; j < dimensions; j++)
                {
                    if (!S.Contains(j)&&weight [currentNode ,j]<double.MaxValue )
                    {
                        if (L[j] > L[currentNode] + weight[currentNode, j])
                        {
                            L[j] = L[currentNode] + weight[currentNode, j];
                            p[j] = currentNode;
                        }
                    }
                }
                double min = 0;
                for (int i = 0; i < dimensions; i++)
                {
                    if (!S.Contains(i))
                    {
                        min = L[i];
                        break;
                    }
                }
                for (int i = 0; i < dimensions; i++)
                {
                    if (!S.Contains(i))
                    {
                        if (L[i] <= min)
                        {
                            currentNode = i;
                        }
                    }
                }
                S.Add(currentNode);
            }
        }
        //****************************************************************************************************
        
        //*********************************************************************************************************
        //求最短路的Floyd算法
        public static void Floyd
            (
            double[,] weight, //IN,各节点之间的路权
            double[,] d,      //OUT,各节点之间的最短路长
            int[,] p          //OUT,各节点之间的最短路径
            )
        {
            int rows = weight.GetLength(0);
            int columns = weight.GetLength(1);
            if (rows != columns)
            {
                throw new Exception("维数错误，必须为n阶方阵！");
            }
            else
            {
                int dimensions = rows;
                double[,] tempD = new double[dimensions, dimensions];
                int[,] tempP = new int[dimensions, dimensions];
                //step0
                int k = 0;
                for (int i = 0; i < dimensions; i++)
                {
                    for (int j = 0; j < dimensions; j++)
                    {
                        p[i, j] = i;
                        d[i, j] = weight[i, j];
                    }
                }

                //step1
                for (k = 0; k < dimensions; k++)
                {
                    for (int i = 0; i < dimensions; i++)
                    {
                        for (int j = 0; j < dimensions; j++)
                        {
                            tempD[i, j] = d[i, j];
                            tempP[i, j] = p[i, j];
                        }
                    }

                    for (int i = 0; i < dimensions; i++)
                    {
                        for (int j = 0; j < dimensions; j++)
                        {
                            if (tempD[i, j] <= (tempD[i, k] + tempD[k, j]))
                            {
                                d[i, j] = tempD[i, j];
                                p[i, j] = tempP[i, j];
                            }
                            else
                            {
                                d[i, j] = tempD[i, k] + tempD[k, j];
                                p[i, j] = tempP[k, j];
                            }
                        }
                    }
                }
            }

        }
        //***********************************************************************************************

        //**********************************************************************************************
        //最短路径交通分配
        public static void AllOrNotAssignmentMethod
            (
            double[,] OD,       //IN,需要分配的各节点之间的OD量
            double[,] weight,   //IN,各节点之间的路权
            double[,] result    //OUT,各节点之间流量按最短路径分配结果
            )
        {
            int dimensions = OD.GetLength(0);
            double[,] tempD = new double[dimensions, dimensions];
            int[,] tempP = new int[dimensions, dimensions];
            Floyd(weight, tempD, tempP);
            for (int i = 0; i < dimensions; i++)
            {
                for (int j = 0; j < dimensions; j++)
                {
                    double ODFlow = OD[i, j];
                    if (ODFlow > 0)
                    {
                        if (tempP[i, j] == i)
                        {
                            result[i, j] += ODFlow;
                        }
                        else
                        {
                            int flag = j;
                            int temp;
                            while (tempP[i, flag] != i)
                            {
                                temp = flag;
                                flag = tempP[i, flag];
                                result[flag, temp] += ODFlow;
                            }
                            result[i, flag] += ODFlow;
                        }