数据结构—拓扑排序详解

1、拓扑排序的介绍

对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序,是将G中所有顶点排成一个线性序列,使得图中任意一对顶点u和v,若边(u,v)∈E(G),则u在线性序列中出现在v之前。
拓扑排序对应施工的流程图具有特别重要的作用,它可以决定哪些子工程必须要先执行,哪些子工程要在某些工程执行后才可以执行。为了形象地反映出整个工程中各个子工程(活动)之间的先后关系,可用一个有向图来表示,图中的顶点代表活动(子工程),图中的有向边代表活动的先后关系,即有向边的起点的活动是终点活动的前序活动,只有当起点活动完成之后,其终点活动才能进行。通常,我们把这种顶点表示活动、边表示活动间先后关系的有向图称做顶点活动网(Activity On Vertex network),简称AOV网。
一个AOV网应该是一个有向无环图,即不应该带有回路,因为若带有回路,则回路上的所有活动都无法进行(对于数据流来说就是死循环)。在AOV网中,若不存在回路,则所有活动可排列成一个线性序列,使得每个活动的所有前驱活动都排在该活动的前面,我们把此序列叫做拓扑序列(Topological order),由AOV网构造拓扑序列的过程叫做拓扑排序(Topological sort)。AOV网的拓扑序列不是唯一的,满足上述定义的任一线性序列都称作它的拓扑序列。
Continue reading

算法导论–最小生成树(Kruskal和Prim算法)

原创 2016年07月14日 16:58:59

转载请注明出处:勿在浮沙筑高台http://blog.csdn.net/luoshixian099/article/details/51908175


关于图的几个概念定义:

  • 连通图:在无向图中,若任意两个顶点vivj都有路径相通,则称该无向图为连通图。
  • 强连通图:在有向图中,若任意两个顶点vivj都有路径相通,则称该有向图为强连通图。
  • 连通网:在连通图中,若图的边具有一定的意义,每一条边都对应着一个数,称为权;权代表着连接连个顶点的代价,称这种连通图叫做连通网。
  • 生成树:一个连通图的生成树是指一个连通子图,它含有图中全部n个顶点,但只有足以构成一棵树的n-1条边。一颗有n个顶点的生成树有且仅有n-1条边,如果生成树中再添加一条边,则必定成环。
  • 最小生成树:在连通网的所有生成树中,所有边的代价和最小的生成树,称为最小生成树。
    这里写图片描述

下面介绍两种求最小生成树算法

1.Kruskal算法

此算法可以称为“加边法”,初始最小生成树边数为0,每迭代一次就选择一条满足条件的最小代价边,加入到最小生成树的边集合里。
1. 把图中的所有边按代价从小到大排序;
2. 把图中的n个顶点看成独立的n棵树组成的森林;
3. 按权值从小到大选择边,所选的边连接的两个顶点ui,vi,应属于两颗不同的树,则成为最小生成树的一条边,并将这两颗树合并作为一颗树。
4. 重复(3),直到所有顶点都在一颗树内或者有n-1条边为止。

这里写图片描述

2.Prim算法

此算法可以称为“加点法”,每次迭代选择代价最小的边对应的点,加入到最小生成树中。算法从某一个顶点s开始,逐渐长大覆盖整个连通网的所有顶点。

  1. 图的所有顶点集合为V;初始令集合u={s},v=Vu;
  2. 在两个集合u,v能够组成的边中,选择一条代价最小的边(u0,v0),加入到最小生成树中,并把v0并入到集合u中。
  3. 重复上述步骤,直到最小生成树有n-1条边或者n个顶点为止。

由于不断向集合u中加点,所以最小代价边必须同步更新;需要建立一个辅助数组closedge,用来维护集合v中每个顶点与集合u中最小代价边信息,:

struct
{
  char vertexData   //表示u中顶点信息
  UINT lowestcost   //最小代价
}closedge[vexCounts]
  • 1
  • 2
  • 3
  • 4
  • 5

这里写图片描述


3.完整代码

/************************************************************************
CSDN 勿在浮沙筑高台 http://blog.csdn.net/luoshixian099算法导论--最小生成树(Prim、Kruskal)2016年7月14日
************************************************************************/
#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
#define INFINITE 0xFFFFFFFF   
#define VertexData unsigned int  //顶点数据
#define UINT  unsigned int
#define vexCounts 6  //顶点数量
char vextex[] = { 'A', 'B', 'C', 'D', 'E', 'F' };
struct node 
{
    VertexData data;
    unsigned int lowestcost;
}closedge[vexCounts]; //Prim算法中的辅助信息
typedef struct 
{
    VertexData u;
    VertexData v;
    unsigned int cost;  //边的代价
}Arc;  //原始图的边信息
void AdjMatrix(unsigned int adjMat[][vexCounts])  //邻接矩阵表示法
{
    for (int i = 0; i < vexCounts; i++)   //初始化邻接矩阵
        for (int j = 0; j < vexCounts; j++)
        {
            adjMat[i][j] = INFINITE;
        }
    adjMat[0][1] = 6; adjMat[0][2] = 1; adjMat[0][3] = 5;
    adjMat[1][0] = 6; adjMat[1][2] = 5; adjMat[1][4] = 3;
    adjMat[2][0] = 1; adjMat[2][1] = 5; adjMat[2][3] = 5; adjMat[2][4] = 6; adjMat[2][5] = 4;
    adjMat[3][0] = 5; adjMat[3][2] = 5; adjMat[3][5] = 2;
    adjMat[4][1] = 3; adjMat[4][2] = 6; adjMat[4][5] = 6;
    adjMat[5][2] = 4; adjMat[5][3] = 2; adjMat[5][4] = 6;
}
int Minmum(struct node * closedge)  //返回最小代价边
{
    unsigned int min = INFINITE;
    int index = -1;
    for (int i = 0; i < vexCounts;i++)
    {
        if (closedge[i].lowestcost < min && closedge[i].lowestcost !=0)
        {
            min = closedge[i].lowestcost;
            index = i;
        }
    }
    return index;
}
void MiniSpanTree_Prim(unsigned int adjMat[][vexCounts], VertexData s)
{
    for (int i = 0; i < vexCounts;i++)
    {
        closedge[i].lowestcost = INFINITE;
    }      
    closedge[s].data = s;      //从顶点s开始
    closedge[s].lowestcost = 0;
    for (int i = 0; i < vexCounts;i++)  //初始化辅助数组
    {
        if (i != s)
        {
            closedge[i].data = s;
            closedge[i].lowestcost = adjMat[s][i];
        }
    }
    for (int e = 1; e <= vexCounts -1; e++)  //n-1条边时退出
    {
        int k = Minmum(closedge);  //选择最小代价边
        cout << vextex[closedge[k].data] << "--" << vextex[k] << endl;//加入到最小生成树
        closedge[k].lowestcost = 0; //代价置为0
        for (int i = 0; i < vexCounts;i++)  //更新v中顶点最小代价边信息
        {
            if ( adjMat[k][i] < closedge[i].lowestcost)
            {
                closedge[i].data = k;
                closedge[i].lowestcost = adjMat[k][i];
            }
        }
    }
}
void ReadArc(unsigned int  adjMat[][vexCounts],vector<Arc> &vertexArc) //保存图的边代价信息
{
    Arc * temp = NULL;
    for (unsigned int i = 0; i < vexCounts;i++)
    {
        for (unsigned int j = 0; j < i; j++)
        {
            if (adjMat[i][j]!=INFINITE)
            {
                temp = new Arc;
                temp->u = i;
                temp->v = j;
                temp->cost = adjMat[i][j];
                vertexArc.push_back(*temp);
            }
        }
    }
}
bool compare(Arc  A, Arc  B)
{
    return A.cost < B.cost ? true : false;
}
bool FindTree(VertexData u, VertexData v,vector<vector<VertexData> > &Tree)
{
    unsigned int index_u = INFINITE;
    unsigned int index_v = INFINITE;
    for (unsigned int i = 0; i < Tree.size();i++)  //检查u,v分别属于哪颗树
    {
        if (find(Tree[i].begin(), Tree[i].end(), u) != Tree[i].end())
            index_u = i;
        if (find(Tree[i].begin(), Tree[i].end(), v) != Tree[i].end())
            index_v = i;
    }

    if (index_u != index_v)   //u,v不在一颗树上,合并两颗树
    {
        for (unsigned int i = 0; i < Tree[index_v].size();i++)
        {
            Tree[index_u].push_back(Tree[index_v][i]);
        }
        Tree[index_v].clear();
        return true;
    }
    return false;
}
void MiniSpanTree_Kruskal(unsigned int adjMat[][vexCounts])
{
    vector<Arc> vertexArc;
    ReadArc(adjMat, vertexArc);//读取边信息
    sort(vertexArc.begin(), vertexArc.end(), compare);//边按从小到大排序
    vector<vector<VertexData> > Tree(vexCounts); //6棵独立树
    for (unsigned int i = 0; i < vexCounts; i++)
    {
        Tree[i].push_back(i);  //初始化6棵独立树的信息
    }
    for (unsigned int i = 0; i < vertexArc.size(); i++)//依次从小到大取最小代价边
    {
        VertexData u = vertexArc[i].u;  
        VertexData v = vertexArc[i].v;
        if (FindTree(u, v, Tree))//检查此边的两个顶点是否在一颗树内
        {
            cout << vextex[u] << "---" << vextex[v] << endl;//把此边加入到最小生成树中
        }   
    }
}

int main()
{
    unsigned int  adjMat[vexCounts][vexCounts] = { 0 };
    AdjMatrix(adjMat);   //邻接矩阵
    cout << "Prim :" << endl;
    MiniSpanTree_Prim(adjMat,0); //Prim算法,从顶点0开始.
    cout << "-------------" << endl << "Kruskal:" << endl;
    MiniSpanTree_Kruskal(adjMat);//Kruskal算法
    return 0;
}

 

这里写图片描述


Reference:
数据结构–耿国华
算法导论–第三版

极大似然估计

编辑

极大似然估计方法(Maximum Likelihood Estimate,MLE)也称为最大概似估计或最大似然估计,是求估计的另一种方法,最大概似是1821年首先由德国数学家高斯(C. F. Gauss)提出,但是这个方法通常被归功于英国的统计学家。罗纳德·费希尔(R. A. Fisher)

Continue reading

词汇关系 相似性词推荐,推荐性,常用表述推荐
句子关系 细节题(定位), 推断题(因果调节推断原理),
篇章关系

 

实体:词汇-词汇

关系:近义词,(词汇题推荐) 高频出现词(PMI),写作高分协作词汇(PMI),命名实体(高频协作内容)

权重:近义词相似度,共现频率,高分推荐权重
Continue reading

LDA

(LDA文档主题生成模型)

锁定

LDA(Latent Dirichlet Allocation)是一种文档主题生成模型,也称为一个三层贝叶斯概率模型,包含词、主题和文档三层结构。所谓生成模型,就是说,我们认为一篇文章的每个词都是通过“以一定概率选择了某个主题,并从这个主题中以一定概率选择某个词语”这样一个过程得到。文档到主题服从多项式分布,主题到词服从多项式分布。[1]
LDA是一种非监督机器学习技术,可以用来识别大规模文档集(document collection)或语料库(corpus)中潜藏的主题信息。它采用了词袋(bag of words)的方法,这种方法将每一篇文档视为一个词频向量,从而将文本信息转化为了易于建模的数字信息。但是词袋方法没有考虑词与词之间的顺序,这简化了问题的复杂性,同时也为模型的改进提供了契机。每一篇文档代表了一些主题所构成的一个概率分布,而每一个主题又代表了很多单词所构成的一个概率分布。

Continue reading

深度学习笔记:主成分分析(PCA)(1)——标准化、协方差、相关系数和协方差矩阵

笔者在学习主成分分析(PCA)的时候接触到了协方差矩阵的应用。这部分知识有些遗忘了,因此重新巩固一下,记录在此,希望能帮助到有需要的同学。

1. 概率论中的标准化、协方差、相关系数和协方差矩阵概念

1.1 随机变量的部分数字特征

假设有二维随机向量(X,Y)

数字特征 意义 描述
E(X) 数学期望 反映X的平均值
D(X) 方差 反映X与平均值偏离的程度
Cov(X,Y) 协方差 等于E((XE(X))(YE(Y))),若为0,则说明XY独立
ρρXY 相关系数(就是随机变量标准化后的协方差) 等于Cov(X,Y)D(X)D(Y)

Continue reading

贝叶斯定理是关于随机事件A和B的条件概率(或边缘概率)的一则定理。其中P(A|B)是在B发生的情况下A发生的可能性。

 

贝叶斯公式与两个概率有关系,一个是先验概率(基础概率),一个是现象概率(观察到的条件)

仍然是熊猫给出的例子:某城市发生了一起汽车撞人逃跑事件,该城市只有两种颜色的车,蓝色15%,绿色85%,事发时有一个人在现场看见了,他指证是蓝车。但是根据专家在现场分析,当时那种条件能看正确的可能性是80%。那么,肇事的车是蓝车的概率到底是多少?

令B是城市里车为蓝色的事件,G为车子是绿色的事件,E为观察到车子为蓝色的事件。则由已知条件可以得出P(B)=0.15,P(G)=P(~B)=0.85,至于P(E)我们一会儿再说。

好了,现在,如果没有证人看到肇事者车的话,那么我们只能盲猜,因此肇事者的车子为蓝色的概率只能是整个城市里面车为蓝色的概率,也就是先验概率P(B)=0.15,因为这时我们还没有其他证据介入,只能做个粗略的估算。

接下来,当当当当,有证人了。证人说他看到了车子,并且说是蓝色的,注意,这分两种情况,…………重要的事情说两遍:贝叶斯里面现象(新的证据)部分总是分两种情况出现的:一是车子的确是蓝色的,并且证人也正确的分辨出车是蓝色的来了,概率为 P(E,B)=P(B)xP(E|B)=0.15×0.8=0.12,二是车子根本就是绿色的,只是证人看成蓝色的了,概率为P(E,~B)=P(~B)xP(E|~B)=P(~B)x(1 – P(~E|~B))=0.85x(1-0.8)=0.17(此处原本计算有误,感谢

提醒),所以P(E)=P(E,B)+P(E,~B)=0.12+0.17=0.29然后,我们要求解的其实是在有证人的条件下车子为蓝色的概率,也就是P(B|E)=P(E,B)/P(E)=0.12/0.29=0.41

你看,P(B|E)根本就是P(B)的加强版本,条件概率跟先验概率描述的根本就是同一件事。那么当当当当,又一个结论来了:当有新的证据出现时,P(B|E)会替代原来P(B)的角色。换句话说,现在警察找到了一个新的证人,他也觉得这辆肇事车是蓝色的,这时在新一轮的贝叶斯概率计算中,基础概率P(B)=0.41,而不是原先的0.15,大家可以算一下,新的P(B|E)=0.73,换句话说,当有两个人看见肇事车辆为蓝色的时候,对比只有一个人看到肇事车辆为蓝色的时候,该车实际为蓝色的概率大大增加

关于贝叶斯,写过一篇文章专门详述了相关的内容,可以参考链接:

在概率论与数理统计中,有两个相当重要的公式——全概率公式与贝叶斯公式。然而很多人对这两个公式感到非常迷茫。一来不知道公式背后的意义所在,二来不知道这些冰冷的公式能有什么现实应用。

Continue reading

古典概型也叫传统概率、其定义是由法国数学家拉普拉斯 (Laplace ) 提出的。如果一个随机试验所包含的单位事件是有限的,且每个单位事件发生的可能性均相等,则这个随机试验叫做拉普拉斯试验,这种条件下的概率模型就叫古典概型。
在这个模型下,随机实验所有可能的结果是有限的,并且每个基本结果发生的概率是相同的。古典概型是概率论中最直观和最简单的模型,概率的许多运算规则,也首先是在这种模型下得到的。
中文名
古典概型
外文名
classical models of probability
应用学科
数学
适用领域范围
数学 统计学
又    名
等可能概型
样本空间
有限个元素

Continue reading