多對多匹配演算法
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等多模式匹配。
總之都能方便搜索到啦。