Skip to content

Commit e7c2fad

Browse files
TonyKim9401TonyKim9401
authored
Merge pull request #2291 from ys-han00/main
[ys-han00] WEEK 11 solutions Solutions
2 parents d930b63 + b74f829 commit e7c2fad

4 files changed

Lines changed: 210 additions & 0 deletions

File tree

‎binary-tree-maximum-path-sum/ys-han00.cpp‎

Lines changed: 33 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
8+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10+
* };
11+
*/
12+
class Solution {
13+
public:
14+
int max_sum = INT_MIN;
15+
16+
int dfs(TreeNode* node) {
17+
if(!node)
18+
return 0;
19+
20+
int left_max = max(dfs(node->left), 0);
21+
int right_max = max(dfs(node->right), 0);
22+
23+
max_sum = max(node->val + left_max + right_max, max_sum);
24+
25+
return node->val + max(left_max, right_max);
26+
}
27+
28+
int maxPathSum(TreeNode* root) {
29+
dfs(root);
30+
return max_sum;
31+
}
32+
};
33+

‎merge-intervals/ys-han00.cpp‎

Lines changed: 40 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,40 @@
1+
class Solution {
2+
public:
3+
vector<vector<int>> merge(vector<vector<int>>& intervals) {
4+
sort(intervals.begin(), intervals.end());
5+
6+
vector<vector<int>> ans;
7+
for (const auto& interval : intervals) {
8+
if (ans.empty() || ans.back()[1] < interval[0])
9+
ans.push_back(interval);
10+
else
11+
ans.back()[1] = max(ans.back()[1], interval[1]);
12+
}
13+
14+
return ans;
15+
}
16+
17+
// vector<vector<int>> merge(vector<vector<int>>& intervals) {
18+
// vector<vector<int>> ans;
19+
// sort(intervals.begin(), intervals.end());
20+
21+
// int idx = 0, s, e;
22+
// s = intervals[idx][0];
23+
// e = intervals[idx][1];
24+
// idx++;
25+
// while(idx < intervals.size()) {
26+
// if(e < intervals[idx][0]) {
27+
// ans.push_back(vector<int>({s, e}));
28+
// s = intervals[idx][0];
29+
// e = intervals[idx][1];
30+
// } else {
31+
// e = max(e, intervals[idx][1]);
32+
// }
33+
// idx++;
34+
// }
35+
// ans.push_back(vector<int>({s, e}));
36+
37+
// return ans;
38+
// }
39+
};
40+

‎missing-number/ys-han00.cpp‎

Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
class Solution {
2+
public:
3+
// int missingNumber(vector<int>& nums) {
4+
// sort(nums.begin(), nums.end());
5+
6+
// for(int i = 0; i < nums.size(); i++)
7+
// if(i != nums[i])
8+
// return i;
9+
10+
// return nums.size();
11+
// }
12+
13+
// int missingNumber(vector<int>& nums) {
14+
// int ans = nums.size();
15+
// for(int i = 0; i < nums.size(); i++)
16+
// ans ^= i ^ nums[i];
17+
// return ans;
18+
// }
19+
20+
int missingNumber(vector<int>& nums) {
21+
int idx = 0;
22+
while(idx < nums.size()) {
23+
int val = nums[idx];
24+
if(val < nums.size() && val != idx)
25+
swap(nums[idx], nums[val]);
26+
else
27+
idx++;
28+
}
29+
30+
for(int i = 0; i < nums.size(); i++)
31+
if(i != nums[i])
32+
return i;
33+
34+
return nums.size();
35+
}
36+
};
37+

‎reorder-list/ys-han00.cpp‎

Lines changed: 100 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,100 @@
1+
/**
2+
* Definition for singly-linked list.
3+
* struct ListNode {
4+
* int val;
5+
* ListNode *next;
6+
* ListNode() : val(0), next(nullptr) {}
7+
* ListNode(int x) : val(x), next(nullptr) {}
8+
* ListNode(int x, ListNode *next) : val(x), next(next) {}
9+
* };
10+
*/
11+
class Solution {
12+
public:
13+
void reorderList(ListNode* head) {
14+
ListNode* slow = head;
15+
ListNode* fast = head;
16+
while (fast->next && fast->next->next) {
17+
slow = slow->next;
18+
fast = fast->next->next;
19+
}
20+
21+
ListNode* curr = slow->next;
22+
slow->next = nullptr;
23+
ListNode* prev = nullptr;
24+
25+
while (curr) {
26+
ListNode* temp = curr->next;
27+
curr->next = prev;
28+
prev = curr;
29+
curr = temp;
30+
}
31+
32+
ListNode* first = head;
33+
ListNode* second = prev;
34+
35+
while (second) {
36+
ListNode* temp1 = first->next;
37+
ListNode* temp2 = second->next;
38+
39+
first->next = second;
40+
second->next = temp1;
41+
42+
first = temp1;
43+
second = temp2;
44+
}
45+
}
46+
47+
// void reorderList(ListNode* head) {
48+
// ListNode* now = head;
49+
// stack<ListNode*> sta;
50+
51+
// while(now) {
52+
// sta.push(now);
53+
// now = now->next;
54+
// }
55+
56+
// now = head;
57+
// int n = sta.size();
58+
// for(int i = 0; i < n / 2; i++) {
59+
// ListNode* tail = sta.top();
60+
// sta.pop();
61+
62+
// tail->next = now->next;
63+
// now->next = tail;
64+
// now = tail->next;
65+
// }
66+
67+
// now->next = nullptr;
68+
// }
69+
70+
// void reorderList(ListNode* head) {
71+
// ListNode* now = head;
72+
// stack<ListNode*> sta;
73+
74+
// while(now) {
75+
// sta.push(now);
76+
// now = now->next;
77+
// }
78+
79+
// now = head;
80+
// int cnt = 0;
81+
// int node_cnt = sta.size();
82+
// while(cnt < node_cnt / 2) {
83+
// if(cnt != node_cnt / 2 - 1)
84+
// sta.top()->next = now->next;
85+
// else {
86+
// if(node_cnt & 1) {
87+
// now->next->next = nullptr;
88+
// sta.top()->next = now->next;
89+
// }
90+
// else
91+
// sta.top()->next = nullptr;
92+
// }
93+
// now->next = sta.top();
94+
// now = sta.top()->next;
95+
// sta.pop();
96+
// cnt++;
97+
// }
98+
// }
99+
};
100+

0 commit comments

Comments
 (0)