动态规划实现最短路径问题

一、设计最短路径的动态规划算法

　　<算法导论>中一般将设计动态规划算法归纳为下面几个步骤：

　　1）分析最优解的结构

　　2）递归定义最优解的值

　　3）自底向上计算最优解的值

　　4）从计算的最优解的值上面构建出最优解

二、最短路径的结构

　　从最优解的结构开始分析(我们假设没有权值为负的路径),对于图G<V,E>的所有结点对最短路径的问题，我们能知道一条最短路径的子路径都是最短路径。假设用邻接矩阵W=w(ij)来表示输入带权图,考虑从结点i到结点j的一条最短路径p，如果p最多有m(m为有限值)条边。若i=j，则p的权值为0而且不包含其他边。若i ≠ j，可以将i到j的路径转换为i -> k、k->j。

三、一个给定的图

　　1）给定一个有向图

　　

　　2）我们可以给出这个有向图的邻接矩阵

　　

四、C++实现

　　

#include <iostream>
#include<fstream>
#include<sstream>
#include<vector>
#include<string>
using namespace std;
const int Max_Num = 100;

typedef struct Point {
    int n; //点的个数 
    double p[Max_Num];
    double q[Max_Num]; 
    int root[Max_Num][Max_Num];
    double w[Max_Num][Max_Num];
    double e[Max_Num][Max_Num];
}Point;

vector<Point> points;
vector<string> res;
vector<int> num;

void file_read();
void createPoint();
void optimalBST();
void printRoot(Point P);
void printOptimalBST(int i, int j, int r, Point P, ofstream &fileWrite);
template <class Type>
Type stringToNum(const string& str) {
    istringstream iss(str);
    Type num;
    iss >> num;
    iss.str("");
    return num;
}

void file_read() {
    string str2, str1 = "", result;
    ifstream fileRead("in.dat");
    if (fileRead.is_open()) {
        while (getline(fileRead, str2, '
')) {
            if (str2.find(" ") != -1) {
                str1.append(str2 + " ");
            }
            else {
                num.push_back(stringToNum<int>(str2));
                if (str1 != "") {
                    res.push_back(str1);
                }
                str1 = "";
            }
        }
        res.push_back(str1);
        fileRead.close();
    }
}

void createPoint() {
    string temp;
    Point P;
    for (int i = 0; i < res.size(); i++) {
        vector<string> temp_str; //存放按照空格分开后的数字 
        int n = num[i];
        stringstream input(res[i]); 
        while (input >> temp) {
            temp_str.push_back(temp);
        }
        P.n = n;
        for(int k = 0; k<=n; k++) P.p[k] = stringToNum<double>(temp_str[k]);
        for(int k = n + 1; k<temp_str.size(); k++) P.q[k-(n+1)] = stringToNum<double>(temp_str[k]);
        points.push_back(P);
    }
}

//根据书上的伪代码：接收概率列表p1....pn和q0.....qn以及规模n作为输入  计算出e和root 
void optimalBST(){
    Point P;
    for(int i = 0; i<res.size(); i++) {
        vector<string> temp_str; //存放按照空格分开后的数字 
        int n = num[i];
        string temp;
        stringstream input(res[i]); 
        while (input >> temp) {
            temp_str.push_back(temp);
        }
        P.n = n;
        
        for(int k = 0; k<=n; k++) P.p[k] = stringToNum<double>(temp_str[k]);
        for(int k = n + 1; k<temp_str.size(); k++) P.q[k-(n+1)] = stringToNum<double>(temp_str[k]);
        
        //初始化只包括虚拟键的子树
        for (int i = 1;i <= P.n + 1;++i){
            P.w[i][i-1] = P.q[i-1];
            P.e[i][i-1] = P.q[i-1];
        }
        //由下到上，由左到右逐步计算
        for (int len = 1;len <= P.n;++len){
            for (int i = 1;i <= P.n - len + 1;++i){
                int j = i + len - 1;
                P.e[i][j] = Max_Num;
                P.w[i][j] = P.w[i][j-1] + P.p[j] + P.q[j];
                //求取最小代价的子树的根
                for (int r = i;r <= j;++r)
                {
                    double temp = P.e[i][r-1] + P.e[r+1][j] + P.w[i][j];
                    if (temp < P.e[i][j])
                    {
                        P.e[i][j] = temp;
                        P.root[i][j] = r;
                    }
                }
            }
        }
        points.push_back(P);
    }
}

void printOptimalBST(int i, int j, int r, Point P, ofstream &fileWrite){
    int root_node = P.root[i][j];//子树根节点
    if (root_node == P.root[1][P.n]){
        //输出整棵树的根
        fileWrite << "k" << root_node << "是根" << endl;
        printOptimalBST(i, root_node - 1, root_node, P, fileWrite);
        printOptimalBST(root_node +1 , j, root_node, P, fileWrite);
        return;
    }
 
    if (j < i - 1){
        return;
    }else if (j == i - 1){//遇到虚拟键
        if (j < r)
            fileWrite << "d" << j << "是" << "k" << r << "的左孩子" << endl;
        else
            fileWrite << "d" << j << "是" << "k" << r << "的右孩子" << endl;
        return;
    }
    else{//遇到内部结点
        if (root_node < r)
            fileWrite << "k" << root_node << "是" << "k" << r << "的左孩子" << endl;
        else
            fileWrite << "k" << root_node << "是" << "k" << r << "的右孩子" << endl;
    }
    printOptimalBST(i, root_node - 1, root_node, P, fileWrite);
    printOptimalBST(root_node + 1, j, root_node, P, fileWrite);
}

//输出最优二叉查找树所有子树的根
void printRoot(Point P){ 
    cout << "各子树的根：" << endl;
    for (int i = 1;i <= P.n;++i){
        for (int j = 1;j <= P.n;++j){
            cout << P.root[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;
}
 
int main(){
    file_read();
    optimalBST();
    ofstream fileWrite("out.dat");
    Point P ;
    for(int i = 0; i<points.size(); i++) {
        P = points[i];
        printRoot(P);
        printOptimalBST(1,P.n,-1, P, fileWrite);
    }
    fileWrite.clear();
    return 0;
}

　　　上述代码是将给定的邻接矩阵从文件中读取

　　　　

　　　　然后根据输入的邻接矩阵求出最短路径