Skip to content

Commit 81c0119

Browse files
andy2gitandy2git
committed
more solutionswq
1 parent e8d7592 commit 81c0119

13 files changed

+245
-72
lines changed

‎coding/.Continious_Subarray_Sum.cpp.swp

12 KB
Binary file not shown.

‎leetcode/Binary_Tree_Right_Side_View.cpp

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
/**
2+
* Definition for binary tree
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8+
* };
9+
*/
10+
class Solution {
11+
public:
12+
vector<int> rightSideView(TreeNode *root) {
13+
if(!root) return {};
14+
15+
queue<TreeNode *> p, q;
16+
p.push(root);
17+
18+
vector<int> result;
19+
while(!p.empty()){
20+
if(p.size() == 1) result.push_back((p.front())->val);
21+
TreeNode *t = p.front();
22+
p.pop();
23+
24+
if(t->left) q.push(t->left);
25+
if(t->right) q.push(t->right);
26+
if(p.empty()) swap(p, q);
27+
}
28+
29+
return result;
30+
}
31+
};

‎leetcode/Count_and_Say.cpp

Lines changed: 7 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,25 +1,24 @@
11
class Solution {
22
public:
33
string countAndSay(int n) {
4-
string st = "1";
5-
if(n == 1) return st;
4+
if(n <= 0) throw runtime_error("invalid input!");
65

7-
stringstream ss;
6+
string st = "1";
87
while(n > 1){
8+
stringstream ss;
99
int cnt = 1;
10-
ss.str("");
11-
ss.clear();
1210
for(int i = 1; i < st.size(); i++){
13-
if(st[i] == st[i-1]){
11+
if(st[i-1] == st[i]){
1412
cnt++;
1513
}else{
1614
ss << cnt << st[i-1];
1715
cnt = 1;
1816
}
1917
}
20-
ss << cnt << st[(int)st.size()-1];
21-
st = ss.str();
2218

19+
// last part of elements
20+
ss << cnt << st[st.size()-1];
21+
st = ss.str();
2322
n--;
2423
}
2524

‎leetcode/First_Missing_Positive.cpp

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -31,3 +31,32 @@ class Solution {
3131
return n+1;
3232
}
3333
};
34+
35+
36+
class Solution {
37+
public:
38+
int firstMissingPositive(int A[], int n) {
39+
if(n == 0) return 1;
40+
41+
for(int i= 0; i < n; i++){
42+
if(A[i] <= 0) A[i] = n+2;
43+
}
44+
45+
// use the above method for cleaner solution
46+
int i = 0;
47+
while(i < n){
48+
if(A[i] > 0 && A[i] <= n) {
49+
int t = A[i];
50+
if(A[t-1] > 0){
51+
swap(A[i], A[t-1]);
52+
A[t-1] = -1;
53+
}else i++;
54+
}else i++;
55+
}
56+
57+
for(int i = 0; i < n; i++){
58+
if(A[i] > 0) return i+1;
59+
}
60+
return n+1;
61+
}
62+
};

‎leetcode/House_Robber.cpp

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
class Solution {
2+
public:
3+
int rob(vector<int> &num) {
4+
if(num.empty()) return 0;
5+
6+
int n = num.size();
7+
vector<int> t(n+1, 0);
8+
t[0] = 0;
9+
t[1] = num[0];
10+
11+
for(int i = 1; i <= n; i++){
12+
t[i] = max(t[i-1], t[i-2]+num[i-1]);
13+
}
14+
15+
return t[n];
16+
}
17+
};

‎leetcode/Merge_Intervals.cpp

Lines changed: 21 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -7,39 +7,36 @@
77
* Interval(int s, int e) : start(s), end(e) {}
88
* };
99
*/
10-
10+
11+
bool intervalCmp(Interval &lhs, Interval &rhs){
12+
return lhs.start < rhs.start;
13+
}
14+
1115
class Solution {
1216
public:
13-
vector<Interval> merge(vector<Interval> &intervals) {
14-
if(intervals.empty()) return vector<Interval>();
17+
vector<Interval> merge(vector<Interval> &A) {
18+
if(A.empty()) return {};
1519

16-
sort(intervals.begin(), intervals.end(), Solution::interval_cmp);
1720

18-
vector<Interval> result;
19-
int i = 1;
20-
int n = intervals.size();
21-
int s, e;
21+
sort(A.begin(), A.end(), intervalCmp);
22+
23+
int cInd = 0;
24+
int nInd = 1;
2225

23-
s = intervals[0].start;
24-
e = intervals[0].end;
25-
while(i < n){
26-
if(intervals[i].start <= e){
27-
e = max(e, intervals[i].end);
26+
vector<Interval> result;
27+
while(nInd < A.size()){
28+
if(A[cInd].end >= A[nInd].start){
29+
A[cInd].end = max(A[cInd].end, A[nInd].end);
30+
nInd++;
2831
}else{
29-
result.push_back(Interval(s, e));
30-
s = intervals[i].start;
31-
e = intervals[i].end;
32+
result.push_back(A[cInd]);
33+
cInd = nInd;
34+
nInd++;
3235
}
33-
34-
i++;
3536
}
36-
result.push_back(Interval(s, e));
37+
38+
result.push_back(A[cInd]);
3739

3840
return result;
3941
}
40-
private:
41-
static bool interval_cmp(const Interval &lhs, const Interval &rhs){
42-
return lhs.start < rhs.start;
43-
}
4442
};
45-

‎leetcode/Number_of_Islands.cpp

Lines changed: 38 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,38 @@
1+
class Solution {
2+
public:
3+
int numIslands(vector<vector<char>> &grid) {
4+
if(grid.empty()) return 0;
5+
6+
int m = grid.size();
7+
int n = grid[0].size();
8+
9+
int cnt = 0;
10+
set<pair<int, int>> mark;
11+
for(int i = 0; i < m; i++){
12+
for(int j = 0; j < n; j++){
13+
if(grid[i][j] == '1' && mark.find({i, j}) == mark.end()){
14+
dfsTraverse(i, j, mark, grid);
15+
cnt++;
16+
}
17+
}
18+
}
19+
20+
return cnt;
21+
}
22+
23+
private:
24+
// use set<pair<int, int>> to avoid hash() requirement for unordered_set<T>
25+
void dfsTraverse(int i, int j, set<pair<int, int>> &mark, vector<vector<char>> &grid){
26+
27+
int m = grid.size();
28+
int n = grid[0].size();
29+
30+
mark.insert({i, j});
31+
32+
if(j+1 < n && grid[i][j+1] == '1' && mark.find({i, j+1}) == mark.end()) dfsTraverse(i, j+1, mark, grid);
33+
if(j-1 >= 0 && grid[i][j-1] == '1' && mark.find({i, j-1}) == mark.end()) dfsTraverse(i, j-1, mark, grid);
34+
35+
if(i+1 < m && grid[i+1][j] == '1' && mark.find({i+1, j}) == mark.end()) dfsTraverse(i+1, j, mark, grid);
36+
if(i-1 >= 0 && grid[i-1][j] == '1' && mark.find({i-1, j}) == mark.end()) dfsTraverse(i-1, j, mark, grid);
37+
}
38+
};

‎leetcode/Validate_Binary_Search_Tree.cpp

Lines changed: 13 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -10,20 +10,21 @@
1010
class Solution {
1111
public:
1212
bool isValidBST(TreeNode *root) {
13-
if(root == nullptr) return true;
14-
if(root->left == nullptr && root->right == nullptr) return true;
13+
if(!root) return true;
14+
if(!root->left && !root->right) return true;
1515

16-
return is_bst_helper(root, INT_MIN, INT_MAX);
16+
return isBSTHelper(root, LONG_MIN, LONG_MAX);
1717
}
18-
private:
19-
bool is_bst_helper(TreeNode *root, int min, int max){
20-
// speical case
21-
if(root == nullptr) return true;
22-
23-
if(root->val <= min || root->val >= max) return false;
24-
25-
return is_bst_helper(root->left, min, root->val) && is_bst_helper(root->right, root->val, max);
18+
19+
// use long for overflow problem
20+
// NOTE:
21+
// -----
22+
// In BST, key cannot be duplicated
23+
bool isBSTHelper(TreeNode *root, long l, long h){
24+
if(!root) return true;
25+
if(root->val <= l || root->val >= h) return false;
2626

27+
return isBSTHelper(root->left, l, root->val)
28+
&& isBSTHelper(root->right, root->val, h);
2729
}
28-
2930
};

‎leetcode/Word_Break_2.cpp

Lines changed: 40 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -43,3 +43,43 @@ class Solution {
4343
}
4444
}
4545
};
46+
47+
// backtracking solution
48+
class Solution {
49+
public:
50+
vector<string> wordBreak(string s, unordered_set<string> &dict) {
51+
if(s.empty() || dict.empty()) return {};
52+
53+
54+
if(!containsSolution(s, dict)) return{};
55+
56+
vector<string> result;
57+
wbHelper(result, "", s, 0, dict);
58+
return result;
59+
}
60+
61+
private:
62+
bool containsSolution(string &s, unordered_set<string> &dict){
63+
int n = s.size();
64+
for(int i = n-1; i >= 0; i--){
65+
if(dict.find(s.substr(i, n-i)) != dict.end()) return true;
66+
}
67+
68+
return false;
69+
}
70+
71+
72+
void wbHelper(vector<string> &result, string sofar, string remain, int s, unordered_set<string> &dict){
73+
if(s == remain.size()){
74+
if(!sofar.empty()) result.push_back(sofar.substr(1));
75+
return;
76+
}
77+
78+
for(int i = s; i < remain.size(); i++){
79+
string t = remain.substr(s, i-s+1);
80+
if(dict.find(t) != dict.end()){
81+
wbHelper(result, sofar+" "+t, remain, i+1, dict);
82+
}
83+
}
84+
}
85+
};

‎lintcode/Combination_Sum.cpp

Lines changed: 20 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -1,40 +1,32 @@
11
class Solution {
22
public:
33
/**
4-
* @param candidates: A list of integers
5-
* @param target:An integer
6-
* @return: A list of lists of integers
4+
* @param n: Given the range of numbers
5+
* @param k: Given the numbers of combinations
6+
* @return: All the combinations of k numbers out of 1..n
77
*/
8-
vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
9-
if(candidates.empty()) return {};
10-
11-
sort(candidates.begin(), candidates.end());
8+
vector<vector<int> > combine(int n, int k) {
9+
// write your code here
1210
vector<vector<int>> result;
1311
vector<int> sofar;
1412

15-
combinationHelper(result, sofar, candidates, 0, target);
13+
combineHelper(result, sofar, 1, n, k);
14+
1615
return result;
1716
}
1817
private:
19-
void combinationHelper(vector<vector<int>> &result, vector<int> &sofar, vector<int> &remain, int k, int target){
20-
int sum = accumulate(sofar.begin(), sofar.end(), 0);
21-
if(sum == target) {
22-
result.push_back(sofar);
23-
return;
24-
}
25-
if(k == remain.size()) return;
26-
27-
int x = remain[k];
28-
int t = 0;
29-
while(sum + t*x <= target){
30-
if(t > 0) sofar.push_back(x);
31-
combinationHelper(result, sofar, remain, k+1, target);
32-
t++;
18+
19+
void combineHelper(vector<vector<int>> &result, vector<int> &sofar,
20+
int s, int e, int k){
21+
if(sofar.size() == k){
22+
result.push_back(sofar);
23+
return;
24+
}
25+
26+
for(int i = s; i <= e; i++){
27+
sofar.push_back(i);
28+
combineHelper(result, sofar, i+1, e, k);
29+
sofar.pop_back();
30+
}
3331
}
34-
35-
while(t > 1){
36-
sofar.pop_back();
37-
t--;
38-
}
39-
}
4032
};

‎lintcode/First_Missing_Positive.cpp

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
class Solution {
2+
public:
3+
/**
4+
* @param A: a vector of integers
5+
* @return: an integer
6+
*/
7+
int firstMissingPositive(vector<int> A) {
8+
if(A.empty()) return 1;
9+
int n = A.size();
10+
11+
for(int i = 0; i < n; i++){
12+
if(A[i] <= 0) A[i] = n+1;
13+
}
14+
15+
for(int i = 0; i < n; i++){
16+
int k = abs(A[i]);
17+
if(k <= n && A[k-1] > 0) A[k-1] *=-1;
18+
}
19+
20+
for(int i = 0; i < n; i++){
21+
if(A[i] > 0) return i+1;
22+
}
23+
return n+1;
24+
}
25+
};

‎lintcode/Majority_Number_3.cpp

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,4 @@
1+
/* time complexity: O(n) and O(k) space */
12
class Solution {
23
public:
34
/**
@@ -40,6 +41,7 @@ class Solution {
4041
}
4142
};
4243

44+
/* Time complexity: O(nk) and space is O(k) */
4345

4446
class Solution {
4547
public:

0 commit comments

Comments
 (0)