條件匹配演算法

❶ 請問 熟悉VBA的朋友，如何實現有限制條件的自動匹配

首先有三個原始數據表，分別為「基本信息」，「等級記錄1」，「等級記錄2」，為了保護原始數據，另外創建三個表做輔助運算，順序基本是從模塊1到4，最後再把運算結果復制到「RT」表，通過「RT」表中的時間變化來更新結果，結果分別是通過等級、時間之間的運算得到的，代碼裡面有說明的。但是有幾段代碼運行是出現錯誤，我現在的水平還看不出哪裡出錯，所以請你看一下。另外創建三個新表是我自己的想法，如果可以不建新表直接得到RT的結果就最好，你看看能不能把代碼整合、優化一下，提高運行速度。

1.把「基礎信息表」的數據復制到「basic」表，並添加「RT」...「F(t)」等項，見模塊1Sub CreateBasic()、Sub
BasicCopy()；「basic」中的「K2」、「K4」可以先計算，見模塊1的Sub
FGPA()
2.把「等級記錄1」的數據復制到「記錄1」表，並添加「等級評分」、「K1」，見模塊1Sub DnewSheet() 、Sub
D()；要求「等級記錄1」的等級記錄可以和編碼切換，見模塊1Sub
DcodeChange1()（PS：這個運行時出現錯誤，為什麼）。
3.按等級記錄，匹配「記錄1」中的等級評分，並計算「K1」，見模塊2的Function
sum1和模塊1的Sub Dsum()；把「K1」按要求匯總到「basic」中的「K1」，見模塊1的Sub Dtotal()

4.把「等級記錄2」的數據復制到「記錄2」，並添加「等級評分」、「等級影響」、「K5」、「F(t0)」，見模塊3的Sub SnewSheet()、Sub
S()；要求「等級記錄2」的等級記錄可以和編碼切換，見模塊3Sub
ScodeChange()（這里運行是也出錯）；
5.按等級記錄，匹配「記錄2」中的等級評分、等級影響，並分別計運算元K5，F(t0)，見模塊2的Function
sum2，模塊3的Sub
Ssum()；
6.把「記錄2」中每行K5，F(t0)相乘後再把相同條件編號的乘積相加，匹配到「basic」中的「K5*F(t0)」，見模塊3的Sub
Stotal()；
7.計算「basic」中的K3、F(t)、RT，見模塊2的Function sum3、模塊3的Sub
SumAll()
8.把「basic」的A-G列復制到」RT「表，見模塊4的Sub CreateRT()、Sub
BasicRTCopy()
9.」RT「表的內容是最終要顯示的結果，所以在」B3「添加一個選擇日期控制項，希望可以通過選擇不同時間得到結果

❷ 有關匹配和排序的演算法，高手幫幫忙哈

一、插入排序(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++高手請進

先拆分成二段
1 S[]數組的形成
2 匹配演算法

1。形成S[]數組，要根據題目要求，比如for(i=0;;i++) 當i為兩位時處理一下分成二部份。三位時處理成三個部份（乍想之下的，可能有更好的處理方法）

2。匹配的話，可以逐字匹配，或者用KMP演算法匹配。

根據這樣 程序的話你試試看能不能寫出來
如果覺得復雜再細化之。比較復雜的問題，一般能通過細化模塊，求解出來

以下是我寫的程序，供參考
#include <iostream.h>
#include <math.h>

void main()
{
cout<<"請輸入自然數組最大值"<<endl; //輸入自然數最大值，如11，則從1……11
int s_max;
cin>>s_max;
void get_Array_max(int *,int );//聲明函數
int my_result[2];
get_Array_max(my_result,s_max);//調用函數
int nbit=my_result[0];//賦返回的第一個值
int s_fact_max=my_result[1];//賦返回的第二個值，該值是拓展後的數組長度
//cout<<"nbit -->"<<nbit<<"-----s_fact_max:"<<s_fact_max<<endl;
int *s=new int[s_fact_max];//申請這個長度的數組s[]
void set_Init(int *,int,int);//聲明函數
set_Init(s,s_max,nbit);//給數組s[]賦值
/*for(int x=0;x<s_fact_max;x++)
{
cout<<s[x]<<"--------"<<endl;
}*/
cout<<"自然數組形成完畢"<<endl;
cout<<"請輸入子串"<<endl;
int my_input;
cin>>my_input;
int get_nbit(int);//聲明函數
int input_max=get_nbit(my_input);//算出輸入的位數
int *a=new int[input_max];//申請這個長度的數組a[]
void set_input_Init(int *,int ,int );//聲明函數
set_input_Init(a,input_max,my_input);//給這個數組a[]賦值
/*for(x=0;x<input_max;x++)
{
cout<<a[x]<<"--------"<<endl;
}*/
int search_loc(int *,int *,int ,int );//聲明函數
//cout<<"========"<<search_loc(s,a,s_fact_max,input_max)<<endl;
if(int msg=search_loc(s,a,s_fact_max,input_max) != -1)
{
cout<<"出現該子串的首位置在："<<search_loc(s,a,s_fact_max,input_max)<<endl;
}
else
{
cout<<"沒有找到該子串"<<endl;
}
delete s,a;
}

int search_loc(int *s,int *a,int s_fact_max,int input_max)
{
int s1=0;
int a1=0;
int count=0;
//cout<<s_fact_max<<endl;
while(true)
{
//cout<<"-----=======-------"<<s[s1]<<' '<<a[a1]<<endl;
if(s[s1]==a[a1])//如果相應位相等則進入
{
//cout<<"(-(_((__"<<s1<<'-'<<a1<<endl;
if(a1==input_max-1)//如果輸入的位數達到末尾則找到條件，返回
{
return s1-input_max+2;//返回位置
}
s1++;
a1++;
continue;
}
a1=0;
s1=++count;
if(s1==s_fact_max)//到達末尾仍沒結束
{
return -1;
}
}
}

void get_Array_max(int *my_result,int max)
{
int num;
for(int i=5;i>=0;i--)
{
if( (max/(int)pow(10,i))!=0)
{
num=i+1;
break;
}
}//計算自然數組最大值的位數
int fact_max=max;
for(i=1;i<num-1;i++)
{
fact_max=fact_max+9*(int)pow(10,i)*i;
}
fact_max=fact_max+(max-(int)pow(10,num-1)+1)*(num-1);//算出拆分該數組後的總長度
my_result[0]=num;
my_result[1]=fact_max;//將位數和總長度存入數組

}

int get_nbit(int max)
{
int num;
for(int i=5;i>=0;i--)
{
if( (max/(int)pow(10,i))!=0)
{
num=i+1;
break;
}
}
return num;//計算位數
}

void set_Init(int *s,int max,int nbit)//將數拆分寫入S[]
{
int arr_num=0;
for(int i=1;i<=max;i++)
{
int tmp=i;
for(int j=nbit-1;j>=0;j--)
{
if( (tmp/(int)pow(10,j)) !=0 || (get_nbit(tmp)<j+1 && get_nbit(i)>j+1) )
{
s[arr_num++]=tmp/(int)pow(10,j);
//cout<<"##########"<<arr_num-1<<"%%%%%%%%"<<s[arr_num-1]<<endl;
tmp=tmp%(int)pow(10,j);
}
}
}
}

void set_input_Init(int *a,int nbit,int my_input)//將數拆分寫入A[]
{
int i=0;
for(int j=nbit-1;j>=0;j--)
{
a[i++]=my_input/(int)pow(10,j);
my_input=my_input%(int)pow(10,j);
}
}

❹ 如何評估與匹配演算法的特徵描述

同一場景在不同條件下投影所得到的二維圖像會有很大的差異，這主要是由如下原因引起的：感測器雜訊、成像過程中視角改變引起的圖像變化、目標移動和變形、光照或者環境的改變帶來的圖像變化以及多種感測器的使用等。為解決上述圖像畸變帶來的匹配困難，人們提出了許多匹配演算法，而它們都是由如下四個要素組合而成：
（1）特徵空間
特徵空間是由參與匹配的圖像特徵構成的，選擇好的特徵可以提高匹配性能、降低搜索空間、減小雜訊等不確定性因素對匹配演算法的影響。匹配過程可以使用全局特徵或者局部特徵以及兩者的結合。
（2）相似性度量
相似性度量指用什麼度量來確定待匹配特徵之間的相似性，它通常定義為某種代價函數或者是距離函數的形式。經典的相似性度量包括相關函數和 Minkowski 距離，近年來人們提出了 Hausdorff 距離、互信息作為匹配度量。Hausdorff 距離對於雜訊非常敏感，分數 Hausdorff 距離能處理當目標存在遮擋和出格點的情況，但計算費時；基於互信息的方法因其對於照明的改變不敏感已在醫學等圖像的匹配中得到了廣泛應用，它也存在計算量大的問題，而且要求圖像之間有較大的重疊區域。

❺ 數據結構有哪些基本演算法

數據結構是一門研究非數值計算的程序設計問題中的操作對象，以及它們之間的關系和操作等相關問題的學科。

可以理解為：程序設計 = 數據結構 + 演算法

數據結構演算法具有五個基本特徵：輸入、輸出、有窮性、確定性和可行性。

1、輸入：一個演算法具有零個或者多個輸出。以刻畫運算對象的初始情況，所謂0個輸入是指演算法本身定出了初始條件。後面一句話翻譯過來就是，如果一個演算法本身給出了初始條件，那麼可以沒有輸出。比如，列印一句話：NSLog(@"你最牛逼！");

2、輸出：演算法至少有一個輸出。也就是說，演算法一定要有輸出。輸出的形式可以是列印，也可以使返回一個值或者多個值等。也可以是顯示某些提示。

3、有窮性：演算法的執行步驟是有限的，演算法的執行時間也是有限的。

4、確定性：演算法的每個步驟都有確定的含義，不會出現二義性。

5、可行性：演算法是可用的，也就是能夠解決當前問題。

數據結果的基本演算法有：

1、圖搜索（廣度優先、深度優先）深度優先特別重要

2、排序

3、動態規劃

4、匹配演算法和網路流演算法

5、正則表達式和字元串匹配

6、三路劃分-快速排序

7、合並排序（更具擴展性，復雜度類似快速排序）

8、DF/BF 搜索 （要知道使用場景）

9、Prim / Kruskal （最小生成樹）

10、Dijkstra （最短路徑演算法）

11、選擇演算法

❻ 演算法有哪些分類

演算法分類編輯演算法可大致分為：

基本演算法、數據結構的演算法、數論與代數演算法、計算幾何的演算法、圖論的演算法、動態規劃以及數值分析、加密演算法、排序演算法、檢索演算法、隨機化演算法、並行演算法，厄米變形模型，隨機森林演算法。

❼ 雙目視覺的匹配演算法是不是有好幾種具體是哪幾種

與普通的圖像模板匹配不同的是，立體匹配是通過在兩幅或多幅存在視點差異、幾何畸變、灰度畸變、雜訊干擾的圖像對之間進行的，不存在任何標准模板進行匹配。立體匹配方法一般包含以下三個問題:(1)基元的選擇，即選擇適當的圖像特徵如點、直線、相位等作為匹配基元;(2)匹配的准則，將關於物理世界的某些固有特徵表示為匹配所必須遵循的若干規則，使匹配結果能真實反映景物的本來面目;(3)演算法結構，通過利用適當的數學方法設計能正確匹配所選擇基元的穩定演算法。

根據匹配基元的不同，立體視覺匹配演算法目前主要分為三大類,即區域匹配、相位匹配和特徵匹配:

基於區域灰度的匹配演算法是把一幅圖像(基準圖)中某一點的灰度鄰域作為模板，在另一幅圖像(待匹配圖)中搜索具有相同(或相似)灰度值分布的對應點鄰域，從而實現兩幅圖像的匹配。這類演算法的性能取決於度量演算法及搜索策略的選擇。另外，也必須考慮匹配窗口大小、形式的選擇，大窗口對於景物中存在的遮擋或圖像不光滑的情況會更多的出現誤匹配，小窗口則不具有足夠的灰度變化信息，不同的窗口形式對匹配信息也會有不同的影響。因此應該合理選取匹配區域的大小和形式來達到較好的匹配結果。

相位匹配是近二十年發展起來的一種匹配演算法，相位作為匹配基元，即認為圖像對中的對應點局部相位是一致的。最常用的相位匹配演算法有相位相關法和相位差——頻率法，雖然該方法是一種性能穩定、具有較強的抗輻射抗透視畸變能力、簡單高效、能得到稠密視差圖的特徵匹配方法。但是，當局部結構存在的假設不成立時，相位匹配演算法因帶通輸出信號的幅度太低而失去有效性，也就是通常提到的相位奇點問題，在相位奇點附近，相位信息對位置和頻率的變化極為敏感，因此用這些像素所確定的相位差異來衡量匹配誤差將導致極不可靠的結果。此外，相位匹配演算法的收斂范圍與帶通濾波器的波長有關，通常要考慮相位卷繞，在用相位差進行視差計算時，由於所採用的相位只是原信號某一帶通條件下的相位，故視差估計只能限制在某一限定范圍之內，隨視差范圍的增大，其精確性會有所下降。

基於特徵的圖像匹配方法是目前最常用的方法之一，由於它能夠將對整個圖像進行的各種分析轉化為對圖像特徵(特徵點、特徵曲線等)的分析的優點，從而大大減小了圖像處理過程的計算量，對灰度變化、圖像變形、噪音污染以及景物遮擋等都有較好的適應能力。

基於特徵的匹配方法是為使匹配過程滿足一定的抗噪能力且減少歧義性問題而提出來的。與基於區域的匹配方法不同，基於特徵的匹配方法是有選擇地匹配能表示景物自身特性的特徵，通過更多地強調空間景物的結構信息來解決匹配歧義性問題。這類方法將匹配的搜索范圍限制在一系列稀疏的特徵上。利用特徵間的距離作為度量手段，具有最小距離的特徵對就是最相近的特徵對，也就是匹配對。特徵間的距離度量有最大最小距離、歐氏距離等。

特徵點匹配演算法嚴格意義上可以分成特徵提取、特徵匹配和消除不良匹配點三步。特徵匹配不直接依賴於灰度，具有較強的抗干擾性。該類方法首先從待匹配的圖像中提取特徵，用相似性度量和一些約束條件確定幾何變換，最後將該變換作用於待匹配圖像。匹配中常用的特徵基元有角點、邊緣、輪廓、直線、顏色、紋理等。同時，特徵匹配演算法也同樣地存在著一些不足，主要表現為:

(l)特徵在圖像中的稀疏性決定了特徵匹配只能得到稀疏的視差場，要獲得密集的視差場必須通過使用插值的過程，插值過程通常較為復雜。

(2)特徵的提取和定位的准確與否直接影響特徵匹配結果的精確度。

(3)由於其應用場合的局限性，特徵匹配往往適用於具有特徵信息顯著的環境中，在缺少顯著主導特徵環境中該方法有很大困難。

總之，特徵匹配基元包含了演算法編程上的靈活性以及令人滿意的統計特性。演算法的許多約束條件均能清楚地應用於數據結構，而數據結構的規則性使得特徵匹配非常適用於硬體設計。例如，基於線段的特徵匹配演算法將場景模型描繪成相互聯結的邊緣線段，而不是區域匹配中的平面模型，因此能很好地處理一些幾何畸變問題，對對比度和明顯的光照變化等相對穩定。特徵匹配由於不直接依賴於灰度，計算量小，比基於區域的匹配演算法速度快的多。且由於邊緣特徵往往出現在視差不連續的區域，特徵匹配較易處理立體視覺匹配中的視差不連續問題。

❽ 求分析 =IF(A5,SUBTOTAL(9,OFFSET(B5,,,-ROW()+LOOKUP(1,0/(A$1:A4<>0),ROW(A$1:A4)))),0) 函數的各步驟

0/(A$1:A4<>0),將判斷單元格區域中的數據是否為0，用0除以判斷結果。0除以TRUE＝0，0/FALSE＝#DIV/0!，返回由0和錯誤值組成的數組。利用LOOKUP忽略錯誤值的特性，巧妙地排除了不符合條件的數據。
ROW(A$1:A4)，是取得A1:A4的行號，相當於數組{1;2;3;4}。不直接用常量數組代替，是為了縮短公式長度。
LOOKUP(1,0/(A$1:A4<>0),ROW(A$1:A4))，在由0和錯誤值組成的數組搜索1，由LOOKUP的匹配演算法，會自動匹配最後個符合條件的數據位置，從而返回對應位置的ROW(A$1:A4)的值。OFFSET(B5,,,-2)，以B5為參照系，偏移0行、0列，取-2個單元格.（即從B5開始，向上取兩個單元格的數據B4:B5)

❾ 想找一個解決兩個字元串匹配程度的演算法。

假設string1="abcde",string2="bcd",則分析邏輯如下：
1. 如果string2長於string1，則不匹配
2. 在string1中順序查匹配string2中第一個字元的字元，
查到後，如果string1餘下的字元串長度小於string2的長度，則不匹配
3. 在上述條件滿足時，將string1的下一個字元和string2中的第二個字元匹配，以此類推，一旦有一個不匹配，則不匹配。回到第2步，查找下一個和string2首字元一致的字元。
4. 如果string2中的字元全都匹配上，則說明string2中string1中識別出來了。