bk

Author: hbsun2113

0068.text-justification/text-justification.cpp

@@ -0,0 +1,36 @@
+class Solution {
+public:
+    // https://www.cnblogs.com/grandyang/p/4350381.html 的思想
+    // https://leetcode.com/problems/text-justification/discuss/24873/Share-my-concise-c++-solution-less-than-20-lines 中 @rpfly3的回答
+    vector<string> fullJustify(vector<string>& words, int maxWidth) {
+        vector<string> res;
+        int n=words.size();
+        int cur_width=0;
+        int j;
+        for(int i=0;i<n;i=j){
+            
+            for(j=i,cur_width=0;j<n && cur_width+words[j].size()+j-i<=maxWidth;j++)
+                cur_width+=words[j].size();
+            
+            // 这是为了最后一行准备的默认值
+            int space=1;
+            int extra=0;
+            
+            if(j-1!=i && j!=words.size()){
+                space=(maxWidth-cur_width)/(j-i-1); // j-i-1 是空的数目，space是空的大小
+                extra=(maxWidth-cur_width)%(j-i-1);
+            }
+            // cout<<words[i]<<" "<<words[j-1]<<" "<<space<<" "<<extra<<endl;
+            
+            string line="";
+            for(int k=i;k<j;k++){
+                line+=words[k];
+                if(k!=j-1) line+=string(space, ' ');
+                if(extra-->0) line+=' ';
+            }
+            line += string(maxWidth - line.size(), ' ');
+            res.push_back(line);
+        }
+        return res;
+    }
+};

0068.text-justification/text-justification.md

@@ -0,0 +1,64 @@
+<p>Given an array of words and a width&nbsp;<em>maxWidth</em>, format the text such that each line has exactly <em>maxWidth</em> characters and is fully (left and right) justified.</p>
+
+<p>You should pack your words in a greedy approach; that is, pack as many words as you can in each line. Pad extra spaces <code>&#39; &#39;</code> when necessary so that each line has exactly <em>maxWidth</em> characters.</p>
+
+<p>Extra spaces between words should be distributed as evenly as possible. If the number of spaces on a line do not divide evenly between words, the empty slots on the left will be assigned more spaces than the slots on the right.</p>
+
+<p>For the last line of text, it should be left justified and no <strong>extra</strong> space is inserted between words.</p>
+
+<p><strong>Note:</strong></p>
+
+<ul>
+	<li>A word is defined as a character sequence consisting&nbsp;of non-space characters only.</li>
+	<li>Each word&#39;s length is&nbsp;guaranteed to be greater than 0 and not exceed <em>maxWidth</em>.</li>
+	<li>The input array <code>words</code>&nbsp;contains at least one word.</li>
+</ul>
+
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong>
+words = [&quot;This&quot;, &quot;is&quot;, &quot;an&quot;, &quot;example&quot;, &quot;of&quot;, &quot;text&quot;, &quot;justification.&quot;]
+maxWidth = 16
+<strong>Output:</strong>
+[
+&nbsp; &nbsp;&quot;This &nbsp; &nbsp;is &nbsp; &nbsp;an&quot;,
+&nbsp; &nbsp;&quot;example &nbsp;of text&quot;,
+&nbsp; &nbsp;&quot;justification. &nbsp;&quot;
+]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong>
+words = [&quot;What&quot;,&quot;must&quot;,&quot;be&quot;,&quot;acknowledgment&quot;,&quot;shall&quot;,&quot;be&quot;]
+maxWidth = 16
+<strong>Output:</strong>
+[
+&nbsp; &quot;What &nbsp; must &nbsp; be&quot;,
+&nbsp; &quot;acknowledgment &nbsp;&quot;,
+&nbsp; &quot;shall be &nbsp; &nbsp; &nbsp; &nbsp;&quot;
+]
+<strong>Explanation:</strong> Note that the last line is &quot;shall be    &quot; instead of &quot;shall     be&quot;,
+&nbsp;            because the last line must be left-justified instead of fully-justified.
+             Note that the second line is also left-justified becase it contains only one word.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong>
+words = [&quot;Science&quot;,&quot;is&quot;,&quot;what&quot;,&quot;we&quot;,&quot;understand&quot;,&quot;well&quot;,&quot;enough&quot;,&quot;to&quot;,&quot;explain&quot;,
+&nbsp;        &quot;to&quot;,&quot;a&quot;,&quot;computer.&quot;,&quot;Art&quot;,&quot;is&quot;,&quot;everything&quot;,&quot;else&quot;,&quot;we&quot;,&quot;do&quot;]
+maxWidth = 20
+<strong>Output:</strong>
+[
+&nbsp; &quot;Science &nbsp;is &nbsp;what we&quot;,
+  &quot;understand &nbsp; &nbsp; &nbsp;well&quot;,
+&nbsp; &quot;enough to explain to&quot;,
+&nbsp; &quot;a &nbsp;computer. &nbsp;Art is&quot;,
+&nbsp; &quot;everything &nbsp;else &nbsp;we&quot;,
+&nbsp; &quot;do &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;&quot;
+]
+</pre>

0193.valid-phone-numbers/valid-phone-numbers.md

@@ -0,0 +1,22 @@
+<p>Given a text file <code>file.txt</code> that contains list of phone numbers (one per line), write a one liner bash script to print all valid phone numbers.</p>
+
+<p>You may assume that a valid phone number must appear in one of the following two formats: (xxx) xxx-xxxx or xxx-xxx-xxxx. (x means a digit)</p>
+
+<p>You may also assume each line in the text file must not contain leading or trailing white spaces.</p>
+
+<p><strong>Example:</strong></p>
+
+<p>Assume that <code>file.txt</code> has the following content:</p>
+
+<pre>
+987-123-4567
+123 456 7890
+(123) 456-7890
+</pre>
+
+<p>Your script should output the following valid phone numbers:</p>
+
+<pre>
+987-123-4567
+(123) 456-7890
+</pre>

0211.add-and-search-word-data-structure-design/add-and-search-word-data-structure-design.cpp

@@ -0,0 +1,60 @@
+class Node{
+public:    
+    bool end=false;
+    vector<Node*> next;
+    
+    Node(){
+        next.clear();
+        next.resize(26,nullptr);
+    }
+};
+
+class WordDictionary {
+public:
+    Node *root=new Node();
+    
+    /** Initialize your data structure here. */
+    WordDictionary() {
+        
+    }
+    
+    /** Adds a word into the data structure. */
+    void addWord(string word) {
+        auto cur=root;
+        for(const auto &c:word){
+            if(cur->next[c-'a']==nullptr) cur->next[c-'a']=new Node();
+            cur=cur->next[c-'a'];
+        }
+        cur->end=true;
+    }
+    
+    /** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */
+    bool search(string word) {
+        return dfs(word,0,root);
+    }
+    
+    bool dfs(string &s, int i, Node* cur){
+        if(i==s.size()){
+            if(cur->end) return true;
+            else return false;
+        } 
+        
+        if(s[i]=='.'){
+            for(auto &v:cur->next){
+                if(v==nullptr) continue;
+                if(dfs(s,i+1,v)) return true;
+            }
+            return false;
+        }
+        
+        if(cur->next[s[i]-'a']==nullptr) return false;
+        return dfs(s,i+1,cur->next[s[i]-'a']);
+    }
+};
+
+/**
+ * Your WordDictionary object will be instantiated and called as such:
+ * WordDictionary* obj = new WordDictionary();
+ * obj->addWord(word);
+ * bool param_2 = obj->search(word);
+ */

0211.add-and-search-word-data-structure-design/add-and-search-word-data-structure-design.md

@@ -0,0 +1,23 @@
+<p>Design a data structure that supports the following two operations:</p>
+
+<pre>
+void addWord(word)
+bool search(word)
+</pre>
+
+<p>search(word) can search a literal word or a regular expression string containing only letters <code>a-z</code> or <code>.</code>. A <code>.</code> means it can represent any one letter.</p>
+
+<p><strong>Example:</strong></p>
+
+<pre>
+addWord(&quot;bad&quot;)
+addWord(&quot;dad&quot;)
+addWord(&quot;mad&quot;)
+search(&quot;pad&quot;) -&gt; false
+search(&quot;bad&quot;) -&gt; true
+search(&quot;.ad&quot;) -&gt; true
+search(&quot;b..&quot;) -&gt; true
+</pre>
+
+<p><b>Note:</b><br />
+You may assume that all words are consist of lowercase letters <code>a-z</code>.</p>

0220.contains-duplicate-iii/contains-duplicate-iii.cpp

@@ -0,0 +1,76 @@
+class Solution {
+public:
+    // 这个解法实在是很trick了 使用了分桶思想
+    // https://leetcode.com/problems/contains-duplicate-iii/discuss/61645/AC-O(N)-solution-in-Java-using-buckets-with-explanation
+    // 大致看了楼主的帖子，然后是comments揭露了本质 @wzrthhj @WendyO__O
+    // bucket_size要+1：避免了t为0时的除法。另外，本来就应该是t+1的，假设t=3,则[0,1,2,3]应该被分到一个桶中。0和3除以4都为0
+    // remapn：需要重hash，是因为负数在除以整数的时候会向0靠近，这样把不应该分为一桶的数分到一桶里，例如t=2,则[0,1,2]应该在一桶，但是如果有-1，则变成了[-1,0,1,2],而distance(-1,2)大于了t，因此有问题。如果我们找到一个base，然后根据距离base的距离来进行分桶，就避免了负数的尴尬问题
+    // 相邻桶中元素也需要做比较的原因(remapn-bucket_set[bucketid-1]<=t)：假如桶是这样的[[1,2,3],[4,5,6]],我们发现3和4的距离其实也是小于t的，即两个相邻桶中的元素也可能符合条件
+    // bucket_set[bucketid]=remapn;会把之前的元素替换掉，但不会有问题的原因：我之前担心这个会影响相邻桶中元素做比较(假如有A、B两个桶，A中本来有一个元素a1距离B中元素b是小于t的，但是又来了一个a2将a1替换掉了，这样等到遍历到b时就不会发现a1了)。但这个其实不会影响，因为我们把上述顺序打出来看一下：a1->a2->b，当遍历到a2时，就会发现a1已经和自己落到同一个桶中了，直接return true，都等不到遍历到b。
+    // 我们上面只考虑了t的限制，没有考虑到位置k的限制。解决方案：我们通过动态删除bucket_set元素，保证了当遍历到元素x时，桶中的元素的位置距离x一定是小于等于k的。
+    bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {
+        if(t<0 || k<0) return false;
+        
+        long long bucket_size=0ll+t+1;
+        unordered_map<long long , long long> bucket_set;
+        
+        for(int i=0;i<nums.size();i++){
+            long long n=nums[i];
+            long long remapn = 0ll+n-INT_MIN;
+            long long bucketid = remapn/bucket_size;
+            if(bucket_set.find(bucketid)!=bucket_set.end()) return true;
+            if(bucket_set.find(bucketid-1)!=bucket_set.end() && remapn-bucket_set[bucketid-1]<=t) return true;
+            if(bucket_set.find(bucketid+1)!=bucket_set.end() && bucket_set[bucketid+1]-remapn<=t) return true;
+            
+            bucket_set[bucketid]=remapn;
+            
+            if(bucket_set.size()>k){
+                long long remapdeleten = 0ll+nums[i-k]-INT_MIN;
+                long long deletebucketid=remapdeleten/bucket_size;
+                bucket_set.erase(deletebucketid);
+            }
+        
+        }
+        
+        return  false;
+    }
+    
+    
+    
+    // 自己写的 暴力解法
+    bool containsNearbyAlmostDuplicate1(vector<int>& nums, int k, int t) {
+        // cout<<nums.size()<<" "<<k<<" "<<t<<endl;
+        if(k<t) return k_is_samller(nums,k,t);
+        else return t_is_samller(nums,k,t);
+    }
+    
+    // 遍历位置
+    bool k_is_samller(vector<int>& nums, int k, int t){ 
+        for(int i=0;i<nums.size();i++){
+            for(int j=i+1;(j<nums.size() && j-i<=k);j++){
+                if(llabs(nums[i]+0ll+-nums[j])<=t) return true;
+            }
+        }
+        return false;
+    }
+    
+    // 遍历值
+    bool t_is_samller(vector<int>& nums, int k, int t){
+        unordered_map<long long,int> um;  //value->position
+        for(int i=0;i<nums.size();i++){
+            
+            int v=nums[i];
+            int p=i;
+            
+            for(int i=0;i<=t;i++){
+                if(um.find(v+0ll-i)!=um.end() && abs(um[v-i]-p)<=k) return true;
+                if(um.find(v+0ll+i)!=um.end() && abs(um[v+i]-p)<=k) return true;
+            }
+            
+            um[v]=p;
+        
+        }
+        
+        return false;
+    } 
+};

0220.contains-duplicate-iii/contains-duplicate-iii.md

@@ -0,0 +1,28 @@
+<p>Given an array of integers, find out whether there are two distinct indices <i>i</i> and <i>j</i> in the array such that the <b>absolute</b> difference between <b>nums[i]</b> and <b>nums[j]</b> is at most <i>t</i> and the <b>absolute</b> difference between <i>i</i> and <i>j</i> is at most <i>k</i>.</p>
+
+<div>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input: </strong>nums = <span id="example-input-1-1">[1,2,3,1]</span>, k = <span id="example-input-1-2">3</span>, t = <span id="example-input-1-3">0</span>
+<strong>Output: </strong><span id="example-output-1">true</span>
+</pre>
+
+<div>
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input: </strong>nums = <span id="example-input-2-1">[1,0,1,1]</span>, k = <span id="example-input-2-2">1</span>, t = <span id="example-input-2-3">2</span>
+<strong>Output: </strong><span id="example-output-2">true</span>
+</pre>
+
+<div>
+<p><strong>Example 3:</strong></p>
+
+<pre>
+<strong>Input: </strong>nums = <span id="example-input-3-1">[1,5,9,1,5,9]</span>, k = <span id="example-input-3-2">2</span>, t = <span id="example-input-3-3">3</span>
+<strong>Output: </strong><span id="example-output-3">false</span>
+</pre>
+</div>
+</div>
+</div>

0229.majority-element-ii/majority-element-ii.cpp

@@ -0,0 +1,71 @@
+class Solution {
+public:
+    // https://leetcode.com/problems/majority-element-ii/discuss/63520/Boyer-Moore-Majority-Vote-algorithm-and-my-elaboration
+    vector<int> majorityElement(vector<int>& nums) {
+        vector<int> res;
+        int t=nums.size()/3+1;
+        
+        int c1=0;
+        int c2=0;
+        int a=INT_MIN; // 任意值
+        int b=a;
+        for(const auto &n:nums){
+            if(n==a) c1++; // 先看值，而不是看个数。这样更简单
+            else if(n==b) c2++;
+            else if(c1==0) a=n,c1=1;
+            else if(c2==0) b=n,c2=1;
+            else{
+                c1--;
+                c2--;
+            }
+            // cout<<n<<"..."<<a<<":"<<c1<<" | "<<b<<":"<<c2<<endl;
+        }
+        
+        c1=0;
+        c2=0;
+        for(const auto &n:nums){
+            c1+=(n==a);
+            c2+=(n==b);
+        }
+        if(c1>=t) res.push_back(a);
+        if(c2>=t) res.push_back(b);
+        if(res.size()==2 && a==b) res.pop_back();
+        
+        return res;
+    }
+    
+    // 自己写的，但是没有模板的感觉
+    vector<int> majorityElement1(vector<int>& nums) {
+        vector<int> res;
+        int t=nums.size()/3+1;
+        
+        int c1=0;
+        int c2=0;
+        int a=INT_MIN; // 任意值
+        int b=a;
+        for(const auto &n:nums){
+            
+            if(c1==0 && n!=b) a=n;
+            else if(c2==0) b=n;
+            
+            if(n==a) c1++;
+            else if(n==b) c2++;
+            else{
+                c1--;
+                c2--;                
+            }
+            // cout<<n<<"..."<<a<<":"<<c1<<" | "<<b<<":"<<c2<<endl;
+        }
+        
+        c1=0;
+        c2=0;
+        for(const auto &n:nums){
+            c1+=(n==a);
+            c2+=(n==b);
+        }
+        if(c1>=t) res.push_back(a);
+        if(c2>=t && (res.empty() || res[0]!=b) ) res.push_back(b);
+        
+        return res;
+    }
+};