smilegithub01
diff --git a/‎AddTwoNumbers/AddTwoNumbers.cpp‎
Lines changed: 60 additions & 0 deletions b/‎AddTwoNumbers/AddTwoNumbers.cpp‎
Lines changed: 60 additions & 0 deletions
diff --git a/‎LongestPalindromicSubstring/LongestPalindromicSubstring.cpp‎
Lines changed: 25 additions & 0 deletions b/‎LongestPalindromicSubstring/LongestPalindromicSubstring.cpp‎
Lines changed: 25 additions & 0 deletions
diff --git a/‎LongestSubstringWithoutRepeatingCharacters/LongestSubstringWithoutRepeatingCharacters.cpp‎
Lines changed: 23 additions & 0 deletions b/‎LongestSubstringWithoutRepeatingCharacters/LongestSubstringWithoutRepeatingCharacters.cpp‎
Lines changed: 23 additions & 0 deletions
diff --git a/‎MedianofTwoSortedArrays/MedianofTwoSortedArrays.cpp‎
Lines changed: 33 additions & 0 deletions b/‎MedianofTwoSortedArrays/MedianofTwoSortedArrays.cpp‎
Lines changed: 33 additions & 0 deletions
diff --git a/‎TwoSum/TwoSum.cpp‎
Lines changed: 33 additions & 0 deletions b/‎TwoSum/TwoSum.cpp‎
Lines changed: 33 additions & 0 deletions
@@ -0,0 +1,60 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        int carry = 0;
+        ListNode *list = new ListNode(0);
+        ListNode *head = list;
+        ListNode *prev = list;
+        while (l1 && l2) {
+            carry += l1->val + l2->val;
+            
+            list = new ListNode(0);
+            list->val = carry % 10;
+            carry /= 10;
+
+            l1 = l1->next;
+            l2 = l2->next;
+            prev->next = list;
+            prev = prev->next;
+        }
+        while (l1) {
+            carry += l1->val;
+            
+            list = new ListNode(0);
+            list->val = carry % 10;
+            carry /= 10;
+
+            l1 = l1->next;
+            prev->next = list;
+            prev = prev->next;
+        }
+        while (l2) {
+            carry += l2->val;
+            
+            list = new ListNode(0);
+            list->val = carry % 10;
+            carry /= 10;
+
+            l2 = l2->next;
+            prev->next = list;
+            prev = prev->next;
+        }
+        if (carry) {
+            list = new ListNode(0);
+            list->val = carry;
+            prev->next = list;
+            prev = prev->next;
+        }
+        return head->next;
+    }
+};
@@ -0,0 +1,25 @@
+class Solution {
+public:
+    string longestPalindrome(string s) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        int beg = 0, end = 0;
+        int longest = 1;
+        for (int i = 0; i < s.size(); i++) {
+            dp[i][i] = dp[i+1][i] = true;
+        }
+        for (int d = 1; d < s.size(); d++) {
+            for (int i = 0, j = i + d; j < s.size(); i++, j++) {
+                dp[i][j] = false;
+                if (s[i] == s[j]) dp[i][j] |= dp[i+1][j-1];
+                if (dp[i][j] && longest < j-i+1) {
+                    beg = i, end = j;
+                }
+            }
+        }
+        return s.substr(beg, end - beg + 1);
+    }
+private:
+    static const int MAXN = 1010;
+    bool dp[MAXN][MAXN];
+};
@@ -0,0 +1,23 @@
+class Solution {
+public:
+    int lengthOfLongestSubstring(string s) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        int hash[256];
+        memset(hash, -1, sizeof(hash));
+        int maxlen = 0, count = 0;
+        for (int i = 0, j = 0; j < s.size(); j++) {
+            if (hash[s[j]] == -1) {
+                hash[s[j]] = j;
+                maxlen = max(maxlen, j - i + 1);
+            } else {
+                while (i <= hash[s[j]]) {
+                    hash[s[i]] = -1;
+                    i += 1;
+                }
+                hash[s[j]] = j;
+            }
+        }
+        return maxlen;
+    }
+};
@@ -0,0 +1,33 @@
+class Solution {
+public:
+    double findMedianSortedArrays(int A[], int m, int B[], int n) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        if ((m + n) & 1) 
+            return (double)findKth(A, m, B, n, (m+n+1)/2);
+        else
+            return (findKth(A, m, B, n, (m+n)/2) + findKth(A, m, B, n, (m+n)/2+1)) / 2.0;
+        
+    }
+    
+    int findKth(int A[], int m, int B[], int n, int k) {
+        if (m <= 0) return B[k-1];
+        if (n <= 0) return A[k-1];
+        if (k <= 1) return min(A[0], B[0]);
+        
+        int ans;
+        if (m/2 + n/2 + 1 >= k) {
+            if (A[m/2] >= B[n/2])
+                ans = findKth(A, m/2, B, n, k);
+            else
+                ans = findKth(A, m, B, n/2, k);
+        } 
+        else {
+            if (A[m/2] >= B[n/2])
+                ans = findKth(A, m, B + n/2 + 1, n - n/2 - 1, k - n/2 - 1);
+            else
+                ans = findKth(A + m/2 + 1, m - m/2 - 1, B, n, k - m/2 - 1);
+        }
+        return ans;
+    }
+};
@@ -0,0 +1,33 @@
+
+bool lessthan(const pair<int, int>& lhs, const pair<int, int>& rhs) {
+    if (lhs.first == rhs.first) 
+        return lhs.second < rhs.second;
+    return lhs.first < rhs.first;
+}
+
+class Solution {
+public:
+    vector<int> twoSum(vector<int> &numbers, int target) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        vector<pair<int, int>> vnum;
+        for (size_t i = 0; i < numbers.size(); i++) {
+            vnum.push_back(make_pair(numbers[i], i + 1));
+        }
+        sort(vnum.begin(), vnum.end(), lessthan);
+        vector<int> ans;
+        int s = 0, e = vnum.size() - 1;
+        while (s < e) {
+            if (vnum[s].first + vnum[e].first == target) {
+                ans.push_back(min(vnum[s].second, vnum[e].second));
+                ans.push_back(max(vnum[s].second, vnum[e].second));
+                break;
+            } 
+            else if (vnum[s].first + vnum[e].first > target)
+                e -= 1;
+            else 
+                s += 1;
+        }
+        return ans;
+    }
+};