HDU 4323 bk樹 編輯距離
阿新 • • 發佈：2019-01-27
除了字串匹配、查找回文串、查詢重複子串等經典問題以外，日常生活中我們還會遇到其它一些怪異的字串問題。比如，有時我們需要知道給定的兩個字串“有多像”，換句話說兩個字串的相似度是多少。1965年，俄國科學家Vladimir Levenshtein給字串相似度做出了一個明確的定義叫做Levenshtein距離，我們通常叫它“編輯距離”。字串A到B的編輯距離是指，只用插入、刪除和替換三種操作，最少需要多少步可以把A變成B。例如，從FAME到GATE需要兩步（兩次替換），從GAME到ACM則需要三步（刪除G和E再新增C）。Levenshtein給出了編輯距離的一般求法，就是大家都非常熟悉的經典動態規劃問題。
在自然語言處理中，這個概念非常重要，例如我們可以根據這個定義開發出一套半自動的校對系統：查找出一篇文章裡所有不在字典裡的單詞，然後對於每個單詞，列出字典裡與它的Levenshtein距離小於某個數n的單詞，讓使用者選擇正確的那一個。n通常取到2或者3，或者更好地，取該單詞長度的1/4等等。這個想法倒不錯，但演算法的效率成了新的難題：查字典好辦，建一個Trie樹即可；但怎樣才能快速在字典裡找出最相近的單詞呢？這個問題難就難在，Levenshtein的定義可以是單詞任意位置上的操作，似乎不遍歷字典是不可能完成的。現在很多軟體都有拼寫檢查的功能，提出更正建議的速度是很快的。它們到底是怎麼做的呢？1973年，Burkhard和Keller提出的BK樹有效地解決了這個問題。這個資料結構強就強在，它初步解決了一個看似不可能的問題，而其原理非常簡單。
首先，我們觀察Levenshtein距離的性質。令d(x,y)表示字串x到y的Levenshtein距離，那麼顯然：
1. d(x,y) = 0 當且僅當 x=y （Levenshtein距離為0 <==> 字串相等）
2. d(x,y) = d(y,x) （從x變到y的最少步數就是從y變到x的最少步數）
3. d(x,y) + d(y,z) >= d(x,z) （從x變到z所需的步數不會超過x先變成y再變成z的步數）
最後這一個性質叫做三角形不等式。就好像一個三角形一樣，兩邊之和必然大於第三邊。給某個集合內的元素定義一個二元的“距離函式”，如果這個距離函式同時滿足上面說的三個性質，我們就稱它為“度量空間”。我們的三維空間就是一個典型的度量空間，它的距離函式就是點對的直線距離。度量空間還有很多，比如Manhattan距離，圖論中的最短路，當然還有這裡提到的Levenshtein距離。就好像並查集對所有等價關係都適用一樣，BK樹可以用於任何一個度量空間。
建樹的過程有些類似於Trie。首先我們隨便找一個單詞作為根（比如GAME）。以後插入一個單詞時首先計算單詞與根的Levenshtein距離：如果這個距離值是該節點處頭一次出現，建立一個新的兒子節點；否則沿著對應的邊遞迴下去。例如，我們插入單詞FAME，它與GAME的距離為1，於是新建一個兒子，連一條標號為1的邊；下一次插入GAIN，算得它與GAME的距離為2，於是放在編號為2的邊下。再下次我們插入GATE，它與GAME距離為1，於是沿著那條編號為1的邊下去，遞迴地插入到FAME所在子樹；GATE與FAME的距離為2，於是把GATE放在FAME節點下，邊的編號為2。
查詢操作異常方便。如果我們需要返回與錯誤單詞距離不超過n的單詞，這個錯誤單詞與樹根所對應的單詞距離為d，那麼接下來我們只需要遞迴地考慮編號在d-n到d+n範圍內的邊所連線的子樹。由於n通常很小，因此每次與某個節點進行比較時都可以排除很多子樹。
舉個例子，假如我們輸入一個GAIE，程式發現它不在字典中。現在，我們想返回字典中所有與GAIE距離為1的單詞。我們首先將GAIE與樹根進行比較，得到的距離d=1。由於Levenshtein距離滿足三角形不等式，因此現在所有離GAME距離超過2的單詞全部可以排除了。比如，以AIM為根的子樹到GAME的距離都是3，而GAME和GAIE之間的距離是1，那麼AIM及其子樹到GAIE的距離至少都是2。於是，現在程式只需要沿著標號範圍在1-1到1+1裡的邊繼續走下去。我們繼續計算GAIE和FAME的距離，發現它為2，於是繼續沿標號在1和3之間的邊前進。遍歷結束後回到GAME的第二個節點，發現GAIE和GAIN距離為1，輸出GAIN並繼續沿編號為1或2的邊遞迴下去（那條編號為4的邊連線的子樹又被排除掉了）……
實踐表明，一次查詢所遍歷的節點不會超過所有節點的5%到8%，兩次查詢則一般不會17-25%，效率遠遠超過暴力列舉。適當進行快取，減小Levenshtein距離常數n可以使演算法效率更高。
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<iostream>
#include<vector>
#include<string>
#include<math.h>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<algorithm>
using namespace std;
int dp[40][40];
char s1[100], s2[100], st[10010][30];
const int inf = 0x7f7f7f7f;
//資料結構定義
struct node
{
char word[30]; //當前結點值
node *next[30];
}root;
node p[100000];
int num, flag, vnum, fuck;
map<string,int>mp;
int f[100000];
void init( )
{
for( int i = 0; i < 40; i++)
for( int j = 0; j < 40; j++)
dp[i][j] = inf;
}
int diff( char *s1, char *s2)
{
init();
int x = strlen(s1+1);
int y = strlen(s2+1);
for( int i = 0; i <= x; i++)
dp[i][0] = i;
for( int j = 0; j <= y; j++)
dp[0][j] = j;
for( int i = 1; i <= x; i++)
{
for( int j = 1; j <= y; j++)
{
dp[i][j] = min(min(dp[i-1][j]+1, dp[i][j-1]+1), dp[i-1][j-1]+ !(s1[i]==s2[j]) );
}
}
return dp[x][y];
}
//建樹
void insert(node *q, char *str)
{
node *l = q;
while( l )
{
int dis = diff( l->word, str);
if( ! l->next[dis] )
{
l->next[dis] = &p[num++];
strcpy(l->next[dis]->word + 1, str + 1);
break;
}
l = l->next[dis];
}
}
//查詢與單詞相差不大於d的單詞
void sfind(node *q, char *str, int d)
{
if( flag )
return ;
node *l = q;
if( l == NULL )
return;
int dis = diff(str, l->word);
if( dis <= d )
{
fuck++;
}
for( int x = dis-d; x <= dis+d; x++)
{
if( x >= 0 && x <= 20 && l->next[x] )
sfind(l->next[x], str, d);
}
}
int main( )
{
int N, M, d, cnt, T, abc = 1;
char str[1000];
scanf("%d",&T);
while( T-- )
{
scanf("%d%d",&N,&M);
memset(p,0,sizeof(p));
for( int i = 0; i < 30; i++)
root.next[i] = NULL;
num = 0;
int cnum = 1;
strcpy(st[0] + 1, root.word+1);
for( int i = 1; i <= N; i++)
{
scanf("%s",st[i]+1);
insert(&root, st[i]);
}
d = 1;
printf("Case #%d:\n", abc++);
for( int i = 1; i <= M; i++)
{
vnum = 0;
flag = 0;
fuck = 0;
scanf("%s%d",str+1, &d);
sfind(&root, str, d);
printf("%d\n", fuck);
}
}
return 0;
}自己寫的版本，比較容易理解
#include <iostream>
#include <vector>
#include <string>
#include <fstream>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <sstream>
#include <set>
#include <algorithm>
using namespace std;
#define MAXEDIT 15
class node {
public:
string word;
node *next[MAXEDIT];
node() {
memset(next, 0, sizeof(next));
}
};
string split(const string& str) {
size_t pos = str.find(" ||| ");
return str.substr(0, pos);
}
bool isalpha(const string& str) {
for (int i = 0; i < str.size(); ++i) {
if (!(str[i]>='a' && str[i] <='z' || str[i]>='A' && str[i] <='Z' )) return false;
}
return true;
}
int minTri(int a, int b, int c) {
int rst = a;
if (rst > b) rst = b;
if (rst > c) rst = c;
return rst;
}
int editDist(const string &str1, const string &str2) {
vector<vector<int> > mat(str1.size() + 1, vector<int>(str2.size() +1, 0));
for (int i = 1; i < str1.size(); ++i) mat[i][0] = i;
for (int i = 1; i < str2.size(); ++i) mat[0][i] = i;
for (int i = 1; i <= str1.size(); ++i) {
for (int j = 1; j <= str2.size(); ++j) {
int cost = 1;
if (str1[i-1] == str2[j-1]) cost = 0;
mat[i][j] = minTri(mat[i-1][j-1]+cost, mat[i-1][j] + 1, mat[i][j-1] + 1);
}
}
return mat[str1.size()][str2.size()];
}
void insert(node* head, const string& str) {
node *tmp = head;
while (tmp) {
int dis = editDist(tmp->word, str);
if (dis == 0 || dis >= MAXEDIT) return;
if (tmp->next[dis]) tmp = tmp->next[dis];
else {
tmp->next[dis] = new node();
tmp->next[dis]->word = str;
break;
}
}
}
void buildKDTree(node *head, const vector<string>& ls) {
for (int i = 0; i < ls.size(); ++i) {
insert(head, ls[i]);
}
}
void freeKDTree(node* head) {
for (int i = 0; i < MAXEDIT; ++i) {
if (head->next[i]) {
freeKDTree(head->next[i]);
delete head->next[i];
head->next[i] = NULL;
}
}
}
void findN(node *head, const string & str,vector<pair<string,int> >& rst, int n) {
int d = editDist(head->word, str);
if (d <= n && d != 0) {
rst.push_back(make_pair(head->word,d));
}
int minR = max(1, d - n);
int maxR = min(MAXEDIT-1, d + n);
for (int i = minR; i <= maxR; ++i) {
if (head->next[i]) {
findN(head->next[i], str, rst, n);
}
}
}
bool Cmp(const pair<string, int>& p1, const pair<string, int> &p2) {
return p1.second < p2.second;
}
int main(int argc, char *argv[]) {
if (argc != 3) {
cout << "input output"<<endl;
return -1;
}
ifstream fin(argv[1]);
ofstream fo(argv[2]);
string line;
set<string> st;
while(getline(fin, line)) {
string word = split(line);
if (isalpha(word) && word.size() > 1)
st.insert(word);
}
vector<string> ls(st.size());
set<string>::iterator it = st.begin();
int i = 0;
for(; it != st.end(); ++it)
ls[i++] = *it;
node head;
head.word = ls[0];
buildKDTree(&head, ls);
for (i = 0; i < ls.size();++i) {
if ((i+1)%5000 ==0) cout << i+1<<endl;
vector<pair<string, int> > rst;
int dist = min((int)ls[i].size()/2, 3);
findN(&head, ls[i], rst, dist);
ostringstream ostr;
ostr<<ls[i]<<"\t";
sort(rst.begin(), rst.end(), Cmp);
for (int j = 0; j < rst.size(); ++j) {
ostr<<rst[j].first<<" ";
}
fo<<ostr.str()<<endl;
}
freeKDTree(&head);
fin.close();
fo.close();
system("pause");
return 0;
}實際效果比之前寫的多執行緒暴力慢多了.......