SharpICTCLAS分词系统简介(4)NShortPath-1
2010-02-06 08:48
363 查看
N-最短路径中文词语粗分是分词过程中非常重要的一步,而原有ICTCLAS中该部分代码也是我认为最难读懂的部分,到现在还有一些方法没有弄明白,因此我几乎重写了NShortPath类。要想说明N-最短路径代码是如何工作的并不容易,所以分成两步分,本部分先说说SharpICTCLAS中1-最短路径是如何实现的,在下一篇文章中再引申到N-最短路径。
1、数据表示 这里我们求最短路的例子使用如下的有向图,每条边的权重已经在图中标注出来了。
![](images/0308002.gif)
(图一)
根据上篇文章内容,该图该可以等价于如下的二维表格表示:
![](images/0308003.gif)
(图二)
而对应于该表格的是一个ColumnFirstDynamicArray,共有10个结点,每个结点的取值如下表所示:
![](images/copycode.gif)
Copy Code
该示例对应的ColumnFirstDynamicArray
row:0, col:1, eWeight:1, nPOS:0, sWord: 始@A
row:1, col:2, eWeight:1, nPOS:0, sWord: A@B
row:1, col:3, eWeight:2, nPOS:0, sWord: A@C
row:2, col:3, eWeight:1, nPOS:0, sWord: B@C
row:2, col:4, eWeight:1, nPOS:0, sWord: B@D
row:3, col:4, eWeight:1, nPOS:0, sWord: C@D
row:4, col:5, eWeight:1, nPOS:0, sWord: D@E
row:3, col:6, eWeight:2, nPOS:0, sWord: C@末
row:4, col:6, eWeight:3, nPOS:0, sWord: D@末
row:5, col:6, eWeight:1, nPOS:0, sWord: E@末
2、计算出每个结点上可达最短路的PreNode 在求解N-最短路径之前,先看看如何求最短PreNode。如下图所示:
![](images/0308004.gif)
(图三)
首先计算出到达每个结点的最短路径,并将该结点的父结点压入该结点所对应的队列。例如3号“C”结点,到达该结点的最短路径长度为3,它的Parent结点可以是1号“A”结点,也可以是2号“B”结点,因此在队列中存储了两个PreNode结点。
而在实际计算时,如何知道到达3号“C”结点的路径有几条呢?其实我们首先计算所有到达3号“C”结点的路径长度,并按照路径长度从小到大的顺序排列(所有这些都是靠CQueue这个类完成的),然后从队列中依次向后取值,取出所有最短路径对应的PreNode。
计算到当前结点(nCurNode)可能的边,并根据总路径长度由小到大压入队列的代码如下(经过简化):
![](images/copycode.gif)
Copy Code
EnQueueCurNodeEdges方法
//====================================================================
// 将所有到当前结点(nCurNode)可能的边根据eWeight排序并压入队列
//====================================================================
private void EnQueueCurNodeEdges(ref CQueue queWork, int nCurNode)
{
int nPreNode;
double eWeight;
ChainItem pEdgeList;
queWork.Clear();
pEdgeList = m_apCost.GetFirstElementOfCol(nCurNode);
// 获取所有到当前结点的边
while (pEdgeList != null && pEdgeList.col == nCurNode)
{
nPreNode = pEdgeList.row; // 很特别的命令,利用了row与col的关系
eWeight = pEdgeList.Content.eWeight;
// 第一个结点,没有PreNode,直接加入队列
if (nPreNode == 0)
{
queWork.EnQueue(new QueueElement(nPreNode, eWeight));
break;
}
queWork.EnQueue(new QueueElement(nPreNode, eWeight + m_pWeight[nPreNode - 1]));
pEdgeList = pEdgeList.next;
}
}
这段代码中有一行很特别的命令,就是用红颜色注释的那句“nPreNode = pEdgeList.row;”,让我琢磨了半天终于弄明白原有ICTCLAS用意的一句话。这需要参考本文图二,为了方便起见,我将它挪到了这里:
![](images/0308003.gif)
注意 3 号“C”结点在该表中处于第 3 列,所有可以到达该结点的边就是该列中的元素(目前有两个元素“A@C”与“B@C”)。而与 3 号“C”结点构成这两条边的PreNode结点恰恰是这两个元素的“行号”,分别是 1 号“A”结点与 2 号“B”结点。正是因为这种特殊的对应关系,为我们检索所有可达边提供了便捷的方法。阅读上面那段代码务必把握好这种关系。
3、求解最短路径 求出每个结点上最短路径的PreNode后就需要据此推导出完整的最短路径。原ICTCLAS代码中是靠GetPaths方法实现的,只是到现在我也没有读懂这个方法的代码究竟想干什么 ,只知道它用了若干个while,若干个if,若干个嵌套...(将ICTCLAS中的GetPaths放上来,如果谁读懂了,回头给我讲讲 ,感觉应该和我的算法差不多)。
![](images/copycode.gif)
Copy Code
NShortPath.cpp程序中的GetPaths方法
void CNShortPath::GetPaths(unsigned int nNode, unsigned int nIndex, int
**nResult, bool bBest)
{
CQueue queResult;
unsigned int nCurNode, nCurIndex, nParentNode, nParentIndex, nResultIndex = 0;
if (m_nResultCount >= MAX_SEGMENT_NUM)
//Only need 10 result
return ;
nResult[m_nResultCount][nResultIndex] = - 1; //Init the result
queResult.Push(nNode, nIndex);
nCurNode = nNode;
nCurIndex = nIndex;
bool bFirstGet;
while (!queResult.IsEmpty())
{
while (nCurNode > 0)
//
{
//Get its parent and store them in nParentNode,nParentIndex
if (m_pParent[nCurNode - 1][nCurIndex].Pop(&nParentNode, &nParentIndex, 0,
false, true) != - 1)
{
nCurNode = nParentNode;
nCurIndex = nParentIndex;
}
if (nCurNode > 0)
queResult.Push(nCurNode, nCurIndex);
}
if (nCurNode == 0)
{
//Get a path and output
nResult[m_nResultCount][nResultIndex++] = nCurNode; //Get the first node
bFirstGet = true;
nParentNode = nCurNode;
while (queResult.Pop(&nCurNode, &nCurIndex, 0, false, bFirstGet) != - 1)
{
nResult[m_nResultCount][nResultIndex++] = nCurNode;
bFirstGet = false;
nParentNode = nCurNode;
}
nResult[m_nResultCount][nResultIndex] = - 1; //Set the end
m_nResultCount += 1; //The number of result add by 1
if (m_nResultCount >= MAX_SEGMENT_NUM)
//Only need 10 result
return ;
nResultIndex = 0;
nResult[m_nResultCount][nResultIndex] = - 1; //Init the result
if (bBest)
//Return the best result, ignore others
return ;
}
queResult.Pop(&nCurNode, &nCurIndex, 0, false, true); //Read the top node
while (queResult.IsEmpty() == false && (m_pParent[nCurNode -
1][nCurIndex].IsSingle() || m_pParent[nCurNode - 1][nCurIndex].IsEmpty
(true)))
{
queResult.Pop(&nCurNode, &nCurIndex, 0); //Get rid of it
queResult.Pop(&nCurNode, &nCurIndex, 0, false, true); //Read the top node
}
if (queResult.IsEmpty() == false && m_pParent[nCurNode -
1][nCurIndex].IsEmpty(true) == false)
{
m_pParent[nCurNode - 1][nCurIndex].Pop(&nParentNode, &nParentIndex, 0,
false, false);
nCurNode = nParentNode;
nCurIndex = nParentIndex;
if (nCurNode > 0)
queResult.Push(nCurNode, nCurIndex);
}
}
}
我重写了求解最短路径的方法,其算法表述如下:
![](images/0308005.gif)
(图四)
1)首先将最后一个元素压入堆栈(本例中是6号结点),什么时候这个元素弹出堆栈,什么时候整个任务结束。
2)对于每个结点的PreNode队列,维护了一个当前指针,初始状态都指向PreNode队列中第一个元素。
3)从右向左依次取出PreNode队列中的当前元素并压入堆栈,并将队列指针重新指向队列中第一个元素。如图四:6号元素PreNode是3,3号元素PreNode是1,1号元素PreNode是0。
4)当第一个元素压入堆栈后,输出堆栈内容即为一条队列。本例中0, 1, 3, 6便是一条最短路径。
5)将堆栈中的内容依次弹出,每弹出一个元素,就将当时压栈时对应的PreNode队列指针下移一格。如果到了末尾无法下移,则继续执行第5步,如果仍然可以移动,则执行第3步。
对于本例,先将“0”弹出堆栈,该元素对应的是1号“A”结点的PreNode队列,该队列的当前指针已经无法下移,因此继续弹出堆栈中的“1” ;该元素对应3号“C”结点,因此将3号“C”结点对应的PreNode队列指针下移。由于可以移动,因此将队列中的2压入队列,2号“B”结点的PreNode是1,因此再压入1,依次类推,直到0被压入,此时又得到了一条最短路径,那就是0,1,2,3,6。如下图:
![](images/0308006.gif)
(图五)
再往下,0、1、2都被弹出堆栈,3被弹出堆栈后,由于它对应的6号元素PreNode队列记录指针仍然可以下移,因此将5压入堆栈并依次将其PreNode入栈,直到0被入栈。此时输出第3条最短路径:0, 1, 2, 4, 5, 6。入下图:
![](images/0308007.gif)
(图六)
输出完成后,紧接着又是出栈,此时已经没有任何堆栈元素对应的PreNode队列指针可以下移,于是堆栈中的最后一个元素6也被弹出堆栈,此时输出工作完全结束。我们得到了3条最短路径,分别是:
0, 1, 3, 6,
0, 1, 2, 3, 6,
0, 1, 2, 4, 5, 6,
让我们看看在SharpICTCLAS中,该算法是如何实现的:
![](images/copycode.gif)
Copy Code
SharpICTCLAS中的GetPaths方法
//====================================================================
// 注:index = 0 : 最短的路径; index = 1 : 次短的路径
// 依此类推。index <= this.m_nValueKind
//====================================================================
public List GetPaths(int index)
{
Stack stack = new Stack();
int curNode = m_nNode - 1, curIndex = index;
QueueElement element;
PathNode node;
int[] aPath;
List result = new List();
element = m_pParent[curNode - 1][curIndex].GetFirst();
while (element != null)
{
// ---------- 通过压栈得到路径 -----------
stack.Push(new PathNode(curNode, curIndex));
stack.Push(new PathNode(element.nParent, element.nIndex));
curNode = element.nParent;
while (curNode != 0)
{
element = m_pParent[element.nParent - 1][element.nIndex].GetFirst();
stack.Push(new PathNode(element.nParent, element.nIndex));
curNode = element.nParent;
}
// -------------- 输出路径 --------------
PathNode[] nArray = stack.ToArray();
aPath = new int[nArray.Length];
for(int i=0; i 小结
1)N-最短路径的求解比较复杂,本文先从求解1-最短路径着手,说明SharpICTCLAS是如何计算的,在下篇文章中将推广到N-最短路径。
2)1-最短路径并不意味着只有一条最短路径,而是路径最短的若干条路径。就如本文案例所示,1-最短路径算法最终求得了3条路径,它们的长度都是5,因此都是最短路径。
1、数据表示 这里我们求最短路的例子使用如下的有向图,每条边的权重已经在图中标注出来了。
![](images/0308002.gif)
(图一)
根据上篇文章内容,该图该可以等价于如下的二维表格表示:
![](images/0308003.gif)
(图二)
而对应于该表格的是一个ColumnFirstDynamicArray,共有10个结点,每个结点的取值如下表所示:
![](images/copycode.gif)
Copy Code
该示例对应的ColumnFirstDynamicArray
row:0, col:1, eWeight:1, nPOS:0, sWord: 始@A
row:1, col:2, eWeight:1, nPOS:0, sWord: A@B
row:1, col:3, eWeight:2, nPOS:0, sWord: A@C
row:2, col:3, eWeight:1, nPOS:0, sWord: B@C
row:2, col:4, eWeight:1, nPOS:0, sWord: B@D
row:3, col:4, eWeight:1, nPOS:0, sWord: C@D
row:4, col:5, eWeight:1, nPOS:0, sWord: D@E
row:3, col:6, eWeight:2, nPOS:0, sWord: C@末
row:4, col:6, eWeight:3, nPOS:0, sWord: D@末
row:5, col:6, eWeight:1, nPOS:0, sWord: E@末
2、计算出每个结点上可达最短路的PreNode 在求解N-最短路径之前,先看看如何求最短PreNode。如下图所示:
![](images/0308004.gif)
(图三)
首先计算出到达每个结点的最短路径,并将该结点的父结点压入该结点所对应的队列。例如3号“C”结点,到达该结点的最短路径长度为3,它的Parent结点可以是1号“A”结点,也可以是2号“B”结点,因此在队列中存储了两个PreNode结点。
而在实际计算时,如何知道到达3号“C”结点的路径有几条呢?其实我们首先计算所有到达3号“C”结点的路径长度,并按照路径长度从小到大的顺序排列(所有这些都是靠CQueue这个类完成的),然后从队列中依次向后取值,取出所有最短路径对应的PreNode。
计算到当前结点(nCurNode)可能的边,并根据总路径长度由小到大压入队列的代码如下(经过简化):
![](images/copycode.gif)
Copy Code
EnQueueCurNodeEdges方法
//====================================================================
// 将所有到当前结点(nCurNode)可能的边根据eWeight排序并压入队列
//====================================================================
private void EnQueueCurNodeEdges(ref CQueue queWork, int nCurNode)
{
int nPreNode;
double eWeight;
ChainItem pEdgeList;
queWork.Clear();
pEdgeList = m_apCost.GetFirstElementOfCol(nCurNode);
// 获取所有到当前结点的边
while (pEdgeList != null && pEdgeList.col == nCurNode)
{
nPreNode = pEdgeList.row; // 很特别的命令,利用了row与col的关系
eWeight = pEdgeList.Content.eWeight;
// 第一个结点,没有PreNode,直接加入队列
if (nPreNode == 0)
{
queWork.EnQueue(new QueueElement(nPreNode, eWeight));
break;
}
queWork.EnQueue(new QueueElement(nPreNode, eWeight + m_pWeight[nPreNode - 1]));
pEdgeList = pEdgeList.next;
}
}
这段代码中有一行很特别的命令,就是用红颜色注释的那句“nPreNode = pEdgeList.row;”,让我琢磨了半天终于弄明白原有ICTCLAS用意的一句话。这需要参考本文图二,为了方便起见,我将它挪到了这里:
![](images/0308003.gif)
注意 3 号“C”结点在该表中处于第 3 列,所有可以到达该结点的边就是该列中的元素(目前有两个元素“A@C”与“B@C”)。而与 3 号“C”结点构成这两条边的PreNode结点恰恰是这两个元素的“行号”,分别是 1 号“A”结点与 2 号“B”结点。正是因为这种特殊的对应关系,为我们检索所有可达边提供了便捷的方法。阅读上面那段代码务必把握好这种关系。
3、求解最短路径 求出每个结点上最短路径的PreNode后就需要据此推导出完整的最短路径。原ICTCLAS代码中是靠GetPaths方法实现的,只是到现在我也没有读懂这个方法的代码究竟想干什么 ,只知道它用了若干个while,若干个if,若干个嵌套...(将ICTCLAS中的GetPaths放上来,如果谁读懂了,回头给我讲讲 ,感觉应该和我的算法差不多)。
![](images/copycode.gif)
Copy Code
NShortPath.cpp程序中的GetPaths方法
void CNShortPath::GetPaths(unsigned int nNode, unsigned int nIndex, int
**nResult, bool bBest)
{
CQueue queResult;
unsigned int nCurNode, nCurIndex, nParentNode, nParentIndex, nResultIndex = 0;
if (m_nResultCount >= MAX_SEGMENT_NUM)
//Only need 10 result
return ;
nResult[m_nResultCount][nResultIndex] = - 1; //Init the result
queResult.Push(nNode, nIndex);
nCurNode = nNode;
nCurIndex = nIndex;
bool bFirstGet;
while (!queResult.IsEmpty())
{
while (nCurNode > 0)
//
{
//Get its parent and store them in nParentNode,nParentIndex
if (m_pParent[nCurNode - 1][nCurIndex].Pop(&nParentNode, &nParentIndex, 0,
false, true) != - 1)
{
nCurNode = nParentNode;
nCurIndex = nParentIndex;
}
if (nCurNode > 0)
queResult.Push(nCurNode, nCurIndex);
}
if (nCurNode == 0)
{
//Get a path and output
nResult[m_nResultCount][nResultIndex++] = nCurNode; //Get the first node
bFirstGet = true;
nParentNode = nCurNode;
while (queResult.Pop(&nCurNode, &nCurIndex, 0, false, bFirstGet) != - 1)
{
nResult[m_nResultCount][nResultIndex++] = nCurNode;
bFirstGet = false;
nParentNode = nCurNode;
}
nResult[m_nResultCount][nResultIndex] = - 1; //Set the end
m_nResultCount += 1; //The number of result add by 1
if (m_nResultCount >= MAX_SEGMENT_NUM)
//Only need 10 result
return ;
nResultIndex = 0;
nResult[m_nResultCount][nResultIndex] = - 1; //Init the result
if (bBest)
//Return the best result, ignore others
return ;
}
queResult.Pop(&nCurNode, &nCurIndex, 0, false, true); //Read the top node
while (queResult.IsEmpty() == false && (m_pParent[nCurNode -
1][nCurIndex].IsSingle() || m_pParent[nCurNode - 1][nCurIndex].IsEmpty
(true)))
{
queResult.Pop(&nCurNode, &nCurIndex, 0); //Get rid of it
queResult.Pop(&nCurNode, &nCurIndex, 0, false, true); //Read the top node
}
if (queResult.IsEmpty() == false && m_pParent[nCurNode -
1][nCurIndex].IsEmpty(true) == false)
{
m_pParent[nCurNode - 1][nCurIndex].Pop(&nParentNode, &nParentIndex, 0,
false, false);
nCurNode = nParentNode;
nCurIndex = nParentIndex;
if (nCurNode > 0)
queResult.Push(nCurNode, nCurIndex);
}
}
}
我重写了求解最短路径的方法,其算法表述如下:
![](images/0308005.gif)
(图四)
1)首先将最后一个元素压入堆栈(本例中是6号结点),什么时候这个元素弹出堆栈,什么时候整个任务结束。
2)对于每个结点的PreNode队列,维护了一个当前指针,初始状态都指向PreNode队列中第一个元素。
3)从右向左依次取出PreNode队列中的当前元素并压入堆栈,并将队列指针重新指向队列中第一个元素。如图四:6号元素PreNode是3,3号元素PreNode是1,1号元素PreNode是0。
4)当第一个元素压入堆栈后,输出堆栈内容即为一条队列。本例中0, 1, 3, 6便是一条最短路径。
5)将堆栈中的内容依次弹出,每弹出一个元素,就将当时压栈时对应的PreNode队列指针下移一格。如果到了末尾无法下移,则继续执行第5步,如果仍然可以移动,则执行第3步。
对于本例,先将“0”弹出堆栈,该元素对应的是1号“A”结点的PreNode队列,该队列的当前指针已经无法下移,因此继续弹出堆栈中的“1” ;该元素对应3号“C”结点,因此将3号“C”结点对应的PreNode队列指针下移。由于可以移动,因此将队列中的2压入队列,2号“B”结点的PreNode是1,因此再压入1,依次类推,直到0被压入,此时又得到了一条最短路径,那就是0,1,2,3,6。如下图:
![](images/0308006.gif)
(图五)
再往下,0、1、2都被弹出堆栈,3被弹出堆栈后,由于它对应的6号元素PreNode队列记录指针仍然可以下移,因此将5压入堆栈并依次将其PreNode入栈,直到0被入栈。此时输出第3条最短路径:0, 1, 2, 4, 5, 6。入下图:
![](images/0308007.gif)
(图六)
输出完成后,紧接着又是出栈,此时已经没有任何堆栈元素对应的PreNode队列指针可以下移,于是堆栈中的最后一个元素6也被弹出堆栈,此时输出工作完全结束。我们得到了3条最短路径,分别是:
0, 1, 3, 6,
0, 1, 2, 3, 6,
0, 1, 2, 4, 5, 6,
让我们看看在SharpICTCLAS中,该算法是如何实现的:
![](images/copycode.gif)
Copy Code
SharpICTCLAS中的GetPaths方法
//====================================================================
// 注:index = 0 : 最短的路径; index = 1 : 次短的路径
// 依此类推。index <= this.m_nValueKind
//====================================================================
public List GetPaths(int index)
{
Stack stack = new Stack();
int curNode = m_nNode - 1, curIndex = index;
QueueElement element;
PathNode node;
int[] aPath;
List result = new List();
element = m_pParent[curNode - 1][curIndex].GetFirst();
while (element != null)
{
// ---------- 通过压栈得到路径 -----------
stack.Push(new PathNode(curNode, curIndex));
stack.Push(new PathNode(element.nParent, element.nIndex));
curNode = element.nParent;
while (curNode != 0)
{
element = m_pParent[element.nParent - 1][element.nIndex].GetFirst();
stack.Push(new PathNode(element.nParent, element.nIndex));
curNode = element.nParent;
}
// -------------- 输出路径 --------------
PathNode[] nArray = stack.ToArray();
aPath = new int[nArray.Length];
for(int i=0; i 小结
1)N-最短路径的求解比较复杂,本文先从求解1-最短路径着手,说明SharpICTCLAS是如何计算的,在下篇文章中将推广到N-最短路径。
2)1-最短路径并不意味着只有一条最短路径,而是路径最短的若干条路径。就如本文案例所示,1-最短路径算法最终求得了3条路径,它们的长度都是5,因此都是最短路径。
相关文章推荐
- SharpICTCLAS分词系统简介(5)NShortPath-2
- SharpICTCLAS分词系统简介(4)NShortPath-1
- SharpICTCLAS分词系统简介(5)NShortPath-2
- SharpICTCLAS分词系统简介(5)NShortPath-2
- SharpICTCLAS分词系统简介(4)NShortPath-1
- SharpICTCLAS分词系统简介(6)Segment
- SharpICTCLAS分词系统简介(3)DynamicArray
- SharpICTCLAS分词系统简介(1)、(2)
- SharpICTCLAS分词系统简介(1)读取词典库
- SharpICTCLAS分词系统简介(7)OptimumSegment
- SharpICTCLAS分词系统简介(2)初步分词
- SharpICTCLAS分词系统简介(6
- SharpICTCLAS分词系统简介(3)DynamicArray
- SharpICTCLAS分词系统简介
- SharpICTCLAS分词系统简介(1)读取词典库
- SharpICTCLAS分词系统简介(8)其它
- 引用:SharpICTCLAS分词系统简介(3)DynamicArray
- SharpICTCLAS分词系统简介(6)Segment
- SharpICTCLAS分词系统简介(7)(8)
- SharpICTCLAS分词系统简介(2)初步分词