Merge pull request #70 from lixiaoyu0123/master

leetcode46

Author: Lmonster

README.md

@@ -263,7 +263,7 @@ Output: [3,5]
 > 1. The order of the result is not important. So in the above example, [5, 3] is also correct.
 > 2. Your algorithm should run in linear runtime complexity. Could you implement it using only constant space complexity?
 
-46. ***【Edit Distance】*** Given two words word1 and word2, find the minimum number of operations required to convert word1 to word2.
+46. ***[【Edit Distance】](./doc/Leetcode46/Leetcode46.md)*** Given two words word1 and word2, find the minimum number of operations required to convert word1 to word2.
 You have the following 3 operations permitted on a word:
     1. Insert a character
     2. Delete a character

code/Leetcode46/edit_dist_dp.cpp

@@ -0,0 +1,38 @@
+#include <vector>
+#include <algorithm> 
+#include "edit_dist_dp.h"
+
+int editDistDp(const std::string &word1, const std::string &word2) {
+    int m = word1.length();
+    int n = word2.length();
+
+    // 有一个字符串为空串
+    if (m * n == 0){
+        return m + n;
+    } 
+
+    // DP 数组
+    std::vector<std::vector<int> > dp((m + 1),std::vector<int>(n + 1));
+
+    // 边界状态初始化
+    for (int i = 0; i < m + 1; i++) {
+		dp[i][0] = i;
+    }
+    for (int j = 0; j < n + 1; j++) {
+		dp[0][j] = j;
+    }
+
+    // 计算所有 DP 值
+	for (int i = 1; i <= m; i++) {
+		for (int j = 1; j <= n; j++) {
+			if (word1[i - 1] == word2[j - 1]) {
+				dp[i][j] = dp[i - 1][j - 1];
+			}else {
+				dp[i][j] = 1 + std::min(dp[i - 1][j],
+					std::min(dp[i][j - 1],
+						dp[i - 1][j - 1]));
+			}
+		}
+	}
+    return dp[m][n];
+}

code/Leetcode46/edit_dist_dp.h

@@ -0,0 +1,3 @@
+#include <string>
+
+int editDistDp(const std::string &word1, const std::string &word2);

code/Leetcode46/edit_dist_dp_best.cpp

@@ -0,0 +1,43 @@
+#include <vector>
+#include <algorithm> 
+#include "edit_dist_dp_best.h"
+
+int editDistDpBest(const std::string &word1, const std::string &word2){ 
+    int m = word1.length(); 
+    int n = word2.length(); 
+
+	if (m * n == 0) {
+		return m + n;
+	}
+  
+	std::vector<std::vector<int> > dp((2), std::vector<int>(n + 1));
+  
+	int iSize = dp.size();
+	for (int i = 0; i < iSize; i++) {
+		int jSize = dp[i].size();
+		for (int j = 0; j < jSize; j++) {
+			dp[i][j] = 0;
+		}
+	}
+
+	//³õʼ»¯i=0µÄÒ»ÐÐÖµ
+    for (int i = 0; i <= n; i++){
+		dp[0][i] = i;
+    }
+
+	for (int i = 1; i <= m; i++) {
+		for (int j = 0; j <= n; j++) {
+			if (j == 0) {
+				dp[i % 2][j] = i;
+			}else if (word1[i - 1] == word2[j - 1]) {
+				dp[i % 2][j] = dp[(i - 1) % 2][j - 1];
+			}else {
+				dp[i % 2][j] = 1 + std::min(dp[(i - 1) % 2][j],
+					std::min(dp[i % 2][j - 1],
+						dp[(i - 1) % 2][j - 1]));
+			}
+		}
+	}
+  
+    return dp[m % 2][n];
+}

code/Leetcode46/edit_dist_dp_best.h

@@ -0,0 +1,3 @@
+#include <string>
+
+int editDistDpBest(const std::string &word1, const std::string &word2);

code/Leetcode46/edit_dist_recursion.cpp

@@ -0,0 +1,40 @@
+#include <algorithm> 
+#include "edit_dist_recursion.h"
+
+int editDistRecursion(const std::string &word1, const std::string &word2) {
+	return editDist(word1, word2, word1.size(), word2.size());
+}
+
+static int min(int x, int y, int z)
+{
+	return std::min(std::min(x, y), z);
+}
+
+
+int editDist(const std::string &word1 , const std::string &word2, int m, int n) { 
+    // If first string is empty, the only option is to 
+    // insert all characters of second string into first 
+    if (m == 0){
+        return n;
+    }		
+  
+    // If second string is empty, the only option is to 
+    // remove all characters of first string 
+    if (n == 0){ 
+        return m; 
+    }
+    // If last characters of two strings are same, nothing 
+    // much to do. Ignore last characters and get count for 
+    // remaining strings. 
+    if (word1[m - 1] == word2[n - 1]) {
+        return editDist(word1, word2, m - 1, n - 1);
+    }
+    // If last characters are not same, consider all three 
+    // operations on last character of first string, recursively 
+    // compute minimum cost for all three operations and take 
+    // minimum of three values. 
+    return 1 + min(editDist(word1, word2, m, n - 1), // Insert 
+		editDist(word1, word2, m - 1, n), // Remove 
+		editDist(word1, word2, m - 1, n - 1) // Replace 
+        ); 
+}

code/Leetcode46/edit_dist_recursion.h

@@ -0,0 +1,5 @@
+#include <string>
+
+int editDistRecursion(const std::string &word1 , const std::string &word2);
+
+int editDist(const std::string &word1, const std::string &word2, int m, int n);

code/Leetcode46/main.cpp

@@ -0,0 +1,37 @@
+#include <stdlib.h>
+#include <string>
+#include <chrono>
+#include <iostream>
+#include "edit_dist_recursion.h"
+#include "edit_dist_dp.h"
+#include "edit_dist_dp_best.h"
+
+int main(int argc, char* argv[]){
+	if (argc < 4) {
+		std::cout << "parameter count is error!\n";
+		return -1;
+	}
+
+	std::string word1(argv[1]);
+	std::string word2(argv[2]);
+	std::string way(argv[3]);
+	int dist = 0;
+	auto beginTime = std::chrono::high_resolution_clock::now();
+
+	if (way == "recursion") {
+		dist = editDistRecursion(word1, word2);
+	}else if (way == "dp") {
+		dist = editDistDp(word1, word2);
+	}else if (way == "dp_best") {
+		dist = editDistDpBest(word1, word2);
+	}else {
+		std::cout << "parameter is err!\n";
+		return -1;
+	}
+	auto endTime = std::chrono::high_resolution_clock::now();
+	auto elapsedTime = std::chrono::duration_cast<std::chrono::microseconds>(endTime - beginTime);
+	std::cout << "elapsed time is " << elapsedTime.count() << " microseconds" << std::endl;
+
+	std::cout<< "the min eidt distance is:" << dist << "\n";
+    return 0;
+}