new problems

haoel · haoel · commit e6fdaded7876 · 2014-12-01T14:06:40.000+08:00
diff --git a/README.md b/README.md
@@ -5,6 +5,9 @@ LeetCode C++ Solutions
 
 | Title | Solution | Add Date | Difficulty |
 | ----- | -------- | -------- | ---------- |
+|[Intersection of Two Linked Lists](https://oj.leetcode.com/problems/intersection-of-two-linked-lists/) | [C++](./src/intersectionOfTwoLinkedLists/intersectionOfTwoLinkedLists.cpp)|2014/11/27|Easy|
+|[Longest Substring with At Most Two Distinct Characters](https://oj.leetcode.com/problems/longest-substring-with-at-most-two-distinct-characters/) :books: | [C++](./src/longestSubstringWithAtMostTwoDistinctCharacters/longestSubstringWithAtMostTwoDistinctCharacters.cpp)|2014/11/25|Hard|
+|[Read N Characters Given Read4 II - Call multiple times](https://oj.leetcode.com/problems/read-n-characters-given-read4-ii-call-multiple-times/) :books: | [C++](./src/readNCharactersGivenRead4/readNCharactersGivenRead4.II.cpp)|2014/11/23|Hard|
 |[Read N Characters Given Read4](https://oj.leetcode.com/problems/read-n-characters-given-read4/) :books: | [C++](./src/readNCharactersGivenRead4/readNCharactersGivenRead4.cpp)|2014/11/19|Easy|
 |[Binary Tree Upside Down](https://oj.leetcode.com/problems/binary-tree-upside-down/) :books: | [C++](./src/binaryTreeUpsideDown/binaryTreeUpsideDown.cpp)|2014/11/16|Medium|
 |[Min Stack](https://oj.leetcode.com/problems/min-stack/)| [C++](./src/minStack/minStack.cpp)|2014/11/09|Easy|
diff --git a/src/intersectionOfTwoLinkedLists/intersectionOfTwoLinkedLists.cpp b/src/intersectionOfTwoLinkedLists/intersectionOfTwoLinkedLists.cpp
@@ -0,0 +1,74 @@
+// Source : https://oj.leetcode.com/problems/intersection-of-two-linked-lists/
+// Author : Hao Chen
+// Date   : 2014-12-01
+
+/********************************************************************************** 
+ * 
+ * Write a program to find the node at which the intersection of two singly linked lists begins.
+ * 
+ * For example, the following two linked lists: 
+ * 
+ *
+ *    A:          a1 → a2
+ *                       ↘
+ *                         c1 → c2 → c3
+ *                       ↗            
+ *    B:     b1 → b2 → b3
+ * 
+ * begin to intersect at node c1.
+ * 
+ * Notes:
+ * 
+ * If the two linked lists have no intersection at all, return null.
+ * The linked lists must retain their original structure after the function returns. 
+ * You may assume there are no cycles anywhere in the entire linked structure.
+ * Your code should preferably run in O(n) time and use only O(1) memory.
+ *               
+ **********************************************************************************/
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+    public:
+        ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
+
+            //caculate the length of each List
+            int lenA = getListLength(headA);
+            int lenB = getListLength(headB);
+
+            if (lenA<=0 || lenB<=0 ) return NULL;
+
+            //let List A is the longest List;
+            if (lenA < lenB){
+                swap(headA, headB);
+            }
+
+            //move head of List A, make both of Lists are same length 
+            for (int i=0; i<abs(lenA-lenB); i++){
+                headA = headA->next;
+            }
+
+            //synced travel both of Lists and check their nodes are same or not 
+            while (headA != headB){
+                headA = headA->next;
+                headB = headB->next;
+            }
+
+            return headA;
+        }
+    private:    
+        inline int getListLength(ListNode *head){
+            int len=0;
+            while(head!=NULL){
+                head = head->next;
+                len++;
+            }
+            return len;
+        }
+};
diff --git a/src/longestSubstringWithAtMostTwoDistinctCharacters/longestSubstringWithAtMostTwoDistinctCharacters.cpp b/src/longestSubstringWithAtMostTwoDistinctCharacters/longestSubstringWithAtMostTwoDistinctCharacters.cpp
@@ -0,0 +1,64 @@
+// Source : https://oj.leetcode.com/problems/longest-substring-with-at-most-two-distinct-characters/
+// Author : Hao Chen
+// Date   : 2014-12-01
+
+/*
+ * Given a string, find the length of the longest substring T that contains at most 2 distinct characters.
+ * 
+ * For example, Given s = “eceba”,
+ * 
+ * T is "ece" which its length is 3.
+ */
+
+
+
+#include <iostream>
+#include <string>
+using namespace std;
+
+
+/*
+ * Idea:
+ *
+ *    1) Using a map to count every chars.
+ *    2) Using a 'cnt' to count the current distinct chars.
+ *    3) if `cnt > 2`, then go through the previous substring to remove one char
+ *
+ * The following algorithm run-time complexity is O(n^2)
+ *
+ * This solution can be easy to extend to "find the length of longest substring with at most K distinct char(s)"
+ */
+int lengthOfLongestSubstringTwoDistinct(string s) {
+    int maxLen = 0;
+    char charMap[256] = {0};
+    int wordCnt = 0;
+    int start = 0;
+
+    for(int i=0; i<s.size(); i++){
+        if ( charMap[s[i]]++ == 0 ){
+            wordCnt++;
+        }
+        while (wordCnt>2){
+            charMap[s[start]]--;
+            if (charMap[s[start]]==0){
+                wordCnt--;
+            }
+            start++;
+        }
+        maxLen = max(maxLen, i - start + 1);
+    }
+
+    return maxLen;
+}
+
+
+int main(int argc, char** argv)
+{
+    string s = "eceba";
+    if (argc>1){
+        s = argv[1];
+    }
+    cout << s << " : " << lengthOfLongestSubstringTwoDistinct(s) << endl;
+
+    return 0;
+}
diff --git a/src/readNCharactersGivenRead4/readNCharactersGivenRead4.II.cpp b/src/readNCharactersGivenRead4/readNCharactersGivenRead4.II.cpp
@@ -0,0 +1,181 @@
+// Source : https://oj.leetcode.com/problems/read-n-characters-given-read4-ii-call-multiple-times/
+// Author : Hao Chen
+// Date   : 2014-12-01
+
+
+/*
+ * The API: int read4(char *buf) reads 4 characters at a time from a file.
+ * 
+ * The return value is the actual number of characters read. 
+ * For example, it returns 3 if there is only 3 characters left in the file.
+ * 
+ * By using the read4 API, implement the function int read(char *buf, int n) that reads n characters from the file.
+ * 
+ * Note:
+ * The read function may be called multiple times.
+ */
+
+
+/*
+ *  The key to solve this problem is: 
+ *
+ *    You have to buffer the extra data return from `read4()` API, which is for next call for `read()` .
+ */
+
+#include <stdio.h>
+#include <string.h>
+// Forward declaration of the read4 API.
+static char input[64];
+static char *p = input;
+
+int read4(char *buf) {
+
+    int s=0;
+    for (; s<4 && *p!='\0'; s++){
+        buf[s] = *p;
+        p++;
+    } 
+    return s;
+}
+
+
+class RingBuffer {
+
+    public:
+        RingBuffer(int cap=4): _capacity(cap) {
+            _size = 0;
+
+            _pbuf = new char[_capacity];
+            _p = _pbuf;
+            _pend = _pbuf + _capacity - 1;
+        } 
+        ~RingBuffer(){
+            delete _pbuf;
+        }
+        int read(char* buf, int n){
+            //empty, nothing can read
+            if (_size==0) return 0;
+
+            //read `n` or all 
+            int s;
+            for (s=0; s<n && s<_size; s++){
+                buf[s] = *_p;
+                _p = (_p < _pend) ? _p + 1 : _pbuf;  
+            }
+            _size -= s;
+            return s;
+        }
+
+        int write(char* buf, int n) {
+            //full, cannot write
+            if (_size >= _capacity) return 0;
+
+            //write `n` or all
+            int s;
+            char *p = _p + _size;
+            for (s=0; s < _capacity - _size && s < n; s++){
+                *p = buf[s];
+                p = (p < _pend) ? p + 1 : _pbuf;
+            }
+            _size += s;
+            return s;
+        }
+
+    private:
+        const int   _capacity;
+        int         _size;
+
+        char*       _pbuf;
+        char*       _p;
+        char*       _pend;
+
+};
+
+class Solution {
+    public:
+        /**
+         * @param buf Destination buffer
+         * @param n   Maximum number of characters to read
+         * @return    The number of characters read
+         */
+        int read(char *buf, int n) {
+            int buf_size = 0;
+            int api_size = 0;
+
+            //read the data from the RingBuffer at first
+            buf_size = _ring_buffer.read(buf, n);
+            if (buf_size == n) {
+                return n;
+            }
+            n = n - buf_size;
+
+            //read the data from the API at second
+            api_size = read1(buf + buf_size, n);
+
+            return buf_size + api_size;
+        }
+
+        // The read1 implementation is from the `Read N Characters Given Read4` problem
+        // Add the feature - write the extra char(s) into RingBuffer
+        int read1(char *buf, int n) {
+            char _buf[4];   // the buffer for read4()
+            int _n = 0;     // the return for read4()
+            int len = 0;    // total buffer read from read4()
+            int size = 0;   // how many bytes need be copied from `_buf` to `buf`
+            while((_n = read4(_buf)) > 0){
+                //check the space of `buf` whether full or not
+                size = len + _n > n ? n-len : _n;
+                //write the extra char(s) into RingBuffer
+                if (len + _n > n ){
+                    _ring_buffer.write(_buf + size, _n - size);    
+                }
+                strncpy(buf+len, _buf, size);
+                len += size;
+                //buffer is full
+                if (len>=n){
+                    break;
+                }
+            }
+            return len;
+        }
+
+
+    private: 
+        RingBuffer _ring_buffer;
+};
+
+
+int main()
+{
+    Solution s;
+    const int buf_len = 10;
+    char buf[buf_len]={0};
+#define SET_INPUT(s)    strcpy(input, s); p=input; printf("input data = \"%s\"\n", p);
+#define CLEAR_BUFFER()  memset(buf, 0, sizeof(buf)/sizeof(buf[0]) )
+#define READ(s, buf, n) CLEAR_BUFFER(); printf("read(%d) => ",n); s.read(buf, n); printf("%s\n", buf);
+
+    printf("-----------------------------\n");
+    SET_INPUT("1234abcd1234abcdxyz");
+    for(int i=0; i<5; i++){
+        READ(s, buf, 4);
+    }
+    printf("-----------------------------\n");
+    SET_INPUT("ab");
+    READ(s, buf, 1);
+    READ(s, buf, 2);
+
+    printf("-----------------------------\n");
+    SET_INPUT("abcde");
+    for(int i=0; i<5; i++){
+        READ(s, buf, 1);
+    }
+    printf("-----------------------------\n");
+    SET_INPUT("1234xyzabcd00");
+    READ(s, buf, 4);
+    for(int i=0; i<3; i++){
+        READ(s, buf, 1);
+    }
+    READ(s, buf, 4);
+    printf("-----------------------------\n");
+    return 0;
+}
diff --git a/src/readNCharactersGivenRead4/readNCharactersGivenRead4.cpp b/src/readNCharactersGivenRead4/readNCharactersGivenRead4.cpp
@@ -29,12 +29,35 @@ class Solution {
          * @return    The number of characters read
          */
         int read(char *buf, int n) {
+            srand(time(0));
+            if (rand()%2){
+                return read1(buf, n);
+            }
+            return read2(buf, n);
+        }
+
+        //read the data in-place. potential out-of-boundary issue
+        int read1(char *buf, int n) {
+            int len = 0;
+            int size = 0;
+
+            // `buf` could be accessed out-of-boundary 
+            while(len <=n && (size = read4(buf))>0){
+                size = len + size > n ?  n - len : size;
+                len += size;
+                buf += size;
+            }
+            return  len;
+        }
+
+        //using a temp-buffer to avoid peotential out-of-boundary issue
+        int read2(char *buf, int n) {
             char _buf[4];   // the buffer for read4()
             int _n = 0;     // the return for read4()
             int len = 0;    // total buffer read from read4()
             int size = 0;   // how many bytes need be copied from `_buf` to `buf`
             while((_n = read4(_buf)) > 0){
-                //check the space of `buf` whether enough or not
+                //check the space of `buf` whether full or not
                 size = len + _n > n ? n-len : _n;
                 strncpy(buf+len, _buf, size);
                 len += size;
