多对多匹配算法
A. 关于一个字符串匹配算法
我看了一下代码的，大概觉得它主要实现的功能是查找*y对应字符串中是否有与*x对应的字符串相等的子字符串存在，如果存在则返回该子串第一个字符在*y中的位置。
但是你没有把问题说清楚，比如preBmBc和memcmp这两个函数是在你给的程序中没有定义的，我猜了好久都不能猜出他们确切的用途。我估计你们老师主要也是叫你们实现这两个函数吧。。
如果你能在把问题给得详细的。。我可以继续帮你想想。。
不愧是毕业设计的题目啊，确实有点难度啊。我觉得那个函数不是一个简单的字符串匹配算法，它是一个多重字符串匹配算法。我给你个C语言的例子你参考一下吧。一下两下我也搞不出来了，真不好意思。
boyermoore算法的sample程序
TCHAR * BoyerMooreSearch(TCHAR *sSrc, TCHAR *sFind)
{
//
// 声明：
// 该段代码只是BoyerMoore(名字也许不准确)的基本思想，当
// 然不是最优的，具体完善工作就留给你自己乐！嘻嘻。
// 该算法的本质就是从字符串的右端而不是左端开始比较，这
// 样，当查询不匹配时才有可能直接跃过多个字符（最多可以跃过
// strlen(sFind)个字符），如果最右边的字符匹配则回溯。比如：
//
// pain
// ^ 这是第一次比较n和空格比
// The rain in SpainThe rain in Spain
//
// pain
// ^ 这是第二次比较，好爽呀！
// The rain in SpainThe rain in Spain
//
// 当然，这样比较会产生一些问题，比如：
//
// pain
// ^ （图1）
// The rain in SpainThe rain in Spain
//
// 如果比较到这儿，大家都会看到，只需再向后移到两个字符
// 就匹配成功了，但如果接下去还按上面的方法跳strlen(sFind)的
// 话，就会错过一次匹配！！！！！
//
// pain
// ^
// The rain in SpainThe rain in Spain
//
// 怎么办？当然可以解决！大家回头看图1，当时a是pain的子
// 串，说明有可能在不移动strlen(sFind)的跨度就匹配成功，那就
// 人为地给它匹配成功的机会嘛！串一下pain串，直接让两个a对齐
// 再做比较！呵呵，如果要比较的字符不是pain的子串，当然就可
// 以直接跨过strlen(sFind)个字符了！不知我说明白没？
//
//
// 查询串的长度
int nLenOfFind = lstrlen(sFind);
// 被查询串的长度
int nLenOfSrc = lstrlen(sSrc);
// 指向查询串最后一个字符的指针
TCHAR * pEndOfFind = sFind + nLenOfFind -1;
// 指向被查询串最后一个字符的指针
TCHAR * pEndOfSrc = sSrc + nLenOfSrc -1;
// 在比较过程中要用到的两个指针
TCHAR * pSrc = sSrc;
TCHAR * pFind;
// 总不能一直让它比较到win.com文件的地址去吧？嘻嘻！
while ( pSrc <= pEndOfSrc ) {
// 每次匹配都是从右向左，这是本算法的核心。
pFind = pEndOfFind;
// 如果比较不成功，被查询串指针将向右串的字符数
int nMoveRightSrc;
// 比较被查询串的当前字符是否和查询串的最右边字
// 符匹配，如果匹配则回溯比较，如果全匹配了，该
// 干什么，我就不用说了吧？:-)
while ( pFind >= sFind ) {
// TNND，白废功夫比了！看看需要向右移动几个
// 字符吧（如果说从右到左是本算法的核心，则
// 判断向右移几个字符则是本算法的技巧）。
if ( *pSrc != *pFind ) {
// 被查询串的当前字符是否在查询串里？
TCHAR * p = strrchr( sFind, *pSrc );
// 没在，直接移lstrlen(sFind)个字符
if ( NULL == p )
nMoveRightSrc = nLenOfFind;
else
// 哇塞！真的在，那就只需...
nMoveRightSrc = pEndOfFind - p;
break;
}
// 哈！又匹配成功了一个！接着向左回溯...
pFind --;
pSrc --;
}
// 如果在上面的while循环里每一次比较都匹配了
// 那就对了呗！告诉用户找到了
if ( pFind < sFind )
return ( pSrc + 1 );
// 没匹配成功，nMoveRightSrc上面已经算好了
// 直接用就可以了。
pSrc += nMoveRightSrc;
}
// 程序运行到这儿肯定是没指望了！
return NULL;
}
行了，函数写完了，我们可以试一下了！
void CTNNDDlg::OnButton1()
{
TCHAR sSrc[] = "The rain in Spain";
TCHAR sFind[]= "pain";
TCHAR * pFound = BoyerMooreSearch( sSrc, sFind );
if ( pFound )
MessageBox(pFound);
else
MessageBox("没找到");
}
//另外一个
void preBmBc(char *x, int m, int bmBc[]) {
int i;
for (i = 0; i < ASIZE; ++i)
bmBc[i] = m;
for (i = 0; i < m - 1; ++i)
bmBc[x[i]] = m - i - 1;
}
void suffixes(char *x, int m, int *suff) {
int f, g, i;
suff[m - 1] = m;
g = m - 1;
for (i = m - 2; i >= 0; --i) {
if (i > g && suff[i + m - 1 - f] < i - g)
suff[i] = suff[i + m - 1 - f];
else {
if (i < g)
g = i;
f = i;
while (g >= 0 && x[g] == x[g + m - 1 - f])
--g;
suff[i] = f - g;
}
}
}
void preBmGs(char *x, int m, int bmGs[]) {
int i, j, suff[XSIZE];
suffixes(x, m, suff);
for (i = 0; i < m; ++i)
bmGs[i] = m;
j = 0;
for (i = m - 1; i >= -1; --i)
if (i == -1 || suff[i] == i + 1)
for (; j < m - 1 - i; ++j)
if (bmGs[j] == m)
bmGs[j] = m - 1 - i;
for (i = 0; i <= m - 2; ++i)
bmGs[m - 1 - suff[i]] = m - 1 - i;
}
void BM(char *x, int m, char *y, int n) {
int i, j, bmGs[XSIZE], bmBc[ASIZE];
/* Preprocessing */
preBmGs(x, m, bmGs);
preBmBc(x, m, bmBc);
/* Searching */
j = 0;
while (j <= n - m) {
for (i = m - 1; i >= 0 && x[i] == y[i + j]; --i);
if (i < 0) {
OUTPUT(j);
j += bmGs[0];
}
else
j += MAX(bmGs[i], bmBc[y[i + j]] - m + 1 + i);
}
}
B. 有关匹配和排序的算法，高手帮帮忙哈
一、插入排序(Insertion Sort)
1. 基本思想：
每次将一个待排序的数据元素，插入到前面已经排好序的数列中的适当位置，使数列依然有序；直到待排序数据元素全部插入完为止。
2. 排序过程：
【示例】：
[初始关键字] [49] 38 65 97 76 13 27 49
J=2(38) [38 49] 65 97 76 13 27 49
J=3(65) [38 49 65] 97 76 13 27 49
J=4(97) [38 49 65 97] 76 13 27 49
J=5(76) [38 49 65 76 97] 13 27 49
J=6(13) [13 38 49 65 76 97] 27 49
J=7(27) [13 27 38 49 65 76 97] 49
J=8(49) [13 27 38 49 49 65 76 97]
Procere InsertSort(Var R : FileType);
//对R[1..N]按递增序进行插入排序, R[0]是监视哨//
Begin
for I := 2 To N Do //依次插入R[2],...,R[n]//
begin
R[0] := R[I]; J := I - 1;
While R[0] < R[J] Do //查找R[I]的插入位置//
begin
R[J+1] := R[J]; //将大于R[I]的元素后移//
J := J - 1
end
R[J + 1] := R[0] ; //插入R[I] //
end
End; //InsertSort //
二、选择排序
1. 基本思想：
每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
2. 排序过程：
【示例】：
初始关键字 [49 38 65 97 76 13 27 49]
第一趟排序后 13 〔38 65 97 76 49 27 49]
第二趟排序后 13 27 〔65 97 76 49 38 49]
第三趟排序后 13 27 38 [97 76 49 65 49]
第四趟排序后 13 27 38 49 [49 97 65 76]
第五趟排序后 13 27 38 49 49 [97 97 76]
第六趟排序后 13 27 38 49 49 76 [76 97]
第七趟排序后 13 27 38 49 49 76 76 [ 97]
最后排序结果 13 27 38 49 49 76 76 97
Procere SelectSort(Var R : FileType); //对R[1..N]进行直接选择排序 //
Begin
for I := 1 To N - 1 Do //做N - 1趟选择排序//
begin
K := I;
For J := I + 1 To N Do //在当前无序区R[I..N]中选最小的元素R[K]//
begin
If R[J] < R[K] Then K := J
end;
If K <>; I Then //交换R[I]和R[K] //
begin Temp := R[I]; R[I] := R[K]; R[K] := Temp; end;
end
End; //SelectSort //
三、冒泡排序(BubbleSort)
1. 基本思想：
两两比较待排序数据元素的大小，发现两个数据元素的次序相反时即进行交换，直到没有反序的数据元素为止。
2. 排序过程：
设想被排序的数组R〔1..N〕垂直竖立，将每个数据元素看作有重量的气泡，根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R，凡扫描到违反本原则的轻气泡，就使其向上"漂浮"，如此反复进行，直至最后任何两个气泡都是轻者在上，重者在下为止。
【示例】：
49 13 13 13 13 13 13 13
38 49 27 27 27 27 27 27
65 38 49 38 38 38 38 38
97 65 38 49 49 49 49 49
76 97 65 49 49 49 49 49
13 76 97 65 65 65 65 65
27 27 76 97 76 76 76 76
49 49 49 76 97 97 97 97
Procere BubbleSort(Var R : FileType) //从下往上扫描的起泡排序//
Begin
For I := 1 To N-1 Do //做N-1趟排序//
begin
NoSwap := True; //置未排序的标志//
For J := N - 1 DownTo 1 Do //从底部往上扫描//
begin
If R[J+1]< R[J] Then //交换元素//
begin
Temp := R[J+1]; R[J+1 := R[J]; R[J] := Temp;
NoSwap := False
end;
end;
If NoSwap Then Return//本趟排序中未发生交换，则终止算法//
end
End; //BubbleSort//
四、快速排序（Quick Sort）
1. 基本思想：
在当前无序区R[1..H]中任取一个数据元素作为比较的"基准"(不妨记为X)，用此基准将当前无序区划分为左右两个较小的无序区：R[1..I-1]和R[I+1..H]，且左边的无序子区中数据元素均小于等于基准元素，右边的无序子区中数据元素均大于等于基准元素，而基准X则位于最终排序的位置上，即R[1..I-1]≤X.Key≤R[I+1..H](1≤I≤H)，当R[1..I-1]和R[I+1..H]均非空时，分别对它们进行上述的划分过程，直至所有无序子区中的数据元素均已排序为止。
2. 排序过程：
【示例】：
初始关键字 [49 38 65 97 76 13 27 49〕
第一次交换后 〔27 38 65 97 76 13 49 49〕
第二次交换后 〔27 38 49 97 76 13 65 49〕
J向左扫描，位置不变，第三次交换后 〔27 38 13 97 76 49 65 49〕
I向右扫描，位置不变，第四次交换后 〔27 38 13 49 76 97 65 49〕
J向左扫描 〔27 38 13 49 76 97 65 49〕
（一次划分过程）
初始关键字 〔49 38 65 97 76 13 27 49〕
一趟排序之后 〔27 38 13〕 49 〔76 97 65 49〕
二趟排序之后 〔13〕 27 〔38〕 49 〔49 65〕76 〔97〕
三趟排序之后 13 27 38 49 49 〔65〕76 97
最后的排序结果 13 27 38 49 49 65 76 97
各趟排序之后的状态
Procere Parttion(Var R : FileType; L, H : Integer; Var I : Integer);
//对无序区R[1,H]做划分，I给以出本次划分后已被定位的基准元素的位置 //
Begin
I := 1; J := H; X := R[I] ;//初始化，X为基准//
Repeat
While (R[J] >;= X) And (I < J) Do
begin
J := J - 1 //从右向左扫描，查找第1个小于 X的元素//
If I < J Then //已找到R[J] 〈X//
begin
R[I] := R[J]; //相当于交换R[I]和R[J]//
I := I + 1
end;
While (R[I] <= X) And (I < J) Do
I := I + 1 //从左向右扫描，查找第1个大于 X的元素///
end;
If I < J Then //已找到R[I] >; X //
begin R[J] := R[I]; //相当于交换R[I]和R[J]//
J := J - 1
end
Until I = J;
R[I] := X //基准X已被最终定位//
End; //Parttion //
Procere QuickSort(Var R :FileType; S,T: Integer); //对R[S..T]快速排序//
Begin
If S < T Then //当R[S..T]为空或只有一个元素是无需排序//
begin
Partion(R, S, T, I); //对R[S..T]做划分//
QuickSort(R, S, I-1);//递归处理左区间R[S,I-1]//
QuickSort(R, I+1,T);//递归处理右区间R[I+1..T] //
end;
End; //QuickSort//
五、堆排序(Heap Sort)
1. 基本思想：
堆排序是一树形选择排序，在排序过程中，将R[1..N]看成是一颗完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系来选择最小的元素。
2. 堆的定义: N个元素的序列K1,K2,K3,...,Kn.称为堆，当且仅当该序列满足特性：
Ki≤K2i Ki ≤K2i+1(1≤ I≤ [N/2])
堆实质上是满足如下性质的完全二叉树：树中任一非叶子结点的关键字均大于等于其孩子结点的关键字。例如序列10,15,56,25,30,70就是一个堆，它对应的完全二叉树如上图所示。这种堆中根结点（称为堆顶）的关键字最小，我们把它称为小根堆。反之，若完全二叉树中任一非叶子结点的关键字均大于等于其孩子的关键字，则称之为大根堆。
3. 排序过程：
堆排序正是利用小根堆（或大根堆）来选取当前无序区中关键字小（或最大）的记录实现排序的。我们不妨利用大根堆来排序。每一趟排序的基本操作是：将当前无序区调整为一个大根堆，选取关键字最大的堆顶记录，将它和无序区中的最后一个记录交换。这样，正好和直接选择排序相反，有序区是在原记录区的尾部形成并逐步向前扩大到整个记录区。
【示例】：对关键字序列42，13，91，23，24，16，05，88建堆
Procere Sift(Var R :FileType; I, M : Integer);
//在数组R[I..M]中调用R[I]，使得以它为完全二叉树构成堆。事先已知其左、右子树(2I+1 <=M时)均是堆//
Begin
X := R[I]; J := 2*I; //若J <=M, R[J]是R[I]的左孩子//
While J <= M Do //若当前被调整结点R[I]有左孩子R[J]//
begin
If (J < M) And R[J].Key < R[J+1].Key Then
J := J + 1 //令J指向关键字较大的右孩子//
//J指向R[I]的左、右孩子中关键字较大者//
If X.Key < R[J].Key Then //孩子结点关键字较大//
begin
R[I] := R[J]; //将R[J]换到双亲位置上//
I := J ; J := 2*I //继续以R[J]为当前被调整结点往下层调整//
end;
Else
Exit//调整完毕，退出循环//
end
R[I] := X;//将最初被调整的结点放入正确位置//
End;//Sift//
Procere HeapSort(Var R : FileType); //对R[1..N]进行堆排序//
Begin
For I := N Div Downto 1 Do //建立初始堆//
Sift(R, I , N)
For I := N Downto 2 do //进行N-1趟排序//
begin
T := R[1]; R[1] := R[I]; R[I] := T;//将当前堆顶记录和堆中最后一个记录交换//
Sift(R, 1, I-1) //将R[1..I-1]重成堆//
end
End; //HeapSort//
六、几种排序算法的比较和选择
1. 选取排序方法需要考虑的因素：
(1) 待排序的元素数目n；
(2) 元素本身信息量的大小；
(3) 关键字的结构及其分布情况；
(4) 语言工具的条件，辅助空间的大小等。
2. 小结：
(1) 若n较小(n <= 50)，则可以采用直接插入排序或直接选择排序。由于直接插入排序所需的记录移动操作较直接选择排序多，因而当记录本身信息量较大时，用直接选择排序较好。
(2) 若文件的初始状态已按关键字基本有序，则选用直接插入或冒泡排序为宜。
(3) 若n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序。 快速排序是目前基于比较的内部排序法中被认为是最好的方法。
(4) 在基于比较排序方法中，每次比较两个关键字的大小之后，仅仅出现两种可能的转移，因此可以用一棵二叉树来描述比较判定过程，由此可以证明：当文件的n个关键字随机分布时，任何借助于"比较"的排序算法，至少需要O(nlog2n)的时间。
(5) 当记录本身信息量较大时，为避免耗费大量时间移动记录，可以用链表作为存储结构。
C. 什么是字符串多模式匹配和字符串多模式匹配算法又如何
你问两个多模式匹配有什么区别吗..
多模式就是说查找的子串不止一个.
你可以当做是单一模式匹配的叠加版,那样直接套KMP也行.
至于字典树(trie),一般用于英文单词匹配.
trie是一棵树,树上的每一条边都是一个字母,除了根节点之外的每一个节点都代表一个单词.
对于每一个节点,都有26个指针:指针A - 指针Z,分别对应26个字母
一开始时,字典树只有一个根节点,当加入一个单词时,先向根节点插入一个元素,连接根节点的一个指针,这个指针编号是单词的第一个字母,然后再在这个新的节点上增加一个元素,指针编号是第二个字母...以此类推.
检索过程很简单,自己想想就懂了,这个结构已经十分好理解了.
D. 求多项式中括号匹配算法~~（有关数据结构，C++实现）
括号可以用栈来匹配啊, 数据结构中的运算符优先法就是用栈实现的,
左右括号都是运算符,规定(优先级最底,要入栈到运算符栈, 其他运算符优先都要高于( 但低于),其他运算符之间的优先关系暂且忽略不说,也就是当读取到) 的时候, 括号内运算一定会结束并得出一个结果进入到操作数栈(由于 ) 的优先级比其他所有运算符都高,其他运算符要出栈运算,并且把结果入到操作数栈),然后就是检查操作数栈栈顶是否是左括号,如果是在左括号出栈,这样左右括号就一起消掉,如果不是,则报错,你要检查你的运算符优先表的定义,因为根据定义,到读取到右括号的时候,括号内的运算会结束并得出结果, 空括号不影响计算, 只是没有操作数入栈而已,而且可以嵌套括号 , 规定好了优先级,可以实现多种不同优先级的括号的混合运算
E. 在MATLAB的sift算法中，怎么用一个模板与多幅图像进行匹配
(1) 尺度不变特征变换（SIFT算法）概要
是一种计算机视觉的算法，用来侦测与描述影像中的局部性特征，它在空间尺度中寻找极值点，并提取出其位置、尺度、旋转不变量。
此算法由 David Lowe 在1999年所发表，2004年完善总结。其应用范围包含物体辨识、机器人地图感知与导航、影像缝合、3D模型建立、手势辨识、影像追踪和动作比对。此算法有其专利，专利拥有者为 英属哥伦比亚大学。
局部影像特征的描述与侦测可以帮助辨识物体，SIFT 特征是基于物体上的一些局部外观的兴趣点而与影像的大小和旋转无关。 对于光线、噪声、些微视角改变的容忍度也相当高。基于这些特性，它们是高度显着而且相对容易撷取，在母数庞大的特征数据库中，很容易辨识物体而且鲜有误认。使用 SIFT特征描述对于部分物体遮蔽的侦测率也相当高，甚至只需要3个以上的SIFT物体特征就足以计算出位置与方位。在现今的电脑硬件速度下和小型的特征数据库条件下，辨识速度可接近即时运算。SIFT特征的信息量大，适合在海量数据库中快速准确匹配。
(2 ) Matlab代码主要功能函数如下： match.m：测试程序
功能：该函数读入两幅（灰度）图像，找出各自的 SIFT 特征, 并显示两连接两幅图像中被匹配的特征点（关键特征点（the matched keypoints）直线（将对应特征点进行连接）。判断匹配的准则是匹配距离小于distRatio倍于下一个最近匹配的距离（ A match is accepted only if its distance is less than distRatio times the distance to the second closest match. 该程序返回显示的匹配对的数量。（ It returns the number of matches displayed.） 调用实例： match('desk.jpg','book.jpg');
( 假如，想测试一个含有一本书的桌面的图像 和一本书的图像之间特征匹配） 调用方法和参数描述：略。 注意：（1）图像为灰度图像，如果是彩色图像，应该在调用前利用rgb2gray转换为灰度图像。
（2）参数distRatio 为控制匹配点数量的系数，这里取 0.6，该参数决定了匹配点的数量，在Match.m文件中调整该参数，获得最合适的匹配点数量。 sift.m :尺度不变特征变换（SIFT算法）的核心算法程序
功能：该函数读入灰度图像，返回SIFT 特征关键点（ SIFT keypoints.） 调用方法和参数描述：
调用方式：[image, descriptors, locs] = sift(imageFile) 输入参数（ Input parameters）:
imageFile: 图像文件名.
输出或返回参数（ Returned）:
image: 是具有double format格式的图像矩阵
descriptors: 一个 K-by-128 的矩阵x, 其中每行是针对找到的K个关键特征点（the K keypoints）的不变量描述子. 这个描述子（descriptor）是一个拥有128个数值并归一化为单位长度向量.
locs: 是K-by-4 矩阵, 其中的每一行具有四个数值，表示关键点位置信息 (在图像中的行坐标，列坐标（row, column) ，注意，一般图像的左上角为坐标原点）, 尺度scale，高斯尺度空间的参数，其中该参数也决定了frame(结构）确定的图像disk的大小, 最后一个参数是方向orientation). 方向参数的范围是[-PI, PI] 单位为弧度.
appendimages.m: 该函数创建一个新的图像分别包含两个匹配的图像和他们之间
的匹配对的连接直线. (3) 实际案例执行结果：
程序代码使用matlab和c混合编程。用matlab打开文件中的sift_match.m文件，并执行。如下图所示：
F. 如何评估与匹配算法的特征描述
同一场景在不同条件下投影所得到的二维图像会有很大的差异，这主要是由如下原因引起的：传感器噪声、成像过程中视角改变引起的图像变化、目标移动和变形、光照或者环境的改变带来的图像变化以及多种传感器的使用等。为解决上述图像畸变带来的匹配困难，人们提出了许多匹配算法，而它们都是由如下四个要素组合而成：
（1）特征空间
特征空间是由参与匹配的图像特征构成的，选择好的特征可以提高匹配性能、降低搜索空间、减小噪声等不确定性因素对匹配算法的影响。匹配过程可以使用全局特征或者局部特征以及两者的结合。
（2）相似性度量
相似性度量指用什么度量来确定待匹配特征之间的相似性，它通常定义为某种代价函数或者是距离函数的形式。经典的相似性度量包括相关函数和 Minkowski 距离，近年来人们提出了 Hausdorff 距离、互信息作为匹配度量。Hausdorff 距离对于噪声非常敏感，分数 Hausdorff 距离能处理当目标存在遮挡和出格点的情况，但计算费时；基于互信息的方法因其对于照明的改变不敏感已在医学等图像的匹配中得到了广泛应用，它也存在计算量大的问题，而且要求图像之间有较大的重叠区域。
G. 图像匹配的算法
迄今为止，人们已经提出了各种各样的图像匹配算法，但从总体上讲，这些匹配算法可以分成关系结构匹配方法、结合特定理论工具的匹配方法、基于灰度信息的匹配方法、基于亚像元匹配方法、基于内容特征的匹配方法五大类型 基于内容特征的匹配首先提取反映图像重要信息的特征，而后以这些特征为模型进行匹配。局部特征有点、边缘、线条和小的区域，全局特征包括多边形和称为结构的复杂的图像内容描述。特征提取的结果是一个含有特征的表和对图像的描述，每一个特征由一组属性表示，对属性的进一步描述包括边缘的定向和弧度，边与线的长度和曲率，区域的大小等。除了局部特征的属性外，还用这些局部特征之间的关系描述全局特征，这些关系可以是几何关系，例如两个相邻的三角形之间的边，或两个边之间的距离可以是辐射度量关系，例如灰度值差别，或两个相邻区域之间的灰度值方差或拓扑关系，例如一个特征受限于另一个特征。人们一般提到的基于特征的匹配绝大多数都是指基于点、线和边缘的局部特征匹配，而具有全局特征的匹配实质上是我们上面提到的关系结构匹配方法。特征是图像内容最抽象的描述，与基于灰度的匹配方法比，特相对于几何图像和辐射影响来说更不易变化，但特征提取方法的计算代价通常较，并且需要一些自由参数和事先按照经验选取的闭值，因而不便于实时应用同时，在纹理较少的图像区域提取的特征的密度通常比较稀少，使局部特征的提 取比较困难。另外，基于特征的匹配方法的相似性度量也比较复杂，往往要以特征属性、启发式方法及闭方法的结合来确定度量方法。基于图像特征的匹配方法可以克服利用图像灰度信息进行匹配的缺点，由于图像的特征点比象素点要少很多，因而可以大大减少匹配过程的计算量同时，特征点的匹配度量值对位置的变化比较敏感，可以大大提高匹配的精确程度而且，特征点的提取过程可以减少噪声的影响，对灰度变化，图像形变以及遮挡等都有较好的适应能力。所以基于图像特征的匹配在实际中的应用越来越广-泛。所使用的特征基元有点特征明显点、角点、边缘点等、边缘线段等。
H. 双目视觉的匹配算法是不是有好几种具体是哪几种
与普通的图像模板匹配不同的是，立体匹配是通过在两幅或多幅存在视点差异、几何畸变、灰度畸变、噪声干扰的图像对之间进行的，不存在任何标准模板进行匹配。立体匹配方法一般包含以下三个问题:(1)基元的选择，即选择适当的图像特征如点、直线、相位等作为匹配基元;(2)匹配的准则，将关于物理世界的某些固有特征表示为匹配所必须遵循的若干规则，使匹配结果能真实反映景物的本来面目;(3)算法结构，通过利用适当的数学方法设计能正确匹配所选择基元的稳定算法。
根据匹配基元的不同，立体视觉匹配算法目前主要分为三大类,即区域匹配、相位匹配和特征匹配:
基于区域灰度的匹配算法是把一幅图像(基准图)中某一点的灰度邻域作为模板，在另一幅图像(待匹配图)中搜索具有相同(或相似)灰度值分布的对应点邻域，从而实现两幅图像的匹配。这类算法的性能取决于度量算法及搜索策略的选择。另外，也必须考虑匹配窗口大小、形式的选择，大窗口对于景物中存在的遮挡或图像不光滑的情况会更多的出现误匹配，小窗口则不具有足够的灰度变化信息，不同的窗口形式对匹配信息也会有不同的影响。因此应该合理选取匹配区域的大小和形式来达到较好的匹配结果。
相位匹配是近二十年发展起来的一种匹配算法，相位作为匹配基元，即认为图像对中的对应点局部相位是一致的。最常用的相位匹配算法有相位相关法和相位差——频率法，虽然该方法是一种性能稳定、具有较强的抗辐射抗透视畸变能力、简单高效、能得到稠密视差图的特征匹配方法。但是，当局部结构存在的假设不成立时，相位匹配算法因带通输出信号的幅度太低而失去有效性，也就是通常提到的相位奇点问题，在相位奇点附近，相位信息对位置和频率的变化极为敏感，因此用这些像素所确定的相位差异来衡量匹配误差将导致极不可靠的结果。此外，相位匹配算法的收敛范围与带通滤波器的波长有关，通常要考虑相位卷绕，在用相位差进行视差计算时，由于所采用的相位只是原信号某一带通条件下的相位，故视差估计只能限制在某一限定范围之内，随视差范围的增大，其精确性会有所下降。
基于特征的图像匹配方法是目前最常用的方法之一，由于它能够将对整个图像进行的各种分析转化为对图像特征(特征点、特征曲线等)的分析的优点，从而大大减小了图像处理过程的计算量，对灰度变化、图像变形、噪音污染以及景物遮挡等都有较好的适应能力。
基于特征的匹配方法是为使匹配过程满足一定的抗噪能力且减少歧义性问题而提出来的。与基于区域的匹配方法不同，基于特征的匹配方法是有选择地匹配能表示景物自身特性的特征，通过更多地强调空间景物的结构信息来解决匹配歧义性问题。这类方法将匹配的搜索范围限制在一系列稀疏的特征上。利用特征间的距离作为度量手段，具有最小距离的特征对就是最相近的特征对，也就是匹配对。特征间的距离度量有最大最小距离、欧氏距离等。
特征点匹配算法严格意义上可以分成特征提取、特征匹配和消除不良匹配点三步。特征匹配不直接依赖于灰度，具有较强的抗干扰性。该类方法首先从待匹配的图像中提取特征，用相似性度量和一些约束条件确定几何变换，最后将该变换作用于待匹配图像。匹配中常用的特征基元有角点、边缘、轮廓、直线、颜色、纹理等。同时，特征匹配算法也同样地存在着一些不足，主要表现为:
(l)特征在图像中的稀疏性决定了特征匹配只能得到稀疏的视差场，要获得密集的视差场必须通过使用插值的过程，插值过程通常较为复杂。
(2)特征的提取和定位的准确与否直接影响特征匹配结果的精确度。
(3)由于其应用场合的局限性，特征匹配往往适用于具有特征信息显着的环境中，在缺少显着主导特征环境中该方法有很大困难。
总之，特征匹配基元包含了算法编程上的灵活性以及令人满意的统计特性。算法的许多约束条件均能清楚地应用于数据结构，而数据结构的规则性使得特征匹配非常适用于硬件设计。例如，基于线段的特征匹配算法将场景模型描绘成相互联结的边缘线段，而不是区域匹配中的平面模型，因此能很好地处理一些几何畸变问题，对对比度和明显的光照变化等相对稳定。特征匹配由于不直接依赖于灰度，计算量小，比基于区域的匹配算法速度快的多。且由于边缘特征往往出现在视差不连续的区域，特征匹配较易处理立体视觉匹配中的视差不连续问题。
I. 求c#方面关于字符串匹配的算法（不仅可以知道哪错了，还能知道那多了哪少了，具体看下里面吧）
给个思路，把两组字符组用' '分割成每个单词数组，在循环匹配两个数组，就可以知道多的单词和少的单词了,存在大小写的先统一格式化小写。
J. 目前时间复杂度最好的字符串匹配算法是什么
KMP是O(n+m)，你可以上网搜索一下。
还有扩展KMP,是针对不同的问题。
以及Trie等多模式匹配。
总之都能方便搜索到啦。