整合了一些最近做的题

Author: eytter48

Diff for: P72.cpp

@@ -0,0 +1,69 @@
+#include<iostream>
+#include<string>
+#include<algorithm>
+
+using namespace std;
+
+
+class Solution {
+public:
+    int minDistance(string word1, string word2) {
+        int f[100][100][100];
+        int len1,len2,len;
+        string w1,w2;
+        if (word1.length() > word2.length()) {
+            w1=word2;
+            w2=word1;
+        }
+        else {
+            w1=word1;
+            w2=word2;
+        }
+        len1 = w1.length();
+        len2 = w2.length();
+        cout << "length: " << len1 << " " << len2 << endl;
+        cout << "word: " << word1 << " " << word2 << endl;
+        len = max(len1,len2);
+        for (int i=0;i<=len;i++)
+            for (int j=0;j<=len;j++) {
+                for (int k=0;k<=len;k++)
+                    f[i][j][k]=k;
+                if (i<len1 && j<len2 && w1[i]==w2[j])
+                    f[i][j][1]=0;
+            }
+        for (int l=2;l<=len;l++) {
+            for (int i=0;i<len1-l+1;i++)
+                for (int j=0;j<len2-l+1;j++) {
+                    for (int k=0;k<l;k++) {
+                        // transfer
+                        f[i][j][l] = min(f[i][j][l], f[i][j][k] + f[i + k][j + k][l - k]);
+                        // 1. change
+                        f[i][j][l] = min(f[i][j][l], f[i][j][k] + f[i + k + 1][j + k + 1][l - k - 1] + 1);
+                        // 2. del
+                        f[i][j][l] = min(f[i][j][l], f[i][j][k] + f[i + k + 1][j + k][l - k] + 1);
+                        // 3. add has 
+                        f[i][j][l] = min(f[i][j][l], f[i][j][k] + f[i + k][j + k + 1][l - k - 1] + 1);
+                    }
+                }
+
+        }
+        return f[0][0][len2];
+    }
+
+    void test() {
+        string s1("horse"),s2("ros");
+        cout << minDistance(s1, s2) << endl;
+        cout << minDistance("ros", "horse") << endl;
+        cout << minDistance("horse", "ros") << endl;
+        cout << minDistance("ros", "horse") << endl;
+        cout << minDistance("intention", "execution") << endl;
+        cout << minDistance("sea", "ate") << endl;
+        return ;
+    }
+};
+
+int main()
+{
+    Solution().test();
+    return 0;
+}

Diff for: P79.cpp

@@ -0,0 +1,60 @@
+#include<vector>
+#include<iostream>
+#include<cstdlib>
+
+using namespace std;
+
+class Solution {
+public:
+    bool exist(vector<vector<char>>& board, string word) {
+        int m,n;
+        m=board.size();
+        if (m==0) return false;
+        n=board[0].size();
+        if (n==0) return false;
+        for (int i=0; i<m; i++)
+            for (int j=0; j<n; j++)
+                if (word[0]==board[i][j]) {
+                    char c=board[i][j];
+                    board[i][j]= '0';
+                    bool t=test(board,i,j,word,1);
+                    board[i][j]=c;
+                    if (t) return t;
+                }
+        return false;
+    }
+    bool test(vector<vector<char>> &b,int x,int y,const string &word,int l) {
+        if (l>=word.length()) return true;
+        if (b[x][y]!=word[l]) return false;
+        char c=b[x][y];
+        b[x][y]='0';
+        int i,j,m,n;
+        bool t;
+        m=b.size();
+        n=b[0].size();
+        i=x+1;j=y;
+        if (i<m) t=test(b,i,j,word,l+1);
+        if (t) return t;
+
+        i=x;j=y+1;
+        if (j<n) t=test(b,i,j,word,l+1);
+        if (t) return t;
+
+        i=x-1;j=y;
+        if (i>=0) t=test(b,i,j,word,l+1);
+        if (t) return t;
+
+        i=x;j=y-1;
+        if (j>=0) t=test(b,i,j,word,l+1);
+        if (t) return t;
+        b[x][y]=c;
+        return false;
+    }
+};
+
+
+int main() {
+    vector<vector<char>> b={{'A','B','C','E'},{'S','F','C','S'},{'A','D','E','E'}};
+    cout << Solution().exist(b,"ABCCED");
+    return 0;
+}

Diff for: P80.cpp

@@ -0,0 +1,28 @@
+#include<vector>
+#include<iostream>
+
+using namespace std;
+
+class Solution {
+public:
+    int removeDuplicates(vector<int>& nums) {
+        int i=1;
+        while (i+1<nums.size()) {
+            if (nums[i-1]==nums[i] && nums[i]==nums[i+1]) {
+                nums.erase(nums.begin()+i);
+            }
+            else 
+                i++;
+        }
+        return nums.size();
+    }
+};
+
+int main() {
+    vector<int> a={1,1,1,1,1,2,2,2,2,3,3,3,4,4,5};
+    int len=Solution().removeDuplicates(a);
+    for (int i=0;i<len;i++)
+        cout<<a[i]<<" ";
+    cout<<endl;
+    return 0;
+}

Diff for: P81.cpp

@@ -0,0 +1,59 @@
+#include<iostream>
+#include<algorithm>
+#include<vector>
+#include<cstdlib>
+
+using namespace std;
+
+class Solution {
+public:
+	bool search(vector<int>& nums, int target) {
+		if (nums.size() == 0) return false;
+		return srch(nums.begin(), nums.end(), target);
+	}
+	bool srch(vector<int>::iterator beg, vector<int>::iterator end, int target) {
+		vector<int>::iterator l, r, m, p;
+		l = beg;
+		r = end-1;
+		// at beginning, a[r]<=a[l]
+		// [l, r]   [beg, end)
+		while (l <= r)
+		{
+			m = l + (r - l) / 2;
+			if (*m == target) return true;
+			if (*l < *m) {
+				p = search_n(l, m, 1, target);
+				if (p != m) return true;
+				l = m + 1;
+			}
+			else if (*l != *m) { //l>m
+				p = search_n(m, r + 1, 1, target);
+				if (p != r + 1) return true;
+				r = m - 1;
+			}
+			else if (*m == *r) {
+				auto k = srch(l, m, target);
+				if (k) return k;
+				k = srch(m + 1, r+1, target);
+				if (k) return k;
+				return false;
+			}
+			else if (*m > * r) {
+				l = m + 1;
+			}
+			else {
+				//cout << "???????ERR????" << endl;
+				p = search_n(l, r + 1, 1, target);
+				if (p != r + 1) return true;
+				return false;
+			}
+		}
+		return false;
+	}
+};
+
+int main() {
+    vector<int> nums={2,5,6,0,0,1,2};
+    cout<< Solution().search(nums,3) << endl;
+    return 0;
+}

Diff for: P82.cpp

@@ -0,0 +1,42 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* deleteDuplicates(ListNode* head) {
+        ListNode* p, *prev = nullptr;
+		if (head==nullptr || head->next==nullptr) return head;
+		auto v=head->val;
+
+		prev = nullptr;
+		p = head;
+		while (p!=nullptr) {
+			if (p->next!=nullptr && p->val==p->next->val) {
+				v = p->val;
+				while (p!=nullptr && p->val==v) {
+					if (prev!=nullptr) {
+						prev->next=p->next;
+						free(p);
+						p=p->next;
+					}
+					else {
+						head=head->next;
+						free(p);
+						p=head;
+					}
+				}
+			}
+			else {
+				prev=p;
+				p=p->next;
+			}	
+		}
+		return head;
+    }
+
+};

Diff for: P83.cpp

@@ -0,0 +1,22 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* deleteDuplicates(ListNode* head) {
+        ListNode *p;
+		p=head;
+		while (p!=nullptr) {
+			if (p->next!=nullptr && p->val==p->next->val) 
+				p->next=p->next->next;
+			else 
+				p=p->next;
+		}
+		return head;
+    }
+};

Diff for: P84.cpp

@@ -0,0 +1,88 @@
+#include "mhead.h"
+
+using namespace std;
+
+class Solution {
+public:
+    int maximalRectangle(vector<vector<char>>& matrix) {
+        int m=matrix.size();
+        if (m==0) return 0;
+        int n=matrix[0].size();
+        if (n==0) return 0;
+
+        int **f = new int *[m];
+        for (int i=0;i<m;i++) f[i]=new int[n];
+        for (int i=0;i<m;i++)
+            for (int j=0;j<n;j++) f[i][j]=matrix[i][j]-'0';
+
+
+                int s1,s2;
+                for (int i=0;i<m;i++)
+                for (int j=0;j<n;j++) {
+                for (int ri=0;ri<m;ri++)
+                for (int rj=0;rj<n;rj++)
+                    {
+                        int x=i+ri,y=j+rj;
+                        if (x==i && y==j) continue;
+                        if (x>=m || y>=n) continue;
+                        if (matrix[x][y]==0) {
+                            f[x][y]=f[x-1][y-1];
+                            continue;
+                        }
+                        s1=0;
+                        if (ri>0 && y-1>=0) {
+                            for (int k=i;k<=x-1;k++) s1+=matrix[k][y];
+                            if (s1==x-i) {
+                                if (f[x-1][y-1]==(ri)*(rj))
+                                    f[x-1][y] = max(f[x-1][y],f[x-1][y-1]+s1);
+                                else
+                                    f[x-1][y] = max(f[x-1][y],s1);
+                            }
+                            else
+                                f[x-1][y] = max(f[x-1][y],f[x-1][y-1]);
+                        }
+                        s2=0;
+                        if (rj>0 && x-1>=0) {
+                            for (int k=j;k<=y-1;k++) s2+=matrix[x][k];
+                            if (s2==y-j) {
+                                if (f[x-1][y-1]==(ri)*(rj))
+                                    f[x][y-1] = max(f[x][y-1],f[x-1][y-1]+s2);
+                                else
+                                    f[x][y-1] = max(f[x][y-1],s2);
+                            }
+                            else
+                                f[x][y-1] = max(f[x][y-1],f[x-1][y-1]);
+                        }
+                        if (ri>0 && rj>0) {
+                            if (s1==x-i && s2==y-j) {
+                                if (f[x-1][y-1]==ri*rj)
+                                    f[x][y] = max(f[x][y],f[x-1][y-1]+s1+s2+1);
+                                else
+                                    f[x][y] = max(f[x][y],max(s1,s2)+1);
+                            }
+                            else
+                                f[x][y] = max(f[x][y],f[x-1][y-1]);
+                        }
+                    }
+                    for (int i1=0;i1<m;i1++) {
+                        for (int i2=0;i2<n;i2++)
+                            cout << f[i1][i2] << " ";
+                        cout << endl;
+                    }
+                    cout << i << " : "<< j << endl;
+                }
+        return f[m-1][n-1];
+
+    }
+    void SolutionTest() {
+        vector<vector<char>> a={
+  {'1','0','1','0','0'},
+  {'1','0','1','1','1'},
+  {'1','1','1','1','1'},
+  {'1','0','0','1','0'}
+};
+        auto k = maximalRectangle(a);
+        cout<<k<<endl;
+        return;
+    }
+};