bk

Author: hbsun2113

0001.two-sum/two-sum.md

@@ -1,14 +1,12 @@
-<p>Given an array of integers, return <strong>indices</strong> of the two numbers such that they add up to a specific target.</p>
-
-<p>You may assume that each input would have <strong><em>exactly</em></strong> one solution, and you may not use the <em>same</em> element twice.</p>
-
-<p><strong>Example:</strong></p>
-
-<pre>
-Given nums = [2, 7, 11, 15], target = 9,
-
-Because nums[<strong>0</strong>] + nums[<strong>1</strong>] = 2 + 7 = 9,
-return [<strong>0</strong>, <strong>1</strong>].
-</pre>
-
-<p>&nbsp;</p>
+<p>Given an array of integers, return <strong>indices</strong> of the two numbers such that they add up to a specific target.</p>
+
+<p>You may assume that each input would have <strong><em>exactly</em></strong> one solution, and you may not use the <em>same</em> element twice.</p>
+
+<p><strong>Example:</strong></p>
+
+<pre>
+Given nums = [2, 7, 11, 15], target = 9,
+
+Because nums[<strong>0</strong>] + nums[<strong>1</strong>] = 2 + 7 = 9,
+return [<strong>0</strong>, <strong>1</strong>].
+</pre>

0024.swap-nodes-in-pairs/swap-nodes-in-pairs.cpp

@@ -1,80 +1,90 @@
-/*
- * @lc app=leetcode id=24 lang=cpp
- *
- * [24] Swap Nodes in Pairs
- *
- * https://leetcode.com/problems/swap-nodes-in-pairs/description/
- *
- * algorithms
- * Medium (43.65%)
- * Total Accepted:    294.1K
- * Total Submissions: 672.2K
- * Testcase Example:  '[1,2,3,4]'
- *
- * Given a linked list, swap every two adjacent nodes and return its head.
- * 
- * You may not modify the values in the list's nodes, only nodes itself may be
- * changed.
- * 
- * 
- * 
- * Example:
- * 
- * 
- * Given 1->2->3->4, you should return the list as 2->1->4->3.
- * 
- * 
- */
-/**
- * Definition for singly-linked list.
- * struct ListNode {
- *     int val;
- *     ListNode *next;
- *     ListNode(int x) : val(x), next(NULL) {}
- * };
- */
-class Solution {
-public:
-    // 迭代，注意我们转移指针的时候不会跳跃。如果跳跃，我觉得应该是有问题，或者说没有写好。
-    ListNode* swapPairs(ListNode* head) {
-        ListNode* newhead=new ListNode(-100);
-        newhead->next=head;
-        ListNode *pre=newhead;
-        while(pre){
-            ListNode* f=pre->next;
-            if(!f) return newhead->next;
-
-            ListNode* s=f->next;
-            if(!s) return newhead->next;
-
-            pre->next=s;
-            f->next=s->next;
-            s->next=f;
-
-            pre=f;
-        }
-        return newhead->next;
-
-
-
-
-    }
-
-
-
-    // 递归做法
-    ListNode* swapPairs1(ListNode* head) {
-        if(!head) return head;
-        ListNode* s=head->next;
-        if(!s) return head;
-        if(!s->next){// 处理最后两个节点。
-            head->next=nullptr;
-            s->next=head;
-            return s;
-        }
-        head->next=swapPairs(s->next);
-        s->next=head;
-        return s;
-    }
-};
-
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    
+    // 迭代版
+    ListNode* swapPairs(ListNode* head) {
+        ListNode* dummy=new ListNode(INT_MIN);
+        dummy->next=head;
+        
+        auto cur=dummy;
+        while(cur){
+            auto son=cur->next;
+            if(!son) break;
+            
+            auto grand=son->next;
+            if(!grand) break;
+            
+            cur->next=grand;
+            son->next=grand->next;
+            grand->next=son;
+            
+            cur=son;
+        }
+        
+        return dummy->next;
+    }
+    
+    
+    // 递归版
+    ListNode* swapPairs1(ListNode* f) {
+        if(!f || !f->next) return f;
+        auto s=f->next;
+        auto tail=swapPairs(s->next);
+        s->next=f;
+        f->next=tail;
+        return s;
+    }
+    
+    
+    /*
+    // 迭代，注意我们转移指针的时候不会跳跃。如果跳跃，我觉得应该是有问题，或者说没有写好。
+    ListNode* swapPairs(ListNode* head) {
+        ListNode* newhead=new ListNode(-100);
+        newhead->next=head;
+        ListNode *pre=newhead;
+        while(pre){
+            ListNode* f=pre->next;
+            if(!f) return newhead->next;
+
+            ListNode* s=f->next;
+            if(!s) return newhead->next;
+
+            pre->next=s;
+            f->next=s->next;
+            s->next=f;
+
+            pre=f;
+        }
+        return newhead->next;
+
+
+
+
+    }
+
+
+
+    // 递归做法
+    ListNode* swapPairs1(ListNode* head) {
+        if(!head) return head;
+        ListNode* s=head->next;
+        if(!s) return head;
+        if(!s->next){// 处理最后两个节点。
+            head->next=nullptr;
+            s->next=head;
+            return s;
+        }
+        head->next=swapPairs(s->next);
+        s->next=head;
+        return s;
+    }
+    */
+};

0044.wildcard-matching/wildcard-matching.c

@@ -0,0 +1,34 @@
+//https://leetcode.com/problems/wildcard-matching/discuss/17810/Linear-runtime-and-constant-space-solution
+//这道题目还没有完全理解
+bool isMatch(char* s, char* p) {
+        char *ps=s;
+        char *pp=p;
+        char *fs=ps;
+        char *fp=NULL;
+        while(*ps){  //注意是*ps，不是ps
+            printf("%c %c\n",*ps,*pp);
+            if((*pp=='?') || (*ps==*pp)){
+                pp++;
+                ps++;
+                continue;
+            }
+            
+            if(*pp=='*'){
+                fp=pp++;
+                fs=ps;
+                continue;
+            }
+            
+            if(fp){
+                pp=fp+1;
+                ps=++fs;
+                continue;
+            }
+            
+            return false;
+            
+        }
+        while(*pp=='*') pp++;
+        
+        return !(*pp);
+}

0045.jump-game-ii/jump-game-ii.cpp

@@ -1,52 +1,29 @@
-/*
- * @lc app=leetcode id=45 lang=cpp
- *
- * [45] Jump Game II
- *
- * https://leetcode.com/problems/jump-game-ii/description/
- *
- * algorithms
- * Hard (27.66%)
- * Total Accepted:    159.5K
- * Total Submissions: 576.1K
- * Testcase Example:  '[2,3,1,1,4]'
- *
- * Given an array of non-negative integers, you are initially positioned at the
- * first index of the array.
- * 
- * Each element in the array represents your maximum jump length at that
- * position.
- * 
- * Your goal is to reach the last index in the minimum number of jumps.
- * 
- * Example:
- * 
- * 
- * Input: [2,3,1,1,4]
- * Output: 2
- * Explanation: The minimum number of jumps to reach the last index is 2.
- * ⁠   Jump 1 step from index 0 to 1, then 3 steps to the last index.
- * 
- * Note:
- * 
- * You can assume that you can always reach the last index.
- * 
- */
-class Solution {
-public:
-    // https://www.cnblogs.com/lichen782/p/leetcode_Jump_Game_II.html
-    int jump(vector<int>& nums) {
-        int last=0;
-        int curr=0;
-        int step=0;
-        for(int i=0;i<nums.size();i++){
-            if(i>last){
-                last=curr;
-                step++;
-            }
-            curr=max(curr,i+nums[i]);
-        }
-        return step;
-    }
-};
-
+class Solution {
+public:
+    // https://www.cnblogs.com/lichen782/p/leetcode_Jump_Game_II.html
+    int jump1(vector<int>& nums) {
+        int last=0;
+        int curr=0;
+        int step=0;
+        for(int i=0;i<nums.size();i++){
+            if(i>last){
+                last=curr;
+                step++;
+            }
+            curr=max(curr,i+nums[i]);
+        }
+        return step;
+    }
+    
+    // https://www.acwing.com/solution/LeetCode/content/107/
+    int jump(vector<int>& nums) {
+        vector<int> dp(nums.size());
+        int last=0;
+        for(int i=1;i<dp.size();i++){
+            while(i>last+nums[last]) last++;
+            dp[i]=dp[last]+1;
+        }
+        return dp.back();
+    }
+};
+

0054.spiral-matrix/spiral-matrix.cpp

@@ -1,5 +1,31 @@
 class Solution {
 public:
+    // 做得不是很流畅
+    vector<int> spiralOrder(vector<vector<int>>& matrix) {
+        vector<int> res;
+        row=matrix.size();
+        if(row==0) return res;
+        col=matrix[0].size();
+        vector<vector<bool>> vis(row,vector<bool>(col,false));
+        
+        int k=0;
+        int x=0,y=0;
+        
+        while(res.size()!=row*col){
+            res.push_back(matrix[x][y]);
+            if(res.size()==row*col) break;
+            vis[x][y]=true;
+            while(x+dx[k]<0 || x+dx[k]>=row || y+dy[k]<0 || y+dy[k]>=col || vis[x+dx[k]][y+dy[k]]){
+                k++;
+                k%=4;
+            }
+            x=x+dx[k];
+            y=y+dy[k];
+            
+        }
+        return res;
+    }
+    
 
     // 三刷，自己做出来了
     // 更简洁的做法,没有while，只有if：https://www.acwing.com/solution/acwing/content/748/
@@ -9,7 +35,7 @@ class Solution {
     vector<int> dy={1,0,-1,0};
     vector<int> res;
     int k=0;
-    vector<int> spiralOrder(vector<vector<int> > matrix) {
+    vector<int> spiralOrder3(vector<vector<int> > matrix) {
 
         row=matrix.size();
         if(row==0) return res;

0055.jump-game/jump-game.cpp

@@ -1,14 +1,11 @@
 class Solution {
 public:
-    // 三刷，做出来了
-    // 注意：如果当前节点可以到达，则它之前所有的节点都是可以的到达的。
     bool canJump(vector<int>& nums) {
-        int maxd=0;
+        int mv=0;
         for(int i=0;i<nums.size();i++){
-            if(maxd<i) return false;
-            maxd=max(maxd,i+nums[i]);
+            if(mv<i) return false;
+            mv=max(mv,i+nums[i]);
         }
         return true;
-        
     }
 };