double CLdDlg::Minimum(double a, double b, double c)
{
double mi;

mi = a;
if (b < mi) {
mi = b;
}
if (c < mi) {
mi = c;
}
return mi;
}

double* CLdDlg::GetCellPointer(double *pOrigin, int col, int row, int nCols)
{
return pOrigin + col + (row * (nCols + 1));
}

double CLdDlg::GetAt(double *pOrigin, int col, int row, int nCols)
{
double *pCell;

pCell = GetCellPointer (pOrigin, col, row, nCols);
return *pCell;
}

void CLdDlg::PutAt(double *pOrigin, int col, int row, int nCols, double x)
{
double *pCell;
pCell = GetCellPointer (pOrigin, col, row, nCols);
*pCell = x;
}

@gyn_tadao
不要用转义符，因为按照我说的输入^M的方法后，前面的那个^已经和正则表达式匹配中匹配行首的^不一样了！

不好意思，我没试过，只是今天别人问我时才发现的，她是通过ftp传上去的

Java version
public class Distance {

//****************************
// Get minimum of three values
//****************************

private int Minimum (int a, int b, int c) {
int mi;

mi = a;
if (b < mi) {
mi = b;
}
if (c < mi) {
mi = c;
}
return mi;

}

//*****************************
// Compute Levenshtein distance
//*****************************

public int LD (String s, String t) {
int d[][]; // matrix
int n; // length of s
int m; // length of t
int i; // iterates through s
int j; // iterates through t
char s_i; // ith character of s
char t_j; // jth character of t
int cost; // cost

// Step 1

n = s.length ();
m = t.length ();
if (n == 0) {
return m;
}
if (m == 0) {
return n;
}
d = new int[n+1][m+1];

// Step 2

for (i = 0; i <= n; i++) {
d[i][0] = i;
}

for (j = 0; j <= m; j++) {
d[0][j] = j;
}

// Step 3

for (i = 1; i <= n; i++) {

s_i = s.charAt (i - 1);

// Step 4

for (j = 1; j <= m; j++) {

t_j = t.charAt (j - 1);

// Step 5

if (s_i == t_j) {
cost = 0;
}
else {
cost = 1;
}

// Step 6

d[i][j] = Minimum (d[i-1][j]+1, d[i][j-1]+1, d[i-1][j-1] + cost);

}

}

// Step 7

return d[n][m];

}

}

应该就是这个算法，这个算法是用来训练参数的，主要是求维数比较小(<20)得多元极小化的算法