voidUpdate(int left, int right, int c, int l, int r, int root, vector<int>& sum, vector<int>& add){ if (left <= l && r <= right) { sum[root] += c * (r - l + 1); // 更新统计信息 add[root] += c; // 更新惰性标记 return; } int m = l + (r - l) / 2; PushDown(root, m - l + 1, r - m, sum, add); // 在更新新标记的时候将旧标记下推, 分别表示左右子树的更新个数 if (left <= m) Update(left, right, c, l, m, root << 1, sum, add); if (m < right) Update(left, right, c, m + 1, r, root << 1 | 1, sum, add); PushUp(root, sum); // 因为只下推了就标记，所以需要更新本节点的统计值 }
查询区间
1 2 3 4 5 6 7 8 9 10 11 12 13 14
intQuery(int left, int right, int l, int r, int root, vector<int>& sum, vector<int>& add){ // left, right为要查找的区间，l和r表示此函数所在的查询区间 if (left <= l && r <= right) { return sum[root]; }
int m = l + (r - l) / 2; PushDown(root, m - l + 1, r - m, sum, add); int ret = 0; if (left <= m) ret += Query(left, right, l, m, root << 1, sum, add); if (m < right) ret += Query(left, right, m + 1, r, root << 1 | 1, sum, add); return ret; }
voidbuild(int root, int l, int r, vector<int>& nums){ if (l == r) { ans[root] = nums[l - 1]; return; } int m = l + (r - l) / 2; build(root << 1, l, m, nums); build(root << 1 | 1, m + 1, r, nums); PushUp(root); }
public: segment_tree(vector<int>& nums) { int n = nums.size(); ans = vector<int>(n << 2, INT_MIN); add = vector<int>(n << 2, 0); build(1, 1, n, nums); }
voidupdate(int index, int c, int l, int r, int root){ if (l == r) { ans[root] += c; return; } // 因为query的时候一定会下推，所以此处不需要下推标记 int m = l + (r - l) / 2; if (index <= m) update(index, c, l, m, root << 1); else update(index, c, m + 1, r, root << 1 | 1); PushUp(root); }
voidupdate(int L, int R, int c, int l, int r, int root){ if (L <= l && r <= R) { ans[root] += c; add[root] += c; return; }
PushDown(root); int m = l + (r - l) / 2; if (L <= m) update(L, R, c, l, m, root << 1); if (m < R) update(L, R, c, m + 1, r, root << 1 | 1); PushUp(root);
}
intquery(int L, int R, int l, int r, int root){ if (L <= l && r <= R) { return ans[root]; } PushDown(root); int m = l + (r - l) / 2; int ret = INT_MIN; if (L <= m) ret = max(ret, query(L, R, l, m, root << 1)); if (m < R) ret = max(ret, query(L, R, m + 1, r, root << 1 | 1)); return ret; } };
intmain(){ int n; cin >> n; vector<int> nums(n, 0); for (int i = 0; i < n; i++) { cin >> nums[i]; }
segment_tree* inst = new segment_tree(nums);
int t; cin >> t; for (int i = 0; i < t; i++) { int x, y, c; cin >> x >> y >> c; if (x == y) inst->update(x, c, 1, n, 1); else { inst->update(x, y, c, 1, n, 1); for (int j = 1; j <= n; j++) cout << inst->query(j, j, 1, n, 1) << " "; cout << endl; } }
voidbuild(vector<int>& nums, int l, int r, int root){ if (l == r) { sum[root] = nums[l - 1]; return; }
int m = l + (r - l) / 2; build(nums, l, m, root << 1); build(nums, m + 1, r, root << 1 |1); PushUp(root); } voidPushDown(int root, int cnt_l, int cnt_r){ if (add[root]) { sum[root << 1] += add[root] * cnt_l; sum[root << 1 | 1] += add[root] * cnt_r; add[root << 1] += add[root]; add[root << 1| 1] += add[root]; add[root] = 0; } } public: segment_tree(vector<int>& nums) { int n = nums.size(); sum = vector<int>(n << 2, 0); add = vector<int>(n << 2, 0); build(nums, 1, n, 1); } voidUpdate(int L, int R, int c, int l, int r, int root){ // 更新是加c到L..R cout << l << " " << r << endl; if (L <= l && r <= R) { sum[root] += c * (r - l + 1); add[root] += c; return; }
int m = l + (r - l) / 2; PushDown(root, m - l + 1, r - m); if (L <= m) Update(L, R, c, l, m, root << 1); if (m < R) Update(L, R, c, m + 1, r, root << 1 | 1); PushUp(root); } voidUpdate(int index, int c, int l, int r, int root){ if (l == r) { sum[root] += c; return; } int m = l + (r - l) / 2; if (index <= m) Update(index, c, l, m, root << 1); else Update(index, c, m + 1, r, root << 1 | 1); PushUp(root); } intquery(int L, int R, int l, int r, int root){ if (L <= l && r <= R) { return sum[root]; }
int ret = 0; int m = l + (r - l) / 2; PushDown(root, m - l + 1, r - m); if (L <= m) ret += query(L, R, l, m, root << 1); if (m < R) ret += query(L, R, m + 1, r, root << 1 | 1); return ret;
}
};
intmain(){ int n; cin >> n; vector<int> nums(n, 0); for (int i = 0; i < n; i++) { cin >> nums[i]; } auto instance = new segment_tree(nums); int t; cin >> t; for (int i = 0; i < t; i++) { for (int j = 1; j <= n; j++) { cout << instance->query(j, j, 1, n, 1) << " "; } cout << endl; int x, y, c; cin >> x >> y >> c; if (x == y) { instance->Update(x, c, 1, n, 1); } else { instance->Update(x, y, c, 1, n, 1); } }
classsegment_tree { private: vector<int> ans; vector<int> mul; intGCD(int a, int b){ if (!b) return a; elsereturn GCD(b, a % b); } voidPushUp(int root){ ans[root] = GCD(ans[root << 1], ans[root << 1 | 1]); } voidPushDown(int root){ if (mul[root] != 1) { ans[root << 1] *= mul[root]; ans[root << 1 | 1] *= mul[root]; mul[root << 1] *= mul[root]; mul[root << 1 | 1] *= mul[root]; mul[root] = 1; } } voidbuild(vector<int>& nums, int l, int r, int root){ if (l == r) { ans[root] = nums[l - 1]; return; } int m = l + (r - l) / 2; if (l <= m) build(nums, l, m, root << 1); if (m < r) build(nums, m + 1, r, root << 1 | 1); PushUp(root); }
public: segment_tree(vector<int>& nums) { int n = nums.size(); // 根据不同问题要注意区间值的初始化问题，因为防止没有叶子导致上推引入异常值 // 因为GCD算法会判断!b，所以将初始值初始化为0可以直接返回a, // 这样上推可以直接调用GCD(ans[root << 1], ans[root << 1 | 1]) ans = vector<int>(n << 2, 0); mul = vector<int>(n << 2, 1); build(nums, 1, n, 1); } voidUpdate(int L, int R, int c, int l, int r, int root){ if (L <= l && r <= R) { ans[root] *= c; mul[root] *= c; return; } PushDown(root); int m = l + (r - l) / 2; if (L <= m) Update(L, R, c, l, m, root << 1); if (m < R) Update(L, R, c, m + 1, r, root << 1 | 1); PushUp(root); } voidUpdate(int index, int c, int l, int r, int root){ if (l == r) { ans[root] *= c; return; } int m = l + (r - l) / 2; if (index <= m) Update(index, c, l, m, root << 1); else Update(index, c, m + 1, r, root << 1 | 1); PushUp(root); } intQuery(int L, int R, int l, int r, int root){ if (L <= l && r <= R) { return ans[root]; } PushDown(root); int ret = 0; int m = l + (r - l) / 2; if (L <= m) ret = GCD(ret, Query(L, R, l, m, root << 1)); if (m < R) ret = GCD(ret, Query(L, R, m + 1, r, root << 1 | 1)); return ret; } };
intmain(){ int n; cin >> n; vector<int> nums(n, 0); for (int i = 0; i < n; i++) { cin >> nums[i]; } auto instance = new segment_tree(nums); int t; cin >> t; for (auto i = 0; i < t; i++) { int x, y, c; cin >> x >> y >> c; if (x == y) { instance->Update(x, c, 1, n, 1); } else { instance->Update(x, y, c, 1, n, 1); } cin >> x >> y; cout << instance->Query(x, y, 1, n, 1) << endl; }
ListNode* helper(ListNode* A, ListNode* B){ ListNode* ret = new ListNode(-1); ListNode* cur = ret; while (A && B) { if (A->val < B->val) { cur->next = A; A = A->next; } else { cur->next = B; B = B->next; } cur = cur->next; } while (A) { cur->next = A; A = A->next; cur = cur->next; } while (B) { cur->next = B; B = B->next; cur = cur->next; } return ret->next; }
intmain(){ int n; cin >> n; auto A = new ListNode(-1); auto cur = A; for (int i = 0; i < n; i++) { int x; cin >> x; cur->next = new ListNode(x); cur = cur->next; } cin >> n; auto B = new ListNode(-1); cur = B; for (int i = 0; i < n; i++) { int y; cin >> y; cur->next = new ListNode(y); cur = cur->next; } auto ret = helper(A->next, B->next); while (ret) { cout << ret->val << " "; ret = ret->next; } cout << endl; return0; }
ListNode* helper(ListNode* root){ ListNode* ret = new ListNode(-1); while (root) { auto temp = root->next; root->next = ret->next; ret->next = root; root = temp; } return ret->next; }
intmain(){ int n; cin >> n; ListNode* A = new ListNode(-1); ListNode* cur = A; for (int i = 0; i < n; i++) { int x; cin >> x; cur->next = new ListNode(x); cur = cur->next; }
auto ret = helper(A->next); while (ret) { cout << ret->val << " "; ret = ret->next; } return0; }
ListNode* helper(ListNode* head){ if (!head || !head->next) return head; ListNode* fast = head, *slow = head; while (fast && fast->next) { fast = fast->next->next; slow = slow->next; } ListNode* head2 = slow->next; slow->next = NULL; ListNode* ret = new ListNode(-1); ListNode* cur = ret; while (head2) { auto temp = head2->next; head2->next = cur->next; cur->next = head2; cur = cur->next; head2 = temp; } head2 = ret->next; ret->next = NULL;
cur = ret; while (head) { cur->next = head; head = head->next; cur = cur->next; if (head2) { cur->next = head2; head2 = head2->next; cur = cur->next; } } return ret->next; }
intmain(){ int n; cin >> n; ListNode* head = new ListNode(-1); auto cur = head; for (int i = 0; i < n; i++) { int x; cin >> x; cur->next = new ListNode(x); cur = cur->next; }
auto ret = helper(head->next); while (ret) { cout << ret->val << " "; ret = ret->next; } cout << endl; return0; }
ListNode* helper(ListNode* head){ if (!head || !head->next) return head; ListNode* A = new ListNode(-1); ListNode* B = new ListNode(-1); ListNode* cur_A = A, *cur_B = B; auto base = head; head = head->next; while (head) { if (head->val < base->val) { cur_A->next = head; cur_A = head; } else { cur_B->next = head; cur_B = head; } head = head->next; } cur_A->next = NULL; cur_B->next = NULL; A->next = helper(A->next); B->next = helper(B->next); cur_A = A; while (cur_A->next) { cur_A = cur_A->next; } cur_A->next = base; base->next = B->next; return A->next; }
intmain(){ int n; cin >> n; ListNode* head = new ListNode(-1); ListNode* cur = head; for (int i = 0; i < n; i++) { int x; cin >> x; cur->next = new ListNode(x); cur = cur->next; } auto ret = helper(head->next); while (ret) { cout << ret->val << " "; ret = ret->next; } cout << endl; return0; }
// 类似于zeros and ones #include<iostream> #include<vector>
usingnamespacestd;
boolhelper(vector<int>& nums, int m, int s){ int n = nums.size(); if (n < m) returnfalse; vector<vector<bool>> dp(m + 1, vector<bool>(s + 1, false)); dp[0][0] = true;
for (auto num : nums) { for (int i = m; i >= 1; i --) { for (int j = s; j >= num; j--) { dp[i][j] = dp[i][j] || dp[i - 1][j - num]; } } } return dp[m][s]; }
intmain(){ int n; cin >> n; vector<int> nums(n, 0); for (int i = 0; i < n; i++) { cin >> nums[i]; }
int m, s; cin >> m >> s; cout << helper(nums, m, s) << endl; return0; }
vector<int> helper(vector<int>& nums) { int n = nums.size(); int ans = 0; vector<int> temp; vector<int> cur; int ret = INT_MIN; for (auto i : nums) { ans += i; if (ans < 0) { ans = 0; cur = vector<int>({}); } else { cur.push_back(i); if (ret < ans) { ret = ans; temp = cur; } } } return temp; }
intmain(){ int n; cin >> n; vector<int> nums(n, 0); for (int i = 0; i < n; i++) { cin >> nums[i]; } for (auto i : helper(nums)) { cout << i << endl; } return0; }
inthelper(vector<int>& nums){ int ret = 0; int limit = INT_MAX; for (auto i : nums) { if (!i) continue; else { limit = min(limit, i); ret ++; } } int ans = 1; while (ans * 2 <= limit) ret ++, ans *= 2; for (auto i : nums) { if (i) ret += i - ans; } return ret; }
intmain(){ int n; cin >> n; vector<int> nums(n, 0); for (int i = 0; i < n; i++) { cin >> nums[i]; } cout << helper(nums) << endl; return0; }
vector<int> helper(vector<vector<int>>& nums) { int m = nums.size(), n = nums[0].size(); int dir = 0; int a[4] = {0, 1, 0, -1}, b[4] = {1, 0, -1, 0}; int x = 0, y = 0; vector<int> ret; while (ret.size() < m * n) { if (nums[x][y] != INT_MAX) { ret.push_back(nums[x][y]); nums[x][y] = INT_MAX; } int X = x + a[dir], Y = y + b[dir]; if (X < m && X >= 0 && Y >= 0 && Y < n && nums[X][Y] != INT_MAX) { x = X, y = Y; } else dir = (dir + 1) % 4; } return ret; }
intmain(){ int m, n; cin >> m >> n; vector<vector<int>> nums(m, vector<int>(n, 0)); for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { cin >> nums[i][j]; } } for (auto i : helper(nums)) { cout << i << " "; } cout << endl; return0; }
voidheapfy(vector<pair<int, int>>& ans, vector<vector<int>>& nums, int index, int max){ int left = index * 2 + 1; int right = left + 1; int smallest = index; if (left < max && nums[ans[left].first][ans[left].second] < nums[ans[smallest].first][ans[smallest].second]) { smallest = left; } if (right < max && nums[ans[right].first][ans[right].second] < nums[ans[smallest].first][ans[smallest].second]) { smallest = right; } if (smallest != index) { swap(ans[index], ans[smallest]); heapfy(ans, nums, smallest, max); } }
vector<int> helper(vector<vector<int>>& nums) { int n = nums.size(); vector<pair<int, int>> ans; for (int i = 0; i < n; i++) { if (!nums[i].empty()) ans.push_back({i, 0}); } vector<int> ret; while (!ans.empty()) { ret.push_back(nums[ans[0].first][ans[0].second]); if (ans[0].second + 1 < nums[ans[0].first].size()) { ans[0].second ++; heapfy(ans, nums, 0, ans.size()); } else { ans[0] = ans.back(); ans.pop_back(); heapfy(ans, nums, 0, ans.size()); } } return ret; }
intmain(){ int k; cin >> k; vector<vector<int>> nums; for (int i = 0; i < k; i++) { int n; cin >> n; vector<int> ans(n, 0); for (int j = 0; j < n; j++) { cin >> ans[j]; } nums.push_back(ans); } for (auto i : helper(nums)) { cout << i << " "; } cout << endl; return0; }
usingnamespacestd; structTreeNode { string val; TreeNode* left; TreeNode* right; TreeNode(string s) : val(s), left(NULL), right(NULL) {} }; TreeNode* build(vector<string>& nums, int& index){ int n = nums.size(); if (index >= n) returnNULL; auto val = nums[index++]; if (val == "#") returnNULL; auto ret = new TreeNode(val); ret->left = build(nums, index); ret->right = build(nums, index); return ret; }
stringhelper1(TreeNode* root, string a, string b, bool& m){ if (!root) return""; if (root->val == a || root->val == b) m = true; bool ml = false, mr = false; string l = helper1(root->left, a, b, ml); if (ml) { if (m) return root->val; m = true; string r = helper1(root->right, a, b, mr); if (mr) return root->val; elsereturn l; } else { string r = helper1(root->right, a, b, mr); if (m && mr) return root->val; if (mr) { m = mr; return r; } elsereturn""; } }
stringhelper(vector<string>& nums, string a, string b){ int index = 0; auto root = build(nums, index); bool m = false; return helper1(root, a, b, m); }
intmain(){ int n; cin >> n; vector<string> nums; for (auto i = 0; i < n; i++) { string s; cin >> s; nums.push_back(s); } string a, b; cin >> a >> b; cout << helper(nums, a, b) << endl; return0; }
inthelper1(Iter a, int m, Iter b, int n, int k){ if (!n) return a[k - 1]; if (!m) return b[k - 1]; if (k == 1) return min(a[0], b[0]);
int l = min(k / 2, m); int r = min(k / 2, n); if (a[l - 1] < b[r - 1]) { return helper1(a + l, m - l, b, n, k - l); } else { return helper1(a, m, b + r, n - r, k - r); } }
voiddfs(vector<vector<int>>& ret, vector<int> nums, int index){ int n = nums.size(); if (n == index) ret.push_back(nums); for (int i = index; i < n; i++) { if (i != index && nums[i] == nums[index]) continue; swap(nums[index], nums[i]); dfs(ret, nums, index + 1); } }
classSolution { public: stringminWindow(string s, string t){ if (t.empty()) return""; unordered_map<char, int> m; for (auto i : t) { m[i] ++; } int ans = m.size(); int n = s.size(); int l = 0, r = 0; int len = INT_MAX; string ret; while (r <= n && l <= r) { if (ans > 0 && r < n) { auto key = s[r++]; if (m.find(key) != m.end()) { m[key] --; if (m[key] == 0) ans--; } } else { auto key = s[l++]; if (m.find(key) != m.end()) { m[key] ++; if (m[key] == 1) ans ++; } } if (!ans && r - l < len) { len = r - l; ret = s.substr(l, len); } } return ret; } };
inthelper1(int n){ int ret = n; while (ret * ret > n) { ret = (ret + n / ret) / 2; } return ret; } inthelper2(int n){ int left = 1, right = n; while (left <= right) { int mid = left + (right - left) / 2; if (mid + 1 > n / (mid + 1) && mid <= n / mid) return mid; if (mid < n / mid) left = mid + 1; else right = mid - 1; } return-1; }
vector<int> helper(vector<pair<int, int>>& nums, int n) { vector<unordered_set<int>> adj(n); for (auto i : nums) { if (i.first == i.second) continue; adj[i.first].insert(i.second); adj[i.second].insert(i.first); }
vector<vector<int>> cur; cur.push_back({0});
while (true) { vector<vector<int>> next; for (auto i : cur) { for (auto j : adj[i.back()]) { if (i.size() > 2 && j == 0) { i.push_back(0); return i; } if (find(i.begin(), i.end(), j) == i.end()) { auto temp = i; temp.push_back(j); next.push_back(temp); } } } if (next.empty()) break; cur = next; } returnvector<int>(); }
intmain(){ int n; cin >> n; int t; cin >> t; vector<pair<int, int>> nums; for (int i = 0; i < t; i++) { int x, y; cin >> x >> y; nums.push_back({x, y}); }
We are given a personal information string S, which may represent either an email address or a phone number.
We would like to mask this personal information according to the following rules:
Email address:
We define a name to be a string of length ≥ 2 consisting of only lowercase letters a-z or uppercase letters A-Z.
An email address starts with a name, followed by the symbol ‘@’, followed by a name, followed by the dot ‘.’ and followed by a name.
All email addresses are guaranteed to be valid and in the format of “name1@name2.name3“.
To mask an email, all names must be converted to lowercase and all letters between the first and last letter of the first name must be replaced by 5 asterisks ‘*’.
Phone number:
A phone number is a string consisting of only the digits 0-9 or the characters from the set {‘+’, ‘-‘, ‘(‘, ‘)’, ‘ ‘}. You may assume a phone number contains 10 to 13 digits.
The last 10 digits make up the local number, while the digits before those make up the country code. Note that the country code is optional. We want to expose only the last 4 digits and mask all other digits.
The local number should be formatted and masked as “--1111”, where 1 represents the exposed digits.
To mask a phone number with country code like “+111 111 111 1111”, we write it in the form “+--*-1111”. The ‘+’ sign and the first ‘-‘ sign before the local number should only exist if there is a country code. For example, a 12 digit phone number mask should start with “+-“.
Note that extraneous characters like “(“, “)”, “ “, as well as extra dashes or plus signs not part of the above formatting scheme should be removed.
Return the correct “mask” of the information provided.
Example 1:
1 2 3 4 5
Input: "LeetCode@LeetCode.com" Output: "l*****e@leetcode.com" Explanation: All names are converted to lowercase, and the letters between the first and last letter of the first name is replaced by 5 asterisks. Therefore, "leetcode" -> "l*****e".
Example 2:
1 2 3 4
Input: "AB@qq.com" Output: "a*****b@qq.com" Explanation: There must be 5 asterisks between the first and last letter of the first name "ab". Therefore, "ab" -> "a*****b".
Example 3:
1 2 3
Input: "1(234)567-890" Output: "***-***-7890" Explanation: 10 digits in the phone number, which means all digits make up the local number.
Example 4:
1 2 3
Input: "86-(10)12345678" Output: "+**-***-***-5678" Explanation: 12 digits, 2 digits for country code and 10 digits for local number.
classSolution { public: boolhelper(string s, int& cnt){ bool ret = false; for (auto i : s) { if (i == '@') ret = true; if (i >= '0' && i <= '9') cnt ++; } return ret; } stringmaskPII(string S){ int cnt = 0; if (!helper(S, cnt)) { string ret; string ans; int index = S.size() - 1; int c = 0; while (c < 4) { if (S[index] <= '9' && S[index] >= '0') { ans = S[index] + ans; c ++; } index --; } if (cnt > 10) { ret = "+"; for (int i = 0; i < cnt - 10; i++) ret += "*"; ret += "-***-***-"; } else ret = "***-***-"; ret += ans; return ret; } else { for (auto &i : S) { if (i >= 'A' && i <= 'Z') i = 'a' + (i - 'A'); } string ret; ret.push_back(S[0]); ret += "*****"; int index = 1; while (S[index + 1] != '@') index ++; while (index < S.size()) ret += S[index ++]; return ret; } } };
classSolution { public: intconsecutiveNumbersSum(int N){ int ret = 1; for (int i = 2; 2 * N - i * (i - 1) > 0; i++) { if ((2 * N - i * (i - 1)) % (2 * i) == 0) ret ++; } return ret; } };
A character is unique in string S if it occurs exactly once in it.
For example, in string S = “LETTER”, the only unique characters are “L” and “R”.
Let’s define UNIQ(S) as the number of unique characters in string S.
For example, UNIQ(“LETTER”) = 2.
Given a string S with only uppercases, calculate the sum of UNIQ(substring) over all non-empty substrings of S.
If there are two or more equal substrings at different positions in S, we consider them different.
Since the answer can be very large, return the answer modulo 10 ^ 9 + 7.
Example 1:
1 2 3 4 5
Input: "ABC" Output: 10 Explanation: All possible substrings are: "A","B","C","AB","BC" and "ABC". Evey substring is composed with only unique letters. Sum of lengths of all substring is 1 + 1 + 1 + 2 + 2 + 3 = 10
Example 2:
1 2 3
Input: "ABA" Output: 8 Explanation: The same as example 1, except uni("ABA") = 1.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
classSolution { public: intuniqueLetterString(string S){ longlong ret = 0; int n = S.size(); for (int i = 0; i < n; i++) { int l = i - 1, r = i + 1; while (l >= 0 && S[l] != S[i]) l--; while (r < n && S[r] != S[i]) r ++; ret += (longlong)(r - i) * (i - l); // 相乘表示从l->i和i->r所有子串的组合 } return ret % 1000000007; } };
Weekly Contest 82
824. Goat Latin [AC]
Leetcode 824 A sentence S is given, composed of words separated by spaces. Each word consists of lowercase and uppercase letters only.
We would like to convert the sentence to “Goat Latin” (a made-up language similar to Pig Latin.)
The rules of Goat Latin are as follows:
If a word begins with a vowel (a, e, i, o, or u), append “ma” to the end of the word. For example, the word ‘apple’ becomes ‘applema’.
If a word begins with a consonant (i.e. not a vowel), remove the first letter and append it to the end, then add “ma”. For example, the word “goat” becomes “oatgma”.
Add one letter ‘a’ to the end of each word per its word index in the sentence, starting with 1. For example, the first word gets “a” added to the end, the second word gets “aa” added to the end and so on. Return the final sentence representing the conversion from S to Goat Latin.
Example 1:
1 2
Input: "I speak Goat Latin" Output: "Imaa peaksmaaa oatGmaaaa atinLmaaaaa"
Example 2:
1 2
Input: "The quick brown fox jumped over the lazy dog" Output: "heTmaa uickqmaaa rownbmaaaa oxfmaaaaa umpedjmaaaaaa overmaaaaaaa hetmaaaaaaaa azylmaaaaaaaaa ogdmaaaaaaaaaa"
classSolution { public: boolhelper(char c){ if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U') returntrue; elsereturnfalse; } stringtoGoatLatin(string S){ string ret; string ans; int cnt = 1; for (auto i : S) { if (i != ' ') { ans.push_back(i); } else { if (ans.empty()) ans += " "; else { if (helper(ans[0])) { ans += "ma"; } else { char t = ans[0]; ans.erase(ans.begin()); ans.push_back(t); ans += "ma"; } for (int i = 0; i < cnt; i++) { ans += "a"; } cnt ++; } ret += " " + ans; ans = ""; } } if (helper(ans[0])) { ans += "ma"; } else { char t = ans[0]; ans.erase(ans.begin()); ans.push_back(t); ans += "ma"; } for (int i = 0; i < cnt; i++) { ans += "a"; } ret += " " + ans; ans = ""; ret.erase(ret.begin()); return ret; } };
classSolution { public: boolhelper(int a, int b){ if ((2 * b <= a + 14) || b > a || (b > 100 && a < 100)) returnfalse; elsereturntrue; } intnumFriendRequests(vector<int>& ages){ int ret = 0; int n = ages.size(); sort(ages.begin(), ages.end()); for (int i = 0; i < n; i++) { for (int j = i + 1; j < n; j++) { if (helper(ages[j], ages[i])) { cout << ages[j] << ages[i] << endl; ret ++; } } } if (ret && n == 2) return2; return ret; } };
We have jobs: difficulty[i] is the difficulty of the ith job, and profit[i] is the profit of the ith job.
Now we have some workers. worker[i] is the ability of the ith worker, which means that this worker can only complete a job with difficulty at most worker[i].
Every worker can be assigned at most one job, but one job can be completed multiple times.
For example, if 3 people attempt the same job that pays $1, then the total profit will be $3. If a worker cannot complete any job, his profit is $0.
What is the most profit we can make?
Example 1:
1 2 3
Input: difficulty = [2,4,6,8,10], profit = [10,20,30,40,50], worker = [4,5,6,7] Output: 100 Explanation: Workers are assigned jobs of difficulty [4,4,6,6] and they get profit of [20,20,30,30] seperately.
classSolution { public: intmaxProfitAssignment(vector<int>& difficulty, vector<int>& profit, vector<int>& worker){ int n = worker.size(), m = profit.size(); vector<pair<int, int>> nums; if (!n || !m) return0; for (int i = 0; i < m; i++) { nums.push_back(make_pair(difficulty[i], profit[i])); } sort(nums.begin(), nums.end()); int ret = 0; for (int i = 0; i < n; i++) { int ans = 0; for (int j = 0; j < m; j++) { if (worker[i] < nums[j].first) break; ans = max(ans, nums[j].second); } ret += ans; } return ret; } };
classSolution { public: int N; intlargestIsland(vector<vector<int>>& grid){ N = grid.size(); //DFS every island and give it an index of island int index = 2, res = 0; unordered_map <int, int>area; for (int x = 0; x < N; ++x) { for (int y = 0; y < N; ++y) { if (grid[x][y] == 1) { area[index] = dfs(grid, x, y, index); res = max(res, area[index++]); } } } //traverse every 0 cell and count biggest island it can conntect for (int x = 0; x < N; ++x) for (int y = 0; y < N; ++y) if (grid[x][y] == 0) { unordered_set<int> seen = {}; int cur = 1; for (auto p : move(x, y)) { index = grid[p.first][p.second]; if (index > 1 && seen.count(index) == 0) { seen.insert(index); cur += area[index]; } } res = max(res, cur); } return res; }
vector<pair<int, int>> move(int x, int y) { vector<pair<int, int>> res; for (auto p : vector<vector<int>> {{1, 0}, {-1, 0}, {0, 1}, {0, -1}}) { if (valid(x + p[0], y + p[1])) res.push_back(make_pair(x + p[0], y + p[1])); } return res; }
intvalid(int x, int y){ return0 <= x && x < N && 0 <= y && y < N; }
intdfs(vector<vector<int>>& grid, int x, int y, int index){ int area = 0; grid[x][y] = index; for (auto p : move(x, y)) if (grid[p.first][p.second] == 1) area += dfs(grid, p.first, p.second, index); return area + 1; } };
Weekly Contest 81
821. Shortest Distance to a Character [AC]
Leetcode 821 Given a string S and a character C, return an array of integers representing the shortest distance from the character C in the string.
Example 1:
1 2
Input: S = "loveleetcode", C = 'e' Output: [3, 2, 1, 0, 1, 0, 0, 1, 2, 2, 1, 0]
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
classSolution { public: vector<int> shortestToChar(string S, char C) { int n = S.size(); vector<int> res(n, n); int pos = -n; for (int i = 0; i < n; ++i) { if (S[i] == C) pos = i; res[i] = min(res[i], abs(i - pos)); } for (int i = n - 1; i >= 0; --i) { if (S[i] == C) pos = i; res[i] = min(res[i], abs(i - pos)); } return res; } };
On a table are N cards, with a positive integer printed on the front and back of each card (possibly different).
We flip any number of cards, and after we choose one card.
If the number X on the back of the chosen card is not on the front of any card, then this number X is good.
What is the smallest number that is good? If no number is good, output 0.
Here, fronts[i] and backs[i] represent the number on the front and back of card i.
A flip swaps the front and back numbers, so the value on the front is now on the back and vice versa.
Example:
1 2 3 4
Input: fronts = [1,2,4,4,7], backs = [1,3,4,1,3] Output: 2 Explanation: If we flip the second card, the fronts are [1,3,4,4,7] and the backs are [1,2,4,1,3]. We choose the second card, which has number 2 on the back, and it isn't on the front of any card, so 2 is good.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
classSolution { public: intflipgame(vector<int>& fronts, vector<int>& backs){ unordered_set<int> same; int n = fronts.size(); for (int i = 0; i < n; i++) { if (fronts[i] == backs[i]) same.insert(fronts[i]); } int ret = INT_MAX; for (auto i : fronts) { if (same.find(i) == same.end()) ret = min(ret, i); } for (auto i : backs) { if (same.find(i) == same.end()) ret = min(ret, i); } return ret == INT_MAX ? 0 : ret; } };
820. Short Encoding of Words [AC]
Leetcode 820 Given a list of words, we may encode it by writing a reference string S and a list of indexes A.
For example, if the list of words is [“time”, “me”, “bell”], we can write it as S = “time#bell#” and indexes = [0, 2, 5].
Then for each index, we will recover the word by reading from the reference string from that index until we reach a “#” character.
What is the length of the shortest reference string S possible that encodes the given words?
Example:
1 2 3
Input: words = ["time", "me", "bell"] Output: 10 Explanation: S = "time#bell#" and indexes = [0, 2, 5].
1 2 3 4 5 6 7 8 9 10 11 12 13 14
classSolution { public: intminimumLengthEncoding(vector<string>& words){ unordered_set<string> s(words.begin(), words.end()); for (auto w : words) { for (int i = 1; i < w.size(); i++) { s.erase(w.substr(i)); } } int ret = 0; for (auto i : s) ret += i.size() + 1; return ret; } };
Given a paragraph and a list of banned words, return the most frequent word that is not in the list of banned words. It is guaranteed there is at least one word that isn’t banned, and that the answer is unique.
Words in the list of banned words are given in lowercase, and free of punctuation. Words in the paragraph are not case sensitive. The answer is in lowercase.
Example:
1 2 3 4 5 6 7 8 9 10
Input: paragraph = "Bob hit a ball, the hit BALL flew far after it was hit." banned = ["hit"] Output: "ball" Explanation: "hit" occurs 3 times, but it is a banned word. "ball" occurs twice (and no other word does), so it is the most frequent non-banned word in the paragraph. Note that words in the paragraph are not case sensitive, that punctuation is ignored (even if adjacent to words, such as "ball,"), and that "hit" isn't the answer even though it occurs more because it is banned.
We are given head, the head node of a linked list containing unique integer values.
We are also given the list G, a subset of the values in the linked list.
Return the number of connected components in G, where two values are connected if they appear consecutively in the linked list.
Example 1:
1 2 3 4 5 6
Input: head: 0->1->2->3 G = [0, 1, 3] Output: 2 Explanation: 0 and 1 are connected, so [0, 1] and [3] are the two connected components.
Example 2:
1 2 3 4 5 6
Input: head: 0->1->2->3->4 G = [0, 3, 1, 4] Output: 2 Explanation: 0 and 1 are connected, 3 and 4 are connected, so [0, 1] and [3, 4] are the two connected components.
We had some 2-dimensional coordinates, like “(1, 3)” or “(2, 0.5)”. Then, we removed all commas, decimal points, and spaces, and ended up with the string S. Return a list of strings representing all possibilities for what our original coordinates could have been.
Our original representation never had extraneous zeroes, so we never started with numbers like “00”, “0.0”, “0.00”, “1.0”, “001”, “00.01”, or any other number that can be represented with less digits. Also, a decimal point within a number never occurs without at least one digit occuring before it, so we never started with numbers like “.1”.
The final answer list can be returned in any order. Also note that all coordinates in the final answer have exactly one space between them (occurring after the comma.)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Example 1: Input: "(123)" Output: ["(1, 23)", "(12, 3)", "(1.2, 3)", "(1, 2.3)"] Example 2: Input: "(00011)" Output: ["(0.001, 1)", "(0, 0.011)"] Explanation: 0.0, 00, 0001 or 00.01 are not allowed. Example 3: Input: "(0123)" Output: ["(0, 123)", "(0, 12.3)", "(0, 1.23)", "(0.1, 23)", "(0.1, 2.3)", "(0.12, 3)"] Example 4: Input: "(100)" Output: [(10, 0)] Explanation: 1.0 is not allowed.
Your car starts at position 0 and speed +1 on an infinite number line. (Your car can go into negative positions.)
Your car drives automatically according to a sequence of instructions A (accelerate) and R (reverse).
When you get an instruction “A”, your car does the following: position += speed, speed *= 2.
When you get an instruction “R”, your car does the following: if your speed is positive then speed = -1 , otherwise speed = 1. (Your position stays the same.)
For example, after commands “AAR”, your car goes to positions 0->1->3->3, and your speed goes to 1->2->4->-1.
Now for some target position, say the length of the shortest sequence of instructions to get there.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Example 1: Input: target = 3 Output: 2 Explanation: The shortest instruction sequence is "AA". Your position goes from 0->1->3.
Example 2: Input: target = 6 Output: 5 Explanation: The shortest instruction sequence is "AAARA". Your position goes from 0->1->3->7->7->6.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
classSolution { public: int dp[10001]; intracecar(int t){ if (dp[t] > 0) return dp[t]; int n = floor(log2(t)) + 1, res; if (1 << n == t + 1) dp[t] = n; else { dp[t] = racecar((1 << n) - 1 - t) + n + 1; for (int m = 0; m < n - 1; ++m) dp[t] = min(dp[t], racecar(t - (1 << (n - 1)) + (1 << m)) + n + m + 1); } return dp[t]; } };
A rectangle is represented as a list [x1, y1, x2, y2], where (x1, y1) are the coordinates of its bottom-left corner, and (x2, y2) are the coordinates of its top-right corner.
Two rectangles overlap if the area of their intersection is positive. To be clear, two rectangles that only touch at the corner or edges do not overlap.
Given two (axis-aligned) rectangles, return whether they overlap.
There are N dominoes in a line, and we place each domino vertically upright.
In the beginning, we simultaneously push some of the dominoes either to the left or to the right.
After each second, each domino that is falling to the left pushes the adjacent domino on the left.
Similarly, the dominoes falling to the right push their adjacent dominoes standing on the right.
When a vertical domino has dominoes falling on it from both sides, it stays still due to the balance of the forces.
For the purposes of this question, we will consider that a falling domino expends no additional force to a falling or already fallen domino.
Given a string “S” representing the initial state. S[i] = ‘L’, if the i-th domino has been pushed to the left; S[i] = ‘R’, if the i-th domino has been pushed to the right; S[i] = ‘.’, if the i-th domino has not been pushed.
Return a string representing the final state.
Example 1:
1 2
Input: ".L.R...LR..L.." Output: "LL.RR.LLRRLL.."
Example 2:
1 2 3
Input: "RR.L" Output: "RR.L" Explanation: The first domino expends no additional force on the second domino.
Alice plays the following game, loosely based on the card game “21”.
Alice starts with 0 points, and draws numbers while she has less than K points. During each draw, she gains an integer number of points randomly from the range [1, W], where W is an integer. Each draw is independent and the outcomes have equal probabilities.
Alice stops drawing numbers when she gets K or more points. What is the probability that she has N or less points?
Example 1:
1 2 3
Input: N = 10, K = 1, W = 10 Output: 1.00000 Explanation: Alice gets a single card, then stops.
Example 2:
1 2 3 4
Input: N = 6, K = 1, W = 10 Output: 0.60000 Explanation: Alice gets a single card, then stops. In 6 out of W = 10 possibilities, she is at or below N = 6 points.
Example 3:
1 2
Input: N = 21, K = 17, W = 10 Output: 0.73278
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
classSolution{ publicdoublenew21Game(int N, int K, int W){ double[] dp = newdouble[N+3]; dp[0] = 1; dp[1] = -1; double val = 0; for(int i = 0;i < K;i++){ val += dp[i]; if(i+1 <= N)dp[i+1] += val / W; if(i+W+1 <= N)dp[i+W+1] -= val / W; } double ret = 0; for(int i = K;i <= N;i++){ val += dp[i]; ret += val; } return ret; } }
Two strings X and Y are similar if we can swap two letters (in different positions) of X, so that it equals Y.
For example, “tars” and “rats” are similar (swapping at positions 0 and 2), and “rats” and “arts” are similar, but “star” is not similar to “tars”, “rats”, or “arts”.
Together, these form two connected groups by similarity: {“tars”, “rats”, “arts”} and {“star”}. Notice that “tars” and “arts” are in the same group even though they are not similar. Formally, each group is such that a word is in the group if and only if it is similar to at least one other word in the group.
We are given a list A of strings. Every string in A is an anagram of every other string in A. How many groups are there?
// 并查集 classSolution { public: boolhelper(string a, string b){ if (a == b) returntrue; if (a.size() != b.size()) returnfalse; if (a.empty()) returntrue; int cnt = 0; char x1 = '\0', y1 = '\0', x2 = '\0', y2 = '\0'; for (int i = 0; i < a.size(); i++) { if (a[i] == b[i]) continue; cnt ++; if (cnt == 1) x1 = a[i], y1 = b[i]; if (cnt == 2) x2 = a[i], y2 = b[i]; } return cnt == 2 && x1 == y2 && x2 == y1; } intMyFind(vector<int>& nums, int x){ int y = x; while (nums[x] != x) { x = nums[x]; } while (x != y) { int t = nums[y]; nums[y] = x; y = t; } return x; } voidMyMerge(vector<int>& nums, int x, int y){ int p1 = MyFind(nums, x); int p2 = MyFind(nums, y); if (p1 != p2) nums[p1] = p2; } intnumSimilarGroups(vector<string>& A){ int n = A.size(); if (!n) return0; vector<int> nums(n, 0); for (int i = 0; i < n; i++) { nums[i] = i; } for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (i == j) continue; if (helper(A[i], A[j])) MyMerge(nums, i, j); } } int ret = 0; for (int i = 0; i < n; i++) { if (MyFind(nums, i) == i) ret ++; } return ret; } };
Given a binary matrix A, we want to flip the image horizontally, then invert it, and return the resulting image.
To flip an image horizontally means that each row of the image is reversed. For example, flipping [1, 1, 0] horizontally results in [0, 1, 1].
To invert an image means that each 0 is replaced by 1, and each 1 is replaced by 0. For example, inverting [0, 1, 1] results in [1, 0, 0].
Example 1:
1 2 3 4
Input: [[1,1,0],[1,0,1],[0,0,0]] Output: [[1,0,0],[0,1,0],[1,1,1]] Explanation: First reverse each row: [[0,1,1],[1,0,1],[0,0,0]]. Then, invert the image: [[1,0,0],[0,1,0],[1,1,1]]
Example 2:
1 2 3 4
Input: [[1,1,0,0],[1,0,0,1],[0,1,1,1],[1,0,1,0]] Output: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]] Explanation: First reverse each row: [[0,0,1,1],[1,0,0,1],[1,1,1,0],[0,1,0,1]]. Then invert the image: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
classSolution { public: vector<vector<int>> flipAndInvertImage(vector<vector<int>>& A) { int m = A.size(), n = A[0].size(); for (int i = 0; i < m; i++) { for (int j = 0; j < n / 2; j++) { swap(A[i][j], A[i][n - 1 - j]); } } for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { A[i][j] ^= 1; } } return A; } };
To some string S, we will perform some replacement operations that replace groups of letters with new ones (not necessarily the same size).
Each replacement operation has 3 parameters: a starting index i, a source word x and a target word y. The rule is that if x starts at position i in the original string S, then we will replace that occurrence of x with y. If not, we do nothing.
For example, if we have S = “abcd” and we have some replacement operation i = 2, x = “cd”, y = “ffff”, then because “cd” starts at position 2 in the original string S, we will replace it with “ffff”.
Using another example on S = “abcd”, if we have both the replacement operation i = 0, x = “ab”, y = “eee”, as well as another replacement operation i = 2, x = “ec”, y = “ffff”, this second operation does nothing because in the original string S[2] = ‘c’, which doesn’t match x[0] = ‘e’.
All these operations occur simultaneously. It’s guaranteed that there won’t be any overlap in replacement: for example, S = “abc”, indexes = [0, 1], sources = [“ab”,”bc”] is not a valid test case.
Example 1:
1 2 3 4
Input: S = "abcd", indexes = [0,2], sources = ["a","cd"], targets = ["eee","ffff"] Output: "eeebffff" Explanation: "a" starts at index 0 in S, so it's replaced by "eee". "cd" starts at index 2 in S, so it's replaced by "ffff".
Example 2:
1 2 3 4
Input: S = "abcd", indexes = [0,2], sources = ["ab","ec"], targets = ["eee","ffff"] Output: "eeecd" Explanation: "ab" starts at index 0 in S, so it's replaced by "eee". "ec" doesn't starts at index 2 in the original S, so we do nothing.
classSolution { public: boolstaticcmp(pair<int, int>& a, pair<int, int>& b){ return a.first < b.first; } stringhelper(string s, vector<pair<int, int>>& m, vector<string>& src, vector<string>& targets){ string ret = ""; int n = s.size(); for (int i = 0; i < n; i++) { if (!m.empty() && i == m[0].first) { auto t = m[0]; m.erase(m.begin()); string a = src[t.second], b = targets[t.second]; if (i + a.size() <= n && a == s.substr(i, a.size())) { ret += b; i += a.size() - 1; continue; } } ret.push_back(s[i]); } return ret; } stringfindReplaceString(string S, vector<int>& indexes, vector<string>& sources, vector<string>& targets){ vector<pair<int, int>> m; int n = indexes.size(); for (int i = 0; i < n; i++) m.push_back(make_pair(indexes[i], i)); sort(m.begin(), m.end(), cmp); return helper(S, m, sources, targets); } };
Two images A and B are given, represented as binary, square matrices of the same size. (A binary matrix has only 0s and 1s as values.)
We translate one image however we choose (sliding it left, right, up, or down any number of units), and place it on top of the other image. After, the overlap of this translation is the number of positions that have a 1 in both images.
(Note also that a translation does not include any kind of rotation.)
What is the largest possible overlap?
Example 1:
1 2 3 4 5 6 7 8
Input: A = [[1,1,0], [0,1,0], [0,1,0]] B = [[0,0,0], [0,1,1], [0,0,1]] Output: 3 Explanation: We slide A to right by 1 unit and down by 1 unit.
classSolution { public: stringconvert(int i, int j){ return to_string(i) + "-" + to_string(j); } voidhelper(int i, int j, vector<vector<int>>& A, vector<vector<int>>& B, int& ret, unordered_set<string>& hash){ int m = A.size(), n = A[0].size(); if (i <= -m || i >= m || j <= -n || j >= n) return; int ans = 0; for (int x = 0; x < m; x ++) { for (int y = 0; y < n; y++) { int X = x + i, Y = y + j; if (X < m && X >= 0 && Y < n && Y >= 0 && A[X][Y] == 1 && B[x][y] == 1) ans ++; } } ret = max(ret, ans); int a[4] = {0, 0, -1, 1}, b[4] = {1, -1, 0, 0}; for (int k = 0; k < 4; k++) { int x = i + a[k], y = j + b[k]; auto s = convert(x, y); if (hash.find(s) != hash.end()) continue; hash.insert(s); helper(x, y, A, B, ret, hash); } } intlargestOverlap(vector<vector<int>>& A, vector<vector<int>>& B){ int ret = 0; unordered_set<string> m; m.insert("0-0"); helper(0, 0, A, B, ret, m); return ret; } };
An undirected, connected tree with N nodes labelled 0…N-1 and N-1 edges are given.
The ith edge connects nodes edges[i][0] and edges[i][1] together.
Return a list ans, where ans[i] is the sum of the distances between node i and all other nodes.
Example 1:
1 2 3 4 5 6 7 8 9 10 11
Input: N = 6, edges = [[0,1],[0,2],[2,3],[2,4],[2,5]] Output: [8,12,6,10,10,10] Explanation: Here is a diagram of the given tree: 0 / \ 1 2 /|\ 3 4 5 We can see that dist(0,1) + dist(0,2) + dist(0,3) + dist(0,4) + dist(0,5) equals 1 + 1 + 2 + 2 + 2 = 8. Hence, answer[0] = 8, and so on.
// 后用dfs保存中间状态AC constint N = 1e4 + 10; vector<int> a[N]; int dp0[N], dp1[N];
voidDFS(int u, int parent){ dp0[u] = 1; dp1[u] = 0; for (auto& v : a[u]) { if (v == parent) continue; DFS(v, u); dp0[u] += dp0[v]; dp1[u] += dp1[v] + dp0[v]; } }
voidDFS2(int u, int parent, int n, vector<int>& ret){ for (auto& v : a[u]) { if (v == parent) continue; ret[v] = ret[u] + (n - dp0[v]) - (dp0[v]); // cout << u << " " << v << " " << ret[u] << " " << dp0[u] << " " << dp0[v] << " " << ret[v] << endl; DFS2(v, u, n, ret); } }
classSolution { public: vector<int> sumOfDistancesInTree(int n, vector<vector<int>>& edges) { for (int i = 0; i < n; ++i) a[i].clear(); for (auto& it : edges) { int x = it[0], y = it[1]; a[x].push_back(y); a[y].push_back(x); } DFS(0, -1); vector<int> ret(n); ret[0] = dp1[0]; DFS2(0, -1, n, ret); return ret; } };
Given a singly linked list, return a random node’s value from the linked list. Each node must have the same probability of being chosen.
Follow up:
What if the linked list is extremely large and its length is unknown to you? Could you solve this efficiently without using extra space?
Example:
1 2 3 4 5 6 7 8
// Init a singly linked list [1,2,3]. ListNode head = new ListNode(1); head.next = new ListNode(2); head.next.next = new ListNode(3); Solution solution = new Solution(head);
// getRandom() should return either 1, 2, or 3 randomly. Each element should have equal probability of returning. solution.getRandom();
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ classSolution { public: ListNode* root; /** @param head The linked list's head. Note that the head is guaranteed to be not null, so it contains at least one node. */ Solution(ListNode* head) { root = head; } /** Returns a random node's value. */ intgetRandom(){ if (!root) return-1; int ret = root->val; ListNode* cur = root->next; int cnt = 2; while (cur) { int k = rand() % cnt; cnt ++; if (!k) ret = cur->val; cur = cur->next; } return ret; } };
/** * Your Solution object will be instantiated and called as such: * Solution obj = new Solution(head); * int param_1 = obj.getRandom(); */
Given an array of integers with possible duplicates, randomly output the index of a given target number. You can assume that the given target number must exist in the array.
Note: The array size can be very large. Solution that uses too much extra space will not pass the judge.
Example:
1 2 3 4 5 6 7 8
int[] nums = new int[] {1,2,3,3,3}; Solution solution = new Solution(nums);
// pick(3) should return either index 2, 3, or 4 randomly. Each index should have equal probability of returning. solution.pick(3);
// pick(1) should return 0. Since in the array only nums[0] is equal to 1. solution.pick(1);
You are given an integer array nums and you have to return a new counts array. The counts array has the property where counts[i] is the number of smaller elements to the right of nums[i].
Example:
1 2 3 4 5 6 7
Input: [5,2,6,1] Output: [2,1,1,0] Explanation: To the right of 5 there are 2 smaller elements (2 and 1). To the right of 2 there is only 1 smaller element (1). To the right of 6 there is 1 smaller element (1). To the right of 1 there is 0 smaller element.
Given an array of n positive integers and a positive integer s, find the minimal length of a contiguous subarray of which the sum ≥ s. If there isn’t one, return 0 instead.
Example:
1 2 3
Input: s = 7, nums = [2,3,1,2,4,3] Output: 2 Explanation: the subarray [4,3] has the minimal length under the problem constraint.
1 2 3 4 5 6 7 8 9 10 11 12 13
classSolution { public: intminSubArrayLen(int s, vector<int>& nums){ int ret = INT_MAX; int n = nums.size(), left = 0, right = 0, ans = 0; while (right < n) { ans += nums[right++]; while (left < right && ans - nums[left] >= s) ans -= nums[left++]; if (ans >= s) ret = min(ret, right - left); } return ret == INT_MAX ? 0 : ret; } };
inthelper(int target, vector<int>& nums){ int ret = INT_MAX; unordered_map<int, int> m; int ans = 0; for (int i = 0; i < nums.size(); i++) { ans += nums[i]; int t = target - ans; m[ans] = i; if (m.count(t)) { ret = min(ret, i - m[t]); } } return ret == INT_MAX ? 0 : ret; }
intmain(){ int target, n; cin >> target >> n; vector<int> nums(n, 0); for (int i = 0; i < n; i++) { cin >> nums[i]; } cout << helper(target, nums) << endl; return0; }
intpartition(vector<int>& nums, int left, int right){ int base = nums[left]; while (left < right) { while (left < right && nums[right] >= base) right --; if (left < right) nums[left] = nums[right]; while (left < right && nums[left] < base) left ++; if (left < right) nums[right] = nums[left]; } nums[left] = base; return left; }
voidhelper(vector<int>& nums, int left, int right){ if (left < right) { int mid = partition(nums, left, right); helper(nums, left, mid); helper(nums, mid + 1, right); }
}
intmain(){ int n; cin >> n; vector<int> nums(n, 0); for (int i = 0; i < n; i++) { cin >> nums[i]; } helper(nums, 0, n); for (auto i : nums) { cout << i << endl; } return0; }
intpartition(vector<int>& nums, int left, int right){ int base = nums[left]; while (left < right) { while (left < right && nums[right] >= base) right --; if (left < right) nums[left] = nums[right]; while (left < right && nums[left] < base) left ++; if (left < right) nums[right] = nums[left]; } nums[left] = base; return left; }
voidhelper(vector<int>& nums, int left, int right){ if (left < right) { // 随机产生基准 int index = left + rand() % (right - left + 1); swap(nums[left], nums[right]); int mid = partition(nums, left, right); helper(nums, left, mid - 1); helper(nums, mid + 1, right); } }
intmain(){ int n; cin >> n; vector<int> nums(n, 0); for (int i = 0; i < n; i++) { cin >> nums[i]; } helper(nums, 0, n - 1); for (int i : nums) { cout << i << endl; } return0; }
intpartition(vector<int>& nums, int left, int right){ int base = nums[left]; while (left < right) { while (left < right && nums[right] <= base) right--; if (left < right) nums[left] = nums[right]; while (left < right && nums[left] > base) left ++; if (left < right) nums[right] = nums[left]; } nums[left] = base; return left; }
inthelper(vector<int>& nums, int left, int right, int k){ if (left <= right) { int mid = partition(nums, left, right); if (mid == k - 1) return nums[mid]; if (mid < k - 1) return helper(nums, mid + 1, right, k); elsereturn helper(nums, left, mid - 1, k); } return-1; }
intfindKthLargest(vector<int>& nums, int k){ int n = nums.size(); if (n < k) return-1; return helper(nums, 0, n - 1, k); }
intmain(){ int n, k; cin >> n >> k; vector<int> nums(n, 0); for (int i = 0; i < n; i++) { cin >> nums[i]; } cout << findKthLargest(nums, k) << endl; return0; }
inthelper(vector<int>& nums){ int ans = 0, n = nums.size(); int ret = INT_MIN; for (int i = 0; i < n; i++) { ans += nums[i]; ret = max(ret, ans); if (ans <= 0) ans = 0; } return ret; }
intmain(){ int n; cin >> n; vector<int> nums(n, 0); for (int i = 0; i < n; i++) { cin >> nums[i]; } cout << helper(nums) << endl; return0; }
intfind(vector<int>& nums, int x){ int y = x; while (nums[x] != x) { x = nums[x]; } while (y != x) { int t = nums[y]; nums[y] = x; y = t; } return x; }
voidmerge(vector<int>& nums, int x, int y){ int p1 = find(nums, x); int p2 = find(nums, y); if (p1 != p2) { nums[p1] = p2; } }
intmain(){ int n, k; cin >> n >> k; vector<int> nums(n, 0); for (int i = 0; i < n; i++) nums[i] = i; for (int i = 0; i < k; i++) { int x, y; cin >> x >> y; merge(nums, x, y); } int ret = 0; for (int i = 0; i < n; i++) { if (i == find(nums, i)) ret ++; } cout << ret << endl; return0; }
voidheapfy(vector<int>& nums, int index, int max){ int left = index * 2 + 1; int right = left + 1; int smallest = index; if (left < max && nums[left] < nums[smallest]) smallest = left; if (right < max && nums[right] < nums[smallest]) smallest = right; if (smallest != index) { swap(nums[index], nums[smallest]); heapfy(nums, smallest, max); } }
inthelper(vector<int>& nums, int k){ int n = nums.size(); if (n < k) return-1; vector<int> ans; for (int i = 0; i < k; i++) { ans.push_back(nums[i]); } for (int i = k / 2 - 1; i >= 0; i--) heapfy(ans, i, k); for (int i = k; i < n; i++) { if (nums[i] < ans[0]) continue; ans[0] = nums[i]; for (int j = k / 2 - 1; j >= 0; j--) heapfy(ans, j, k); } return ans[0]; }
intmain(){ int n, k; cin >> n >> k; vector<int> nums(n, 0); for (int i = 0; i < n; i++) { cin >> nums[i]; } cout << helper(nums, k) << endl; return0; }
vector<vector<int>> helper(vector<unordered_set<int>>& adj, vector<int>& cnt) { int n = cnt.size(); unordered_set<int> m; vector<int> cur; vector<vector<int>> ret; for (int i = 0; i < n; i++) { if (!cnt[i]) { cur.push_back(i); m.insert(i); } } while (true) { ret.push_back(cur); vector<int> next; for (auto i : cur) { for (auto j : adj[i]) { cnt[j]--; if (!cnt[j]) { if (m.find(j) != m.end()) returnvector<vector<int>>(); next.push_back(j); m.insert(j); } } } if (next.empty()) break; else cur = next; } if (n != m.size()) returnvector<vector<int>>(); return ret; }
intmain(){ int n, k; cin >> n >> k; vector<int> cnt(n, 0); vector<unordered_set<int>> adj(n); for (int i = 0; i < k; i++) { int x, y; cin >> x >> y; cnt[y]++; adj[x].insert(y); } auto ret = helper(adj, cnt); for (auto i : ret) { for (auto j : i) { cout << j << " "; } cout << endl; } return0; }
Implement pow(x, n), which calculates x raised to the power n (xn).
1 2
Input: 2.00000, 10 Output: 1024.00000
代码
1 2 3 4 5 6 7 8 9 10 11 12 13 14
classSolution { public: doublemyPow(double x, int n){ double ret = 1.0; // 注意要整型溢出 long N = abs((long) n); while (N) { if (N & 1) ret *= x; N >>= 1; x *= x; } return n > 0 ? ret : 1 / ret; } };
vector<vector<int>> mul(vector<vector<int>>& A, vector<vector<int>>& B) { int n = A.size(); vector<vector<int>> ret(n, vector<int>(n, 0)); for (int i = 0;i < n; i++) { for (int j = 0; j < n; j++) { for (int k = 0; k < n; k++) { ret[i][j] += A[i][k] * B[k][j]; ret[i][j] %= MOD; } } } return ret; }
vector<vector<int>> Qpow(vector<vector<int>> nums, int k) { int n = nums.size(); cout << n << endl; vector<vector<int>> ret(n, vector<int>(n, 0)); for (int i = 0; i < n; i++) { ret[i][i] = 1; } while (k) { if (k & 1) ret = mul(ret, nums); nums = mul(nums, nums); k >>= 1; } return ret; }
intmain(){ int n, k; cin >> n >> k; vector<vector<int>> nums(n, vector<int>(n, 0)); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { cin >> nums[i][j]; } } auto ret = Qpow(nums, k); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { cout << ret[i][j] << " "; } cout << endl; } return0; }
string getPermutation(int n, int k) { long long ans[n + 1] = {1}; string ret; vector<int> nums; for (int i = 1; i <= n; i++) { ans[i] = ans[i - 1] * i; nums.push_back(i); } for (int i = 0; i < n; i++) { int index = (k - 1) / ans[n - i - 1]; ret += to_string(nums[index]); nums.erase(nums.begin() + index); k = k - ans[n - i - 1] * index; } return ret; }
字母全排列
数字可以用上面的方法，但是对于字母来说就不行了，因为long long也存不下所有全排列的种类数
第二个思路是使用nextPermutation，此函数的原理是
从最后向前找相邻的两个元素是的i < ii
然后再从最后向前找一个元素使得i < j
i和j交换，然后将ii之后的元素reverse排序
nextPermutation的头文件是algorithm
1 2 3 4 5 6 7 8 9 10
stringgetPermutation(int n, int k){ string ret; for (int i = 1; i <= n; i++) { ret += to_string(i); } for (int i = 1; i < k; i++) { next_permutation(ret.begin(), ret.end()); } return ret; }
inthelper(vector<unordered_set<int>>& adj){ int n = adj.size(); int ret = 0; vector<int> cur; for (int i = 0; i < n; i++) { if (adj[i].size() == 1) cur.push_back(i); } while (true) { ret ++; vector<int> next; for (auto i : cur) { for (auto j : adj[i]) { adj[j].erase(i); if (adj[j].size() == 1) next.push_back(j); } } if (next.empty()) break; else cur = next; } if (cur.size() == 1) return2 *(ret - 1); elsereturn2 * (ret - 1) + 1; }
intmain(){ int n, k, d; cin >> n >> k >> d; vector<unordered_set<int>> adj(n, unordered_set<int>()); for (int i = 0; i < k; i++) { int x, y; cin >> x >> y; adj[x].insert(y); adj[y].insert(x); } int len = helper(adj), ret; if (len >= d) ret = d; else ret = len + (d - len) * 2; cout << ret << endl; return0; }
inthelper(vector<int>& nums){ int n = nums.size(), ret = 0; for (int i = 0; i <= n; i++) { int left = 0, right = 0; for (int j = 0; j < i; j++) { left += (i - j) * nums[j]; } for (int j = i; j < n; j++) { right += (j - i + 1) * nums[j]; } if (left == right) ret ++; } return ret; }
intmain(){ int n; cin >> n; vector<int> nums(n, 0); for (int i = 0; i < n; i++) { cin >> nums[i]; } cout << helper(nums) << endl; return0; }
Given an array of non-negative integers, you are initially positioned at the first index of the array.
Each element in the array represents your maximum jump length at that position.
Determine if you are able to reach the last index.
Example 1:
1 2 3
Input: [2,3,1,1,4] Output: true Explanation: Jump 1 step from index 0 to 1, then 3 steps to the last index.
Example 2:
1 2 3 4
Input: [3,2,1,0,4] Output: false Explanation: You will always arrive at index 3 no matter what. Its maximum jump length is 0, which makes it impossible to reach the last index.
1 2 3 4 5 6 7 8 9 10 11
classSolution { public: boolcanJump(vector<int>& nums){ if (nums.empty()) returntrue; int n = nums.size(), reach = 0, index = 0; for (index = 0; index < n && index <= reach; index ++) { reach = max(reach, index + nums[index]); } return reach >= n - 1; } };
Suppose you have a random list of people standing in a queue. Each person is described by a pair of integers (h, k), where h is the height of the person and k is the number of people in front of this person who have a height greater than or equal to h. Write an algorithm to reconstruct the queue.
There are a number of spherical balloons spread in two-dimensional space. For each balloon, provided input is the start and end coordinates of the horizontal diameter. Since it’s horizontal, y-coordinates don’t matter and hence the x-coordinates of start and end of the diameter suffice. Start is always smaller than end. There will be at most 104 balloons.
An arrow can be shot up exactly vertically from different points along the x-axis. A balloon with xstart and xend bursts by an arrow shot at x if xstart ≤ x ≤ xend. There is no limit to the number of arrows that can be shot. An arrow once shot keeps travelling up infinitely. The problem is to find the minimum number of arrows that must be shot to burst all balloons.
Example:
1 2 3 4 5 6 7 8
Input: [[10,16], [2,8], [1,6], [7,12]]
Output: 2
Explanation: One way is to shoot one arrow for example at x = 6 (bursting the balloons [2,8] and [1,6]) and another arrow at x = 11 (bursting the other two balloons).
Given a non-negative integer num represented as a string, remove k digits from the number so that the new number is the smallest possible.
Note:
The length of num is less than 10002 and will be ≥ k.
The given num does not contain any leading zero.
Example 1:
1 2 3
Input: num = "1432219", k = 3 Output: "1219" Explanation: Remove the three digits 4, 3, and 2 to form the new number 1219 which is the smallest.
Example 2:
1 2 3
Input: num = "10200", k = 1 Output: "200" Explanation: Remove the leading 1 and the number is 200. Note that the output must not contain leading zeroes.
Example 3:
1 2 3
Input: num = "10", k = 2 Output: "0" Explanation: Remove all the digits from the number and it is left with nothing which is 0.
inthelper(vector<pair<int, int>>& nums){ int n = nums.size(); vector<int> p(n + 1, 0); for (int i = 0; i < n; i++) { p[i] = nums[i].first; } p[n] = nums.back().second;
vector<vector<int>> dp(n, vector<int>(n, 0)); for (int i = 2; i <= n; i++) { for (int l = 0; l <= n - i; l ++) { int r = l + i - 1; dp[l][r] = INT_MAX; for (int k = l; k < r; k++) { int ans = dp[l][k] + dp[k + 1][r] + p[l] * p[k + 1] * p[r + 1]; dp[l][r] = min(dp[l][r], ans); } } } return dp[0][n - 1]; }
intmain(){ int n; cin >> n; vector<pair<int, int>> nums; for (int i = 0; i < n; i++) { int x, y; cin >> x >> y; nums.push_back({x, y}); } cout << helper(nums) << endl; return0; }
There are N gas stations along a circular route, where the amount of gas at station i is gas[i].
You have a car with an unlimited gas tank and it costs cost[i] of gas to travel from station i to its next station (i+1). You begin the journey with an empty tank at one of the gas stations.
Return the starting gas station’s index if you can travel around the circuit once in the clockwise direction, otherwise return -1.
Note:
If there exists a solution, it is guaranteed to be unique.
Both input arrays are non-empty and have the same length.
Each element in the input arrays is a non-negative integer.
Example 1:
1 2 3 4 5 6 7 8 9 10 11 12 13 14
Input: gas = [1,2,3,4,5] cost = [3,4,5,1,2]
Output: 3
Explanation: Start at station 3 (index 3) and fill up with 4 unit of gas. Your tank = 0 + 4 = 4 Travel to station 4. Your tank = 4 - 1 + 5 = 8 Travel to station 0. Your tank = 8 - 2 + 1 = 7 Travel to station 1. Your tank = 7 - 3 + 2 = 6 Travel to station 2. Your tank = 6 - 4 + 3 = 5 Travel to station 3. The cost is 5. Your gas is just enough to travel back to station 3. Therefore, return 3 as the starting index.
Example 2:
1 2 3 4 5 6 7 8 9 10 11 12 13
Input: gas = [2,3,4] cost = [3,4,3]
Output: -1
Explanation: You can't start at station 0 or 1, as there is not enough gas to travel to the next station. Let's start at station 2 and fill up with 4 unit of gas. Your tank = 0 + 4 = 4 Travel to station 0. Your tank = 4 - 3 + 2 = 3 Travel to station 1. Your tank = 3 - 3 + 3 = 3 You cannot travel back to station 2, as it requires 4 unit of gas but you only have 3. Therefore, you can't travel around the circuit once no matter where you start.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
classSolution { public: intcanCompleteCircuit(vector<int>& gas, vector<int>& cost){ int ans = 0, c = 0, g = 0; int ret = 0; for (int i = 0; i < gas.size(); i++) { ans += gas[i] - cost[i]; g += gas[i]; c += cost[i]; if (ans < 0) { ans = 0; ret = i + 1; } } return g >= c ? ret : -1; } };
Given a non negative integer number num. For every numbers i in the range 0 ≤ i ≤ num calculate the number of 1’s in their binary representation and return them as an array.
Example 1:
1 2
Input: 2 Output: [0,1,1]
Example 2:
1 2
Input: 5 Output: [0,1,1,2,1,2]
1 2 3 4 5 6 7 8 9 10
classSolution { public: vector<int> countBits(int num) { vector<int> dp(num + 1, 0); for (int i = 1; i <= num; i++) { dp[i] = dp[i & (i - 1)] + 1; } return dp; } };
You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed. All houses at this place are arranged in a circle. That means the first house is the neighbor of the last one. Meanwhile, adjacent houses have security system connected and it will automatically contact the police if two adjacent houses were broken into on the same night.
Given a list of non-negative integers representing the amount of money of each house, determine the maximum amount of money you can rob tonight without alerting the police.
Example 1:
1 2 3 4
Input: [2,3,2] Output: 3 Explanation: You cannot rob house 1 (money = 2) and then rob house 3 (money = 2), because they are adjacent houses.
Example 2:
1 2 3 4
Input: [1,2,3,1] Output: 4 Explanation: Rob house 1 (money = 1) and then rob house 3 (money = 3). Total amount you can rob = 1 + 3 = 4.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
classSolution { public: inthelper(vector<int>& nums, int left, int right){ int pre = 0, ret = 0; for (int i = left; i <= right; i++) { int temp = max(pre + nums[i], ret); pre = ret, ret = temp; } return ret; } introb(vector<int>& nums){ int n = nums.size(); if (n < 2) return n == 0 ? 0 : nums[0]; return max(helper(nums, 0, n - 2), helper(nums, 1, n - 1)); } };
Say you have an array for which the ith element is the price of a given stock on day i.
Design an algorithm to find the maximum profit. You may complete as many transactions as you like (ie, buy one and sell one share of the stock multiple times) with the following restrictions:
You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again). After you sell your stock, you cannot buy stock on next day. (ie, cooldown 1 day)
Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, determine if s can be segmented into a space-separated sequence of one or more dictionary words.
Note:
The same word in the dictionary may be reused multiple times in the segmentation.
You may assume the dictionary does not contain duplicate words.
Example 1:
1 2 3
Input: s = "leetcode", wordDict = ["leet", "code"] Output: true Explanation: Return true because "leetcode" can be segmented as "leet code".
Example 2:
1 2 3 4
Input: s = "applepenapple", wordDict = ["apple", "pen"] Output: true Explanation: Return true because "applepenapple" can be segmented as "apple pen apple". Note that you are allowed to reuse a dictionary word.
A sequence of numbers is called a wiggle sequence if the differences between successive numbers strictly alternate between positive and negative. The first difference (if one exists) may be either positive or negative. A sequence with fewer than two elements is trivially a wiggle sequence.
For example, [1,7,4,9,2,5] is a wiggle sequence because the differences (6,-3,5,-7,3) are alternately positive and negative. In contrast, [1,4,7,2,5] and [1,7,4,5,5] are not wiggle sequences, the first because its first two differences are positive and the second because its last difference is zero.
Given a sequence of integers, return the length of the longest subsequence that is a wiggle sequence. A subsequence is obtained by deleting some number of elements (eventually, also zero) from the original sequence, leaving the remaining elements in their original order.
Examples:
1 2 3 4 5 6 7 8 9 10
Input: [1,7,4,9,2,5] Output: 6 The entire sequence is a wiggle sequence.
Input: [1,17,5,10,13,15,10,5,16,8] Output: 7 There are several subsequences that achieve this length. One is [1,17,10,13,10,16,8].
Input: [1,2,3,4,5,6,7,8,9] Output: 2
1 2 3 4 5 6 7 8 9 10 11
classSolution { public: intwiggleMaxLength(vector<int>& nums){ int f = 1, d = 1, n = nums.size(); for (int i = 1; i < nums.size(); i++) { if (nums[i] > nums[i - 1]) f = d + 1; if (nums[i] < nums[i - 1]) d = f + 1; } return min(max(f, d), n); } };
A sequence of number is called arithmetic if it consists of at least three elements and if the difference between any two consecutive elements is the same.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
For example, these are arithmetic sequence:
1, 3, 5, 7, 9 7, 7, 7, 7 3, -1, -5, -9
The following sequence is not arithmetic.
1, 1, 2, 5, 7
A zero-indexed array A consisting of N numbers is given. A slice of that array is any pair of integers (P, Q) such that 0 <= P < Q < N.
A slice (P, Q) of array A is called arithmetic if the sequence: A[P], A[p + 1], ..., A[Q - 1], A[Q] is arithmetic. In particular, this means that P + 1 < Q.
The function should return the number of arithmetic slices in the array A.
Example:
1 2 3
A = [1, 2, 3, 4]
return: 3, for 3 arithmetic slices in A: [1, 2, 3], [2, 3, 4] and [1, 2, 3, 4] itself.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
classSolution { public: intnumberOfArithmeticSlices(vector<int>& nums){ int n = nums.size(); if (n < 3) return0; int cur = nums[1] - nums[0] == nums[2] - nums[1] ? 1 : 0; int ret = cur; for (int i = 3; i < n; i++) { if (nums[i] - nums[i - 1] == nums[i - 1] - nums[i - 2]) cur ++; else cur = 0; ret += cur; } return ret; } };
Given an input string (s) and a pattern (p), implement regular expression matching with support for ‘.’ and ‘*’.
1 2 3
'.' Matches any single character. '*' Matches zero or more of the preceding element. The matching should cover the entire input string (not partial).
Note:
s could be empty and contains only lowercase letters a-z.
p could be empty and contains only lowercase letters a-z, and characters like . or *.
Example 1:
1 2 3 4 5
Input: s = "aa" p = "a" Output: false Explanation: "a" does not match the entire string "aa".
Example 2:
1 2 3 4 5
Input: s = "aa" p = "a*" Output: true Explanation: '*' means zero or more of the precedeng element, 'a'. Therefore, by repeating 'a' once, it becomes "aa".
Example 3:
1 2 3 4 5
Input: s = "ab" p = ".*" Output: true Explanation: ".*" means "zero or more (*) of any character (.)".
Example 4:
1 2 3 4 5
Input: s = "aab" p = "c*a*b" Output: true Explanation: c can be repeated 0 times, a can be repeated 1 time. Therefore it matches "aab".
Example 5:
1 2 3 4
Input: s = "mississippi" p = "mis*is*p*." Output: false
Given an input string (s) and a pattern (p), implement wildcard pattern matching with support for ‘?’ and ‘*’.
‘?’ Matches any single character. ‘*’ Matches any sequence of characters (including the empty sequence). The matching should cover the entire input string (not partial).
Note:
s could be empty and contains only lowercase letters a-z. p could be empty and contains only lowercase letters a-z, and characters like ? or *.
Example 1:
1 2 3 4 5
Input: s = "aa" p = "a" Output: false Explanation: "a" does not match the entire string "aa".
Example 2:
1 2 3 4 5
Input: s = "aa" p = "*" Output: true Explanation: '*' matches any sequence.
Example 3:
1 2 3 4 5
Input: s = "cb" p = "?a" Output: false Explanation: '?' matches 'c', but the second letter is 'a', which does not match 'b'.
Example 4:
1 2 3 4 5
Input: s = "adceb" p = "*a*b" Output: true Explanation: The first '*' matches the empty sequence, while the second '*' matches the substring "dce".
Given a strictly increasing array A of positive integers forming a sequence, find the length of the longest fibonacci-like subsequence of A. If one does not exist, return 0.
(Recall that a subsequence is derived from another sequence A by deleting any number of elements (including none) from A, without changing the order of the remaining elements. For example, [3, 5, 8] is a subsequence of [3, 4, 5, 6, 7, 8].)
Example 1:
1 2 3 4
Input: [1,2,3,4,5,6,7,8] Output: 5 Explanation: The longest subsequence that is fibonacci-like: [1,2,3,5,8].
Example 2:
1 2 3 4 5
Input: [1,3,7,11,12,14,18] Output: 3 Explanation: The longest subsequence that is fibonacci-like: [1,11,12], [3,11,14] or [7,11,18].
classSolution { public: intlenLongestFibSubseq(vector<int>& nums){ int n = nums.size(); if (n < 3) return0; unordered_map<int, int> m; for (int i = 0; i < n; i++) { m[nums[i]] = i; } vector<vector<int>> dp(n + 1, vector<int>(n + 1, 0)); int ret = 2; // 从后向前更新，将阶段的结果用于后面的过程 for (int i = n - 2; i >= 0; i--) { for (int j = i + 1; j <= n; j++) { dp[i][j] = 2; int ans = nums[i] + nums[j]; if (!m.count(ans)) continue; int k = m[ans]; dp[i][j] = dp[j][k] + 1; ret = max(dp[i][j], ret); } } return ret >= 3 ? ret : 0; } };
In the computer world, use restricted resource you have to generate maximum benefit is what we always want to pursue.
For now, suppose you are a dominator of m 0s and n 1s respectively. On the other hand, there is an array with strings consisting of only 0s and 1s.
Now your task is to find the maximum number of strings that you can form with given m 0s and n 1s. Each 0 and 1 can be used at most once.
Note:
The given numbers of 0s and 1s will both not exceed 100
The size of given string array won’t exceed 600.
Example 1:
1 2 3
Input: Array = {"10", "0001", "111001", "1", "0"}, m = 5, n = 3 Output: 4 Explanation: This are totally 4 strings can be formed by the using of 5 0s and 3 1s, which are “10,”0001”,”1”,”0”
Example 2:
1 2 3
Input: Array = {"10", "0", "1"}, m = 1, n = 1 Output: 2 Explanation: You could form "10", but then you'd have nothing left. Better form "0" and "1".
classSolution { public: voidhelper(string s, int& one, int& zero){ one = zero = 0; for (auto i : s) { if (i == '0') zero ++; else one ++; } } intfindMaxForm(vector<string>& strs, int m, int n){ vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0)); for (auto s : strs) { int o, z; helper(s, o, z); for (int i = m; i >= z; i--) { for (int j = n; j >= o; j--) { dp[i][j] = max(dp[i][j], dp[i - z][j - o] + 1); } } } return dp[m][n]; } };
Given a non-empty array containing only positive integers, find if the array can be partitioned into two subsets such that the sum of elements in both subsets is equal.
Note:
Each of the array element will not exceed 100.
The array size will not exceed 200.
Example 1:
1 2 3 4 5
Input: [1, 5, 11, 5]
Output: true
Explanation: The array can be partitioned as [1, 5, 5] and [11].
Example 2:
1 2 3 4 5
Input: [1, 2, 3, 5]
Output: false
Explanation: The array cannot be partitioned into equal sum subsets.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
classSolution { public: boolcanPartition(vector<int>& nums){ if (nums.size() < 2) returnfalse; int ans = 0; for (auto i : nums) ans += i; if (ans % 2) returnfalse; int target = ans / 2; vector<bool> dp(target + 1, false); dp[0] = true; for (auto i : nums) { for (int j = target; j >= i; j--) { dp[j] = dp[j] || dp[j - i]; } } return dp[target]; } };
voidwiggleSort(vector<int>& nums){ int n = nums.size(); // Find a median. auto midptr = nums.begin() + n / 2; nth_element(nums.begin(), midptr, nums.end()); int mid = *midptr; // Index-rewiring. #define A(i) nums[(1+2*(i)) % (n|1)]
// 3-way-partition-to-wiggly in O(n) time with O(1) space. int i = 0, j = 0, k = n - 1; while (j <= k) { if (A(j) > mid) swap(A(i++), A(j++)); elseif (A(j) < mid) swap(A(j), A(k--)); else j++; } }
Given an unsorted array of integers, find the length of the longest consecutive elements sequence.
Your algorithm should run in O(n) complexity.
Example:
1 2 3
Input: [100, 4, 200, 1, 3, 2] Output: 4 Explanation: The longest consecutive elements sequence is [1, 2, 3, 4]. Therefore its length is 4.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
classSolution { public: intlongestConsecutive(vector<int>& nums){ unordered_map<int, int> m; int ret = 0; for (auto i : nums) { int l = 0, r = 0; // 此题借用了并查集的思想，将边缘的数据进行合并 // 找到就跳过，防止存在中间结果 if (m.find(i) != m.end()) continue; if (m.find(i - 1) != m.end()) l = m[i - 1]; if (m.find(i + 1) != m.end()) r = m[i + 1]; int ans = l + r + 1; ret = max(ret, ans); m[i] = m[i - l] = m[i + r] = ans; } return ret; } };
There are a total of n courses you have to take, labeled from 0 to n-1.
Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: [0,1]
Given the total number of courses and a list of prerequisite pairs, is it possible for you to finish all courses?
1 2 3 4 5 6 7 8 9 10 11 12
Example 1: Input: 2, [[1,0]] Output: true Explanation: There are a total of 2 courses to take. To take course 1 you should have finished course 0. So it is possible.
Example 2: Input: 2, [[1,0],[0,1]] Output: false Explanation: There are a total of 2 courses to take. To take course 1 you should have finished course 0, and to take course 0 you should also have finished course 1. So it is impossible.
classSolution { public: boolcanFinish(int numCourses, vector<pair<int, int>>& prerequisites){ int ret = 0; unordered_map<int, vector<int>> adj; vector<int> cnt(numCourses, 0); for (auto i : prerequisites) { cnt[i.first]++; adj[i.second].push_back(i.first); } vector<int> next; for (int i = 0; i < numCourses; i++) { if (!cnt[i]) { ret ++; next.push_back(i); } } while (!next.empty()) { vector<int> cur; for (auto i : next) { for (auto j : adj[i]) { cnt[j]--; if (!cnt[j]) { ret ++; cur.push_back(j); } } } next = cur; } return ret == numCourses; } };
For a undirected graph with tree characteristics, we can choose any node as the root. The result graph is then a rooted tree. Among all possible rooted trees, those with minimum height are called minimum height trees (MHTs). Given such a graph, write a function to find all the MHTs and return a list of their root labels.
Format The graph contains n nodes which are labeled from 0 to n - 1. You will be given the number n and a list of undirected edges (each edge is a pair of labels).
You can assume that no duplicate edges will appear in edges. Since all edges are undirected, [0, 1] is the same as [1, 0] and thus will not appear together in edges.
Given a list of airline tickets represented by pairs of departure and arrival airports [from, to], reconstruct the itinerary in order. All of the tickets belong to a man who departs from JFK. Thus, the itinerary must begin with JFK.
Note:
If there are multiple valid itineraries, you should return the itinerary that has the smallest lexical order when read as a single string. For example, the itinerary [“JFK”, “LGA”] has a smaller lexical order than [“JFK”, “LGB”]. All airports are represented by three capital letters (IATA code). You may assume all tickets form at least one valid itinerary.
Input: [["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]] Output: ["JFK","ATL","JFK","SFO","ATL","SFO"] Explanation: Another possible reconstruction is ["JFK","SFO","ATL","JFK","ATL","SFO"]. But it is larger in lexical order.
Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL.
Initially, all next pointers are set to NULL.
Note:
You may only use constant extra space. Recursive approach is fine, implicit stack space does not count as extra space for this problem. You may assume that it is a perfect binary tree (ie, all leaves are at the same level, and every parent has two children).
Example:
1 2 3 4 5 6 7 8 9 10 11 12 13 14
Given the following perfect binary tree,
1 / \ 2 3 / \ / \ 4 5 6 7 After calling your function, the tree should look like:
Given a non-empty binary tree, find the maximum path sum.
For this problem, a path is defined as any sequence of nodes from some starting node to any node in the tree along the parent-child connections. The path must contain at least one node and does not need to go through the root.
classSolution { public: voidhelper(int i, int j, int n, string ans, vector<string>& ret){ if (j != i) helper(i, j + 1, n, ans + ")", ret); if (i != n) helper(i + 1, j, n, ans + "(", ret); if (j == n) ret.push_back(ans); } vector<string> generateParenthesis(int n) { vector<string> ret; if (n < 1) return ret; helper(0, 0, n, "", ret); return ret; } };
The thief has found himself a new place for his thievery again. There is only one entrance to this area, called the “root.” Besides the root, each house has one and only one parent house. After a tour, the smart thief realized that “all houses in this place forms a binary tree”. It will automatically contact the police if two directly-linked houses were broken into on the same night.
Determine the maximum amount of money the thief can rob tonight without alerting the police.
Example 1:
1 2 3 4 5 6 7 8 9 10
Input: [3,2,3,null,3,null,1]
3 / \ 2 3 \ \ 3 1
Output: 7 Explanation: Maximum amount of money the thief can rob = 3 + 3 + 1 = 7.
Example 2:
1 2 3 4 5 6 7 8 9 10
Input: [3,4,5,1,3,null,1]
3 / \ 4 5 / \ \ 1 3 1
Output: 9 Explanation: Maximum amount of money the thief can rob = 4 + 5 = 9.
Given an encoded string, return it’s decoded string.
The encoding rule is: k[encoded_string], where the encoded_string inside the square brackets is being repeated exactly k times. Note that k is guaranteed to be a positive integer.
You may assume that the input string is always valid; No extra white spaces, square brackets are well-formed, etc.
Furthermore, you may assume that the original data does not contain any digits and that digits are only for those repeat numbers, k. For example, there won’t be input like 3a or 2[4].
Examples:
1 2 3
s = "3[a]2[bc]", return "aaabcbc". s = "3[a2[c]]", return "accaccacc". s = "2[abc]3[cd]ef", return "abcabccdcdcdef".
Remember the story of Little Match Girl? By now, you know exactly what matchsticks the little match girl has, please find out a way you can make one square by using up all those matchsticks. You should not break any stick, but you can link them up, and each matchstick must be used exactly one time.
Your input will be several matchsticks the girl has, represented with their stick length. Your output will either be true or false, to represent whether you could make one square using all the matchsticks the little match girl has.
Example 1:
1 2 3
Input: [1,1,2,2,2] Output: true Explanation: You can form a square with length 2, one side of the square came two sticks with length 1.
Example 2:
1 2 3 4
Input: [3,3,3,3,4] Output: false
Explanation: You cannot find a way to form a square with all the matchsticks.
Given an array of integers nums and a positive integer k, find whether it’s possible to divide this array into k non-empty subsets whose sums are all equal.
Example 1:
1 2 3
Input: nums = [4, 3, 2, 3, 5, 2, 1], k = 4 Output: True Explanation: It's possible to divide it into 4 subsets (5), (1, 4), (2,3), (2,3) with equal sums.
classSolution { public: boolhelper(vector<int> ans, int index, vector<int>& nums, int target){ int k = ans.size(), n = nums.size(); if (index == n) { for (int i = 0; i < k; i++) { if (ans[i] != target) returnfalse; } returntrue; } for (int i = 0; i < k; i++) { if (ans[i] + nums[index] > target) continue; ans[i] += nums[index]; if (helper(ans, index + 1, nums, target)) returntrue; ans[i] -= nums[index]; } returnfalse; } boolcanPartitionKSubsets(vector<int>& nums, int k){ int ans = 0, n = nums.size(); for (auto i : nums) ans += i; if (n < k || ans % k) returnfalse; sort(nums.begin(), nums.end(), greater<int>()); return helper(vector<int>(k, 0), 0, nums, ans / k); } };
DescriptionHintsSubmissionsDiscussSolution Given a collection of integers that might contain duplicates, nums, return all possible subsets (the power set).
Note: The solution set must not contain duplicate subsets.
classSolution { public: vector<vector<int>> subsetsWithDup(vector<int>& nums) { vector<vector<int>> ret; ret.push_back(vector<int>()); if (nums.empty()) return ret; sort(nums.begin(), nums.end()); int n = nums.size(); for (int i = 0; i < n; i++) { int index = 0; while (i + index < n && nums[i] == nums[i + index]) index ++; int len = ret.size(); for (int j = 0; j < len; j++) { auto temp = ret[j]; for (int k = 0; k < index; k++) { temp.push_back(nums[i]); ret.push_back(temp); } } i += index - 1; } return ret; } };
DescriptionHintsSubmissionsDiscussSolution Given a 2D board and a word, find if the word exists in the grid.
The word can be constructed from letters of sequentially adjacent cell, where “adjacent” cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once.
classSolution { public: boolhelper(vector<vector<char>>& board, string word, int index, int x, int y){ // 尽量在helper函数中做相等判断，否则还需要在外层函数中实现相等判断和访问覆盖操作 if (word[index] != board[x][y]) returnfalse; int len = word.size(), m = board.size(), n = board[0].size(); if (index == len - 1) returntrue; int a[4] = {0, 0, -1, 1}, b[4] = {-1, 1, 0, 0}; board[x][y] = '\0'; for (int i = 0; i < 4; i++) { int X = x + a[i], Y = y + b[i]; if (X >= 0 && X < m && Y >= 0 && Y < n && helper(board, word, index + 1, X, Y)) returntrue; } board[x][y] = word[index]; returnfalse; } boolexist(vector<vector<char>>& board, string word){ if (board.empty() || board[0].empty()) returnfalse; if (word.empty()) returntrue; int m = board.size(), n = board[0].size(); for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { if (helper(board, word, 0, i, j)) returntrue; } } returnfalse; } };
Given an integer matrix, find the length of the longest increasing path.
From each cell, you can either move to four directions: left, right, up or down. You may NOT move diagonally or move outside of the boundary (i.e. wrap-around is not allowed).
Example 1:
1 2 3 4 5 6 7 8
Input: nums = [ [9,9,4], [6,6,8], [2,1,1] ] Output: 4 Explanation: The longest increasing path is [1, 2, 6, 9].
Example 2:
1 2 3 4 5 6 7 8
Input: nums = [ [3,4,5], [3,2,6], [2,2,1] ] Output: 4 Explanation: The longest increasing path is [3, 4, 5, 6]. Moving diagonally is not allowed.
classSolution { public: inthelper(vector<vector<int>>& matrix, vector<vector<int>>& ma, int x, int y){ if (ma[x][y]) return ma[x][y]; int ans = matrix[x][y]; int m = matrix.size(), n = matrix[0].size(); int a[4] = {0, 0, -1, 1}, b[4] = {-1, 1, 0, 0}; for (int i = 0; i < 4; i++) { int X = x + a[i], Y = y + b[i]; if (X >= 0 && X < m && Y >= 0 && Y < n) { int local = 1; if (matrix[X][Y] > ans) { local += helper(matrix, ma, X, Y); } ma[x][y] = max(local, ma[x][y]); } } return ma[x][y]; } intlongestIncreasingPath(vector<vector<int>>& matrix){ int ret = 1; if (matrix.empty() || matrix[0].empty()) return0; int m = matrix.size(), n = matrix[0].size(); vector<vector<int>> ma(m, vector<int>(n, 0)); for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { ret = max(ret, helper(matrix, ma, i, j)); } } return ret; } };
Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, add spaces in s to construct a sentence where each word is a valid dictionary word. Return all such possible sentences.
Note:
The same word in the dictionary may be reused multiple times in the segmentation. You may assume the dictionary does not contain duplicate words.
Example 1:
1 2 3 4 5 6 7 8
Input: s = "catsanddog" wordDict = ["cat", "cats", "and", "sand", "dog"] Output: [ "cats and dog", "cat sand dog" ]
Example 2:
1 2 3 4 5 6 7 8 9 10
Input: s = "pineapplepenapple" wordDict = ["apple", "pen", "applepen", "pine", "pineapple"] Output: [ "pine apple pen apple", "pineapple pen apple", "pine applepen apple" ] Explanation: Note that you are allowed to reuse a dictionary word.
Design a data structure that supports the following two operations:
void addWord(word) bool search(word) search(word) can search a literal word or a regular expression string containing only letters a-z or .. A . means it can represent any one letter.
structTrieNode { TrieNode* child[26]; bool isKey; TrieNode() : isKey(false) { memset(child, NULL, sizeof(child)); } }; classWordDictionary { public: TrieNode* root; /** Initialize your data structure here. */ WordDictionary() { root = new TrieNode(); } /** Adds a word into the data structure. */ voidaddWord(string word){ TrieNode* cur = root; for (auto i : word) { int c = i - 'a'; if (!cur->child[c]) cur->child[c] = new TrieNode(); cur = cur->child[c]; } cur->isKey = true; } boolhelper(string s, int index, TrieNode* cur){ int n = s.size(); for (int i = index; i < n; i++) { if (s[i] == '.') { for (int j = 0; j < 26; j++) { if (cur->child[j] && helper(s, i + 1, cur->child[j])) returntrue; } returnfalse; } int c = s[i] - 'a'; if (!cur->child[c]) returnfalse; cur = cur->child[c]; } return cur && cur->isKey; } /** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */ boolsearch(string word){ return helper(word, 0, root); } };
/** * Your WordDictionary object will be instantiated and called as such: * WordDictionary obj = new WordDictionary(); * obj.addWord(word); * bool param_2 = obj.search(word); */
Given a list of airline tickets represented by pairs of departure and arrival airports [from, to], reconstruct the itinerary in order. All of the tickets belong to a man who departs from JFK. Thus, the itinerary must begin with JFK.
Note:
If there are multiple valid itineraries, you should return the itinerary that has the smallest lexical order when read as a single string. For example, the itinerary [“JFK”, “LGA”] has a smaller lexical order than [“JFK”, “LGB”]. All airports are represented by three capital letters (IATA code). You may assume all tickets form at least one valid itinerary.
Input: [["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]] Output: ["JFK","ATL","JFK","SFO","ATL","SFO"] Explanation: Another possible reconstruction is ["JFK","SFO","ATL","JFK","ATL","SFO"]. But it is larger in lexical order.
Given a string of numbers and operators, return all possible results from computing all the different possible ways to group numbers and operators. The valid operators are +, - and *.
classSolution { public: vector<int> diffWaysToCompute(string input) { vector<int> ret; for (int i = 0; i < input.size(); i++) { if (ispunct(input[i])) { auto c = input[i]; for (auto a : diffWaysToCompute(input.substr(0, i))) { for (auto b : diffWaysToCompute(input.substr(i + 1))) { ret.push_back(c == '+' ? a + b : (c == '-' ? a - b : a * b)); } } } } return ret.empty() ? vector<int>({stoi(input)}) : ret; } };
classSolution { public: voidhelper(vector<vector<string>>& ret, vector<string> ans, int index, string s){ int n = s.size(); if (index == n) { ret.push_back(ans); return; } for (int i = index; i < n; i++) { int l = index, r = i; while (l < r && s[l] == s[r]) l++, r--; if (l >= r) { ans.push_back(s.substr(index, i - index + 1)); helper(ret, ans, i + 1, s); ans.pop_back(); } } } vector<vector<string>> partition(string s) { vector<vector<string>> ret; if (s.empty()) return ret; helper(ret, vector<string>(), 0, s); return ret; } };
// next permutation 版本 classSolution { public: voidnext_permutation(string& s){ int n = s.size(); int i = n - 2; while (i >= 0 && s[i] >= s[i + 1]) i--; if (i >= 0) { int j = n - 1; while (s[j] <= s[i]) j --; swap(s[j], s[i]); } reverse(s.begin() + i + 1, s.end()); } stringgetPermutation(int n, int k){ string ret; for (int i = 1; i <= n; i++) { ret = ret + to_string(i);; } for (int i = 0; i < k - 1; i++) { next_permutation(ret); } return ret; } };
// 线性扫描 classSolution { public: boolsearchMatrix(vector<vector<int>>& matrix, int target){ if (matrix.empty() || matrix[0].empty()) returnfalse; int m = matrix.size(), n = matrix[0].size(); int i = 0, j = n - 1; while (i < m && j >= 0) { if (matrix[i][j] == target) returntrue; if (matrix[i][j] > target) j--; else i ++; } returnfalse; } };
// 二分法 classSolution { public: boolsearchMatrix(vector<vector<int>>& matrix, int target){ if (matrix.empty() || matrix[0].empty()) returnfalse; int m = matrix.size(), n = matrix[0].size(); int low = 0, high = m - 1; while (low <= high) { int mid = low + (high - low) / 2; if (matrix[mid][0] > target) high = mid - 1; elseif (matrix[mid][n - 1] < target) low = mid + 1; else { int left = 0, right = n - 1; while (left <= right) { int m = left + (right - left) / 2; int x = matrix[mid][m]; if (x == target) returntrue; if (x < target) left = m + 1; else right = m - 1; } returnfalse; } } returnfalse; } };
// 此处不是像惯性思维的i,j封闭了左侧封锁了搜索空间 classSolution { public: boolsearchMatrix(vector<vector<int>>& matrix, int target){ if (matrix.empty() || matrix[0].empty()) returnfalse; int m = matrix.size(), n = matrix[0].size(); int i = 0, j = n - 1; while (i < m && j >= 0) { int x = matrix[i][j]; if (x == target) returntrue; if (x < target) i++; else j --; } returnfalse; } };
// upper_bound是找到大于该值的第一个数，lower_bound是找到大于等于该值的第一个数 classSolution { public: intkthSmallest(vector<vector<int>>& matrix, int k){ if (matrix.empty() || matrix[0].empty()) -1; int m = matrix.size(), n = matrix[0].size(); int left = matrix[0][0], right = matrix[m - 1][n - 1]; while (left < right) { int mid = left + (right - left) / 2; int cnt = 0; for (int i = 0; i < m; i++) { cnt += (int)(upper_bound(matrix[i].begin(), matrix[i].end(), mid) - matrix[i].begin()); } if (cnt < k) { // 如果不满足等于k，则left会一直向后扩直至取到矩阵中的值 left = mid + 1; } else right = mid; } return left; } };
typedefvector<int>::iterator Iter; classSolution { public: inthelper(Iter l, int m, Iter r, int n, int k){ if (!m) return r[k - 1]; if (!n) return l[k - 1]; if (k == 1) return min(l[0], r[0]); int i = min(m, k / 2), j = min(n, k / 2); if (l[i - 1] < r[j - 1]) return helper(l + i, m - i, r, n, k - i); else return helper(l, m, r + j, n - j, k - j); } doublefindMedianSortedArrays(vector<int>& nums1, vector<int>& nums2){ int n1 = nums1.size(), n2 = nums2.size(); int a = helper(nums1.begin(), n1, nums2.begin(), n2, (n1 + n2 + 1) / 2); int b = helper(nums1.begin(), n1, nums2.begin(), n2, (n1 + n2 + 2) / 2); return (a + b) / 2.0; } };
Given a set of intervals, for each of the interval i, check if there exists an interval j whose start point is bigger than or equal to the end point of the interval i, which can be called that j is on the “right” of i.
For any interval i, you need to store the minimum interval j’s index, which means that the interval j has the minimum start point to build the “right” relationship for interval i. If the interval j doesn’t exist, store -1 for the interval i. Finally, you need output the stored value of each interval as an array.
Note: You may assume the interval’s end point is always bigger than its start point. You may assume none of these intervals have the same start point.
Example 1:
1 2 3 4 5
Input: [ [1,2] ]
Output: [-1]
Explanation: There is only one interval in the collection, so it outputs -1.
Example 2:
1 2 3 4 5 6 7
Input: [ [3,4], [2,3], [1,2] ]
Output: [-1, 0, 1]
Explanation: There is no satisfied "right" interval for [3,4]. For [2,3], the interval [3,4] has minimum-"right" start point; For [1,2], the interval [2,3] has minimum-"right" start point.
Example 3:
1 2 3 4 5 6
Input: [ [1,4], [2,3], [3,4] ]
Output: [-1, 2, -1]
Explanation: There is no satisfied "right" interval for [1,4] and [3,4]. For [2,3], the interval [3,4] has minimum-"right" start point.
Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
(i.e., [0,1,2,4,5,6,7] might become [4,5,6,7,0,1,2]).
Find the minimum element.
You may assume no duplicate exists in the array.
Example 1:
1 2
Input: [3,4,5,1,2] Output: 1
Example 2:
1 2
Input: [4,5,6,7,0,1,2] Output: 0
1 2 3 4 5 6 7 8 9 10 11 12 13 14
classSolution { public: intfindMin(vector<int>& nums){ if (nums.empty()) return-1; int n = nums.size(); int left = 0, right = n - 1; while (left < right) { int mid = left + (right - left) / 2; if (nums[mid] > nums[right]) left = mid + 1; else right = mid; } return nums[left]; } };
Koko loves to eat bananas. There are N piles of bananas, the i-th pile has piles[i] bananas. The guards have gone and will come back in H hours.
Koko can decide her bananas-per-hour eating speed of K. Each hour, she chooses some pile of bananas, and eats K bananas from that pile. If the pile has less than K bananas, she eats all of them instead, and won’t eat any more bananas during this hour.
Koko likes to eat slowly, but still wants to finish eating all the bananas before the guards come back.
Return the minimum integer K such that she can eat all the bananas within H hours.
// 二分答案，类似于求绝对值差值第K大那道题 classSolution { public: intminEatingSpeed(vector<int>& piles, int H){ int mx = 0; for (auto i : piles) { mx = max(mx, i); } int left = 1, right = mx; while (left < right) { int i = (left + right) / 2; longlong ans = 0; for (auto j : piles) { int x = j / i; ans += (j % i == 0) ? x * i : (x + 1) * i; } int h = ans / i; if (h > H) left = i + 1; else right = i; } return left; } };
You are given two non-empty linked lists representing two non-negative integers. The most significant digit comes first and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.
You may assume the two numbers do not contain any leading zero, except the number 0 itself.
Follow up: What if you cannot modify the input lists? In other words, reversing the lists is not allowed.
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ classSolution { public: ListNode* addTwoNumbers(ListNode* l1, ListNode* l2){ string num1, num2; ListNode* cur = l1; while (cur) { num1.push_back('0' + cur->val); cur = cur->next; } cur = l2; while (cur) { num2.push_back('0' + cur->val); cur = cur->next; } string ret; int c = 0; int i = num1.size() - 1, j = num2.size() - 1; while (i >= 0 && j >= 0) { int a = num1[i--] - '0'; int b = num2[j--] - '0'; int ans = c + a + b; ret = to_string(ans % 10) + ret; c = ans / 10; } while (i >= 0) { int a = num1[i--] - '0'; int ans = c + a; ret = to_string(ans % 10) + ret; c = ans / 10; } while (j >= 0) { int a = num2[j--] - '0'; int ans = c + a; ret = to_string(ans % 10) + ret; c = ans / 10; } if (c) ret = to_string(c) + ret; ListNode* head = NULL; for (i = ret.size() - 1; i >= 0; i--) { ListNode* cur = new ListNode(ret[i] - '0'); cur->next = head; head = cur; } return head; } };
// 此处由于是默认加法所以没有对减法进行符号处理，否则这里也需要像加法一样对其进行符号判断 stringINT_SUB(string a, string b){ int syn = 1; if (a < b) { string temp = a; a = b; b = temp; syn *= -1; } int i = a.size() - 1, j = b.size() - 1; int c = 0; string ret; while (i >= 0) { int x = a[i--] - '0'; int y = b[j--] - '0'; int ans = (10 + x - y - c) % 10; c = x < y ? 1 : 0; ret = (char)('0' + ans) + ret; } while (ret.empty() && ret[0] == '0') ret.erase(ret.begin()); if (ret.empty()) return"0"; return syn == -1 ? "-" + ret : ret; }
stringINT_ADD(string a, string b){ if (a.empty()) return b; if (b.empty()) return a; if (a[0] == '+') a.erase(a.begin()); if (b[0] == '+') b.erase(b.begin()); int syn = 1; string ret; if (a[0] == '-') { if (b[0] == '-') { syn = -1; ret = INT_ADD(a.substr(1), b.substr(1)); } else { ret = INT_SUB(b, a.substr(1)); } } else { if (b[0] == '-') { ret = INT_SUB(a, b.substr(1)); } else { int i = a.size() - 1, j = b.size() - 1; int c = 0; while (i >= 0 && j >= 0) { int x = a[i--] - '0'; int y = b[j--] - '0'; int ans = x + y + c; ret = (char)('0' + ans % 10) + ret; c = ans / 10; } while (i >= 0) { int x = a[i--] - '0'; int ans = x + c; ret = (char)('0' + ans % 10) + ret; c = ans / 10; } while (j >= 0) { int x = b[j--] - '0'; int ans = x + c; ret = (char)('0' + ans % 10) + ret; c = ans / 10; } if (c) ret = (char)('0' + c) + ret; } } if (ret[0] == '-') { if (syn == 1) return ret; elsereturn ret.substr(1); } else { if (syn == 1) return ret; elsereturn ret != "0" ? "-" + ret : ret; } }
intmain(){ string a, b; cin >> a >> b; cout << INT_ADD(a, b) << endl; return0; }
Find the length of the longest substring T of a given string (consists of lowercase letters only) such that every character in T appears no less than k times.
Example 1:
1 2 3 4 5 6 7
Input: s = "aaabb", k = 3
Output: 3
The longest substring is "aaa", as 'a' is repeated 3 times.
Example 2:
1 2 3 4 5 6 7
Input: s = "ababbc", k = 2
Output: 5
The longest substring is "ababb", as 'a' is repeated 2 times and 'b' is repeated 3 times.
classSolution { public: intlongestSubstring(string s, int k){ int ret = 0, n = s.size(); for (int h = 1; h <= 26; h++) { vector<int> m(26, 0); int i = 0, j = 0, unique = 0, ans = 0; while (j < n) { if (unique <= h) { int index = s[j++] - 'a'; m[index] ++; if (m[index] == k) ans ++; if (m[index] == 1) unique ++; } else { int index = s[i++] - 'a'; m[index] --; if (m[index] == k - 1) ans --; if (m[index] == 0) unique --; } if (unique == h && unique == ans) ret = max(ret, j - i); } } return ret; } };
Given an input string, reverse the string word by word.
Example: Input: "the sky is blue", Output: "blue is sky the".
Note:
A word is defined as a sequence of non-space characters. Input string may contain leading or trailing spaces. However, your reversed string should not contain leading or trailing spaces. You need to reduce multiple spaces between two words to a single space in the reversed string. Follow up: For C programmers, try to solve it in-place in O(1) space.
Given a string S and a string T, find the minimum window in S which will contain all the characters in T in complexity O(n).
Example: Input: S = "ADOBECODEBANC", T = "ABC" Output: "BANC"
Note: If there is no such window in S that covers all characters in T, return the empty string "". If there is such window, you are guaranteed that there will always be only one unique minimum window in S.
classSolution { public: stringminWindow(string s, string t){ // ans保存未满足的字符数 unordered_map<char, int> m; for (auto i : t) m[i] ++; int ans = m.size(), n = s.size(); int cnt = INT_MAX, i = 0, j = 0; string ret; while (j <= n && i <= j) { if (j < n && ans > 0) { if (m.find(s[j]) != m.end()) { m[s[j]]--; if (!m[s[j]]) ans--; } j ++; } else { if (m.find(s[i]) != m.end()) { if (!m[s[i]]) ans ++; m[s[i]] ++; } i++; } if (!ans) { if (j - i < cnt) { cnt = j - i; ret = s.substr(i, cnt); } } } return ret; } };
An encoded string S is given. To find and write the decoded string to a tape, the encoded string is read one character at a time and the following steps are taken:
If the character read is a letter, that letter is written onto the tape. If the character read is a digit (say d), the entire current tape is repeatedly written d-1 more times in total. Now for some encoded string S, and an index K, find and return the K-th letter (1 indexed) in the decoded string.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
Example 1: Input: S = "leet2code3", K = 10 Output: "o" Explanation: The decoded string is "leetleetcodeleetleetcodeleetleetcode". The 10th letter in the string is "o".
Example 2: Input: S = "ha22", K = 5 Output: "h" Explanation: The decoded string is "hahahaha". The 5th letter is "h".
Example 3: Input: S = "a2345678999999999999999", K = 1 Output: "a" Explanation: The decoded string is "a" repeated 8301530446056247680 times. The 1st letter is "a".
Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.
1 2 3 4 5 6 7 8
Example 1: Input: "babad" Output: "bab" Note: "aba" is also a valid answer.
Example 2: Input: "cbbd" Output: "bb"
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
// 最长回文数的最常见算法为O(n2)，还有优化版本，但是需要讲解数学逻辑，之后更新... classSolution { public: stringlongestPalindrome(string s){ if (s.empty()) return s; int n = s.size(), len = 0, index = 0; for (int i = 0; i < n; i++) { if (n - i <= len / 2) break; int l = i, r = i; while (r < n - 1 && s[r + 1] == s[r]) r++; while (l > 0 && r < n - 1 && s[l - 1] == s[r + 1]) l--, r++; if (len < r - l + 1) { index = l, len = r - l + 1; } } return s.substr(index, len); } };
Write a function to check whether an input string is a valid IPv4 address or IPv6 address or neither.
IPv4 addresses are canonically represented in dot-decimal notation, which consists of four decimal numbers, each ranging from 0 to 255, separated by dots ("."), e.g.,172.16.254.1;
Besides, leading zeros in the IPv4 is invalid. For example, the address 172.16.254.01 is invalid.
IPv6 addresses are represented as eight groups of four hexadecimal digits, each group representing 16 bits. The groups are separated by colons (":"). For example, the address 2001:0db8:85a3:0000:0000:8a2e:0370:7334 is a valid one. Also, we could omit some leading zeros among four hexadecimal digits and some low-case characters in the address to upper-case ones, so 2001:db8:85a3:0:0:8A2E:0370:7334 is also a valid IPv6 address(Omit leading zeros and using upper cases).
However, we don't replace a consecutive group of zero value with a single empty group using two consecutive colons (::) to pursue simplicity. For example, 2001:0db8:85a3::8A2E:0370:7334 is an invalid IPv6 address.
Besides, extra leading zeros in the IPv6 is also invalid. For example, the address 02001:0db8:85a3:0000:0000:8a2e:0370:7334 is invalid.
Note: You may assume there is no extra space or special characters in the input string.
Example 1: Input: "172.16.254.1" Output: "IPv4" Explanation: This is a valid IPv4 address, return "IPv4".
Example 2: Input: "2001:0db8:85a3:0:0:8A2E:0370:7334" Output: "IPv6" Explanation: This is a valid IPv6 address, return "IPv6".
Example 3: Input: "256.256.256.256" Output: "Neither" Explanation: This is neither a IPv4 address nor a IPv6 address.
Given an unsorted array return whether an increasing subsequence of length 3 exists or not in the array.
Formally the function should:
Return true if there exists i, j, k such that arr[i] < arr[j] < arr[k] given 0 ≤ i < j < k ≤ n-1 else return false. Note: Your algorithm should run in O(n) time complexity and O(1) space complexity.
1 2 3 4 5 6 7
Example 1: Input: [1,2,3,4,5] Output: true
Example 2: Input: [5,4,3,2,1] Output: false
1 2 3 4 5 6 7 8 9 10 11 12
classSolution { public: boolincreasingTriplet(vector<int>& nums){ int c1 = INT_MAX, c2 = INT_MAX; for (auto i : nums) { if (i <= c1) c1 = i; elseif (i <= c2) c2 = i; elsereturntrue; } returnfalse; } };
Given a binary array, find the maximum length of a contiguous subarray with equal number of 0 and 1.
1 2 3 4 5 6 7 8 9
Example 1: Input: [0,1] Output: 2 Explanation: [0, 1] is the longest contiguous subarray with equal number of 0 and 1.
Example 2: Input: [0,1,0] Output: 2 Explanation: [0, 1] (or [1, 0]) is a longest contiguous subarray with equal number of 0 and 1.
Note: The length of the given binary array will not exceed 50,000.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
classSolution { public: intfindMaxLength(vector<int>& nums){ // 前缀和的变形 for (auto &i : nums) { if (!i) i = -1; } unordered_map<int, int> m; m[0] = -1; int ans = 0, ret = 0, n = nums.size(); for (int i = 0; i < n; i++) { ans += nums[i]; if (m.find(ans) != m.end()) ret = max(ret, i - m[ans]); else m[ans] = i; } return ret; } };
Given four lists A, B, C, D of integer values, compute how many tuples (i, j, k, l) there are such that A[i] + B[j] + C[k] + D[l] is zero.
To make problem a bit easier, all A, B, C, D have same length of N where 0 ≤ N ≤ 500. All integers are in the range of -228 to 228 - 1 and the result is guaranteed to be at most 231 - 1.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Example:
Input: A = [ 1, 2] B = [-2,-1] C = [-1, 2] D = [ 0, 2]
classSolution { public: voidhelper(vector<int>& A, vector<int>& B, unordered_map<int, int>& ret){ for (auto i : A) { for (auto j : B) { ret[i + j]++; } } } intfourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D){ unordered_map<int, int> a, b; helper(A, B, a); helper(C, D, b); int ret = 0; for (auto i : a) { if (b.find(-i.first) != b.end()) ret += i.second * b[-i.first]; } return ret; } };
Given an unsorted integer array, find the smallest missing positive integer.
1 2 3 4 5 6 7 8 9 10 11
Example 1: Input: [1,2,0] Output: 3
Example 2: Input: [3,4,-1,1] Output: 2
Example 3: Input: [7,8,9,11,12] Output: 1
1 2 3 4 5 6 7 8 9 10 11 12 13
classSolution { public: intfirstMissingPositive(vector<int>& nums){ int n = nums.size(); for (int i = 0; i < n; i++) { while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] != nums[i]) swap(nums[nums[i] - 1], nums[i]); } for (int i = 0; i < n; i++) { if (i + 1 != nums[i]) return i + 1; } return n + 1; } };
Given an array nums containing n + 1 integers where each integer is between 1 and n (inclusive), prove that at least one duplicate number must exist. Assume that there is only one duplicate number, find the duplicate one.
1 2 3 4 5 6 7
Example 1: Input: [1,3,4,2,2] Output: 2
Example 2: Input: [3,1,3,4,2] Output: 3
1 2 3 4 5 6 7 8 9 10 11
classSolution { public: intfindDuplicate(vector<int>& nums){ if (nums.empty()) return-1; for (auto &i : nums) { if (nums[abs(i) - 1] < 0) returnabs(i); nums[abs(i) - 1] *= -1; } return-1; } };
Given a string, find the length of the longest substring without repeating characters.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Example 1: Input: "abcabcbb" Output: 3 Explanation: The answer is "abc", which the length is 3.
Example 2: Input: "bbbbb" Output: 1 Explanation: The answer is "b", with the length of 1.
Example 3: Input: "pwwkew" Output: 3 Explanation: The answer is "wke", with the length of 3. Note that the answer must be a substring, "pwke" is a subsequence and not a substring.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
classSolution { public: intlengthOfLongestSubstring(string s){ if (s.empty()) return0; unordered_map<char, int> m; int index = -1, n = s.size(), ret = 0; for (int i = 0; i < n; i++) { auto c = s[i]; if (m.find(c) != m.end() && m[c] > index) index = m[c]; ret = max(ret, i - index); m[c] = i; } return ret; } };
classSolution { public: intFindGreatestSumOfSubArray(vector<int> array){ int ans = 0, n = array.size(); int ret = INT_MIN; for (int i = 0; i < n; i++) { ans += array[i]; ret = max(ret, ans); if (ans <= 0) ans = 0; } return ret; } };
求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。
Given an array of n positive integers and a positive integer s, find the minimal length of a contiguous subarray of which the sum ≥ s. If there isn’t one, return 0 instead.
1 2 3 4 5
Example:
Input: s = 7, nums = [2,3,1,2,4,3] Output: 2 Explanation: the subarray [4,3] has the minimal length under the problem constraint.
Follow up: If you have figured out the O(n) solution, try coding another solution of which the time complexity is O(n log n).
1 2 3 4 5 6 7 8 9 10 11 12 13 14
classSolution { public: // 因为是正整数，和一直是递增的，所以使用双指针就可以了 intminSubArrayLen(int s, vector<int>& nums){ int ans = 0, i = 0, j = 0, n = nums.size(); int ret = INT_MAX; while (j < n) { ans += nums[j++]; while (i < j && ans - nums[i] >= s) ans -= nums[i++]; if (ans >= s) ret = min(ret, j - i); } return ret == INT_MAX ? 0 : ret; } };
Given an array nums of n integers, are there elements a, b, c in nums such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.
Note:
The solution set must not contain duplicate triplets.
Given an array nums of n integers and an integer target, find three integers in nums such that the sum is closest to target. Return the sum of the three integers. You may assume that each input would have exactly one solution.
1 2 3
Example:
Given array nums = [-1, 2, 1, -4], and target = 1.
The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
// 3Sum的扩展版本 classSolution { public: intthreeSumClosest(vector<int>& nums, int target){ int n = nums.size(); if (n < 3) return-1; sort(nums.begin(), nums.end()); int ret = nums[0] + nums[1] + nums[2]; for (int i = 0; i < n - 2; i++) { int j = i + 1, k = n - 1; while (j < k) { int ans = nums[i] + nums[j] + nums[k]; if (ans == target) return target; if (abs(ans - target) < abs(ret - target)) ret = ans; if (ans > target) k--; else j ++; } } return ret; } };
Write a program to find the nth super ugly number.
Super ugly numbers are positive numbers whose all prime factors are in the given prime list primes of size k.
1 2 3 4 5 6
Example:
Input: n = 12, primes = [2,7,13,19] Output: 32 Explanation: [1,2,4,7,8,13,14,16,19,26,28,32] is the sequence of the first 12 super ugly numbers given primes = [2,7,13,19] of size 4.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
classSolution { public: intnthSuperUglyNumber(int n, vector<int>& primes){ int len = primes.size(); vector<int> cnt(len + 1, 0); vector<int> ret(n, INT_MAX); ret[0] = 1; for (int i = 1; i < n; i++) { for (int j = 0; j < len; j++) ret[i] = min(ret[i], primes[j] * ret[cnt[j]]); for (int j = 0; j < len; j++) { if (ret[i] == primes[j] * ret[cnt[j]]) cnt[j] ++; } } return ret[n - 1]; } };
Given a sorted array nums, remove the duplicates in-place such that duplicates appeared at most twice and return the new length.
Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.
1 2 3 4 5 6 7 8 9
Example 1: Given nums = [1,1,1,2,2,3], Your function should return length = 5, with the first five elements of nums being 1, 1, 2, 2 and 3 respectively. It doesn't matter what you leave beyond the returned length.
Example 2: Given nums = [0,0,1,1,1,1,2,3,3], Your function should return length = 7, with the first seven elements of nums being modified to 0, 0, 1, 1, 2, 3 and 3 respectively. It doesn't matter what values are set beyond the returned length.
Clarification:
Confused why the returned value is an integer but your answer is an array?
Note that the input array is passed in by reference, which means modification to the input array will be known to the caller as well.
Internally you can think of this:
1 2 3 4 5 6 7 8
// nums is passed in by reference. (i.e., without making a copy) int len = removeDuplicates(nums);
// any modification to nums in your function would be known by the caller. // using the length returned by your function, it prints the first len elements. for (int i = 0; i < len; i++) { print(nums[i]); }
1 2 3 4 5 6 7 8 9 10
classSolution { public: intremoveDuplicates(vector<int>& nums){ int index = 0, n = nums.size(); for (int i = 0; i < n; i++) { if (index < 2 || nums[index - 2] != nums[i]) nums[index ++] = nums[i]; } return index; } };
Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it is able to trap after raining.
The above elevation map is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped. Thanks Marcos for contributing this image!
classSolution { public: inttrap(vector<int>& height){ int ret = 0, n = height.size(); int level = 0, l = 0, r = n - 1; while (l < r) { int lower = height[height[l] < height[r] ? l ++ : r --]; level = max(level, lower); ret += level - lower; } return ret; } };
classSolution { public: vector<int> multiply(constvector<int>& A) { int len = A.size(); vector<int> B(len, 1); for (int i = 1; i < len; i++) { B[i] = A[i - 1] * B[i - 1]; } int ans = 1; for (int i = len - 1; i>= 0; i--) { B[i] *= ans; ans *= A[i]; } return B; } };
Given an array nums, there is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves right by one position. Return the max sliding window.
1 2 3 4 5 6 7 8 9 10 11 12 13 14
Example:
Input: nums = [1,3,-1,-3,5,3,6,7], and k = 3 Output: [3,3,5,5,6,7] Explanation:
Note: You may assume k is always valid, 1 ≤ k ≤ input array’s size for non-empty array.
Follow up: Could you solve it in linear time?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
classSolution { public: vector<int> maxSlidingWindow(vector<int>& nums, int k) { int n = nums.size(); vector<int> ret; deque<int> d; for (int i = 0; i < n; i++) { while (!d.empty() && nums[i] > nums[d.back()]) d.pop_back(); d.push_back(i); if (i >= k - 1) ret.push_back(nums[d.front()]); if (d.front() <= i - k + 1) d.pop_front(); } return ret; } };
Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and put.
get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1. put(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.
Follow up: Could you do both operations in O(1) time complexity?
1 2 3 4 5 6 7 8 9 10 11 12 13
Example:
LRUCache cache = new LRUCache( 2 /* capacity */ );
Insertion sort iterates, consuming one input element each repetition, and growing a sorted output list. At each iteration, insertion sort removes one element from the input data, finds the location it belongs within the sorted list, and inserts it there. It repeats until no input elements remain.
1 2 3 4 5 6 7
Example 1: Input: 4->2->1->3 Output: 1->2->3->4
Example 2: Input: -1->5->3->4->0 Output: -1->0->3->4->5
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ classSolution { public: ListNode* reverseBetween(ListNode* head, int m, int n){ if (m == n) return head; ListNode* ret = new ListNode(-1); ret->next = head; auto cur = ret; // 因为从1开始数，所以m-1 for (int i = 0; i < m - 1; i++) cur = cur->next; auto start = cur->next; for (int i = 0; i < n - m; i++) { auto temp = start->next; start->next = temp->next; temp->next = cur->next; cur->next = temp; } return ret->next; } };
Given a sequence of n integers a1, a2, …, an, a 132 pattern is a subsequence ai, aj, ak such that i < j < k and ai < ak < aj. Design an algorithm that takes a list of n numbers as input and checks whether there is a 132 pattern in the list.
Note: n will be less than 15,000.
1 2 3 4 5 6 7 8 9 10 11 12 13 14
Example 1: Input: [1, 2, 3, 4] Output: False Explanation: There is no 132 pattern in the sequence.
Example 2: Input: [3, 1, 4, 2] Output: True Explanation: There is a 132 pattern in the sequence: [1, 4, 2].
Example 3: Input: [-1, 3, 2, 0] Output: True Explanation: There are three 132 patterns in the sequence: [-1, 3, 2], [-1, 3, 0] and [-1, 2, 0].
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
classSolution { public: boolfind132pattern(vector<int>& nums){ stack<pair<int, int>> s; for (auto i : nums) { if (s.empty() || s.top().second > i) { s.push(make_pair(i, i)); } elseif (s.top().second < i) { int m = s.top().second; if (s.top().first > i) returntrue; while (!s.empty() && s.top().first <= i) s.pop(); if (!s.empty() && s.top().second < i) returntrue; s.push({i, m}); } } returnfalse; } };
Given a circular array (the next element of the last element is the first element of the array), print the Next Greater Number for every element. The Next Greater Number of a number x is the first greater number to its traversing-order next in the array, which means you could search circularly to find its next greater number. If it doesn’t exist, output -1 for this number.
1 2 3 4 5 6 7
Example 1: Input: [1,2,1] Output: [2,-1,2] Explanation: The first 1's next greater number is 2; The number 2 can't find next greater number; The second 1's next greater number needs to search circularly, which is also 2. Note: The length of given array won't exceed 10000.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
classSolution { public: vector<int> nextGreaterElements(vector<int>& nums) { if (nums.empty()) returnvector<int>(); int len = nums.size(); stack<int> s; vector<int> ret(len, -1); for (int i = 0; i < len * 2; i++) { while (!s.empty() && nums[s.top()] < nums[i % len]) { ret[s.top()] = nums[i % len]; s.pop(); } if (i < len) s.push(i); } return ret; } };
One way to serialize a binary tree is to use pre-order traversal. When we encounter a non-null node, we record the node’s value. If it is a null node, we record using a sentinel value such as #.
For example, the above binary tree can be serialized to the string “9,3,4,#,#,1,#,#,2,#,6,#,#”, where # represents a null node.
Given a string of comma separated values, verify whether it is a correct preorder traversal serialization of a binary tree. Find an algorithm without reconstructing the tree.
Each comma separated value in the string must be either an integer or a character ‘#’ representing null pointer.
You may assume that the input format is always valid, for example it could never contain two consecutive commas such as “1,,3”.
1 2 3 4 5 6 7 8 9 10 11
Example 1: Input: "9,3,4,#,#,1,#,#,2,#,6,#,#" Output: true
/** * Definition for a point. * struct Point { * int x; * int y; * Point() : x(0), y(0) {} * Point(int a, int b) : x(a), y(b) {} * }; */ classSolution { public: intmaxPoints(vector<Point>& points){ int ret = 0; int len = points.size(); if (len < 3) return len; for (int i = 0; i < len; i++) { map<pair<int, int>, int> m; int vertical = 0, overlap = 0, local_ret = 0; for (int j = i + 1; j < len; j++) { int a = points[i].x - points[j].x; int b = points[i].y - points[j].y; if (!a && !b) overlap ++; elseif (!a) vertical ++; else { int k = GCD(a, b); auto ans = make_pair(a / k, b / k); m[ans] ++; local_ret = max(local_ret, m[ans]); } local_ret = max(local_ret, vertical); } ret = max(ret, local_ret + overlap + 1); } return ret; } intGCD(int a, int b){ if (!b) return a; elsereturn GCD(b, a % b); } };
Given an array of integers, find out whether there are two distinct indices i and j in the array such that the absolute difference between nums[i] and nums[j] is at most t and the absolute difference between i and j is at most k.
1 2 3 4 5 6 7 8 9 10 11
Example 1: Input: nums = [1,2,3,1], k = 3, t = 0 Output: true
Example 2: Input: nums = [1,0,1,1], k = 1, t = 2 Output: true
Example 3: Input: nums = [1,5,9,1,5,9], k = 2, t = 3 Output: false
TreeNode* build(int& index, vector<int>& nums){ int n = nums.size(); if (index == n) returnNULL; int val = nums[index++]; if (val == -1) returnNULL; TreeNode* ret = new TreeNode(val); ret->left = build(index, nums); ret->right = build(index, nums); return ret; }
voidhelper(int& ret, int& l, int& r, int& m, int target, TreeNode* root){ l = r = m = 0; if (!root) return; int val = root->val; if (val == target) { m = 1; } if (!root->left && !root->right) { if (m) ret = 0; return; } int ll, lr, rl, rr, ml, mr; helper(ret, ll, lr, ml, target, root->left); helper(ret, rl, rr, mr, target, root->right); if (m) { if (!root->left) ret = min(ret, min(rl, rr) + 1); if (!root->right) ret = min(ret, min(ll, lr) + 1); if (root->left && root->right) { int ans = min(min(ll, lr) + 1, min(rl, rr) + 1); ret = min(ret, ans); } return; } if (ml) { if (root->right) { ret = min(ret, min(rl, rr) + ll + 2); //cout << "ml " << ret<< endl; } l = r = ll + 1; m = 1; return; } elseif (mr) { if (root->left) { ret = min(ret, min(ll, lr) + rr + 2); //cout << "mr " << ret<< endl; } l = r = rr + 1; m = 1; return; } else { l = !root->left ? INT_MAX : min(ll, lr) + 1; r = !root->right ? INT_MAX : min(rr, rl) + 1; //cout << "mid: " << val << " " << l << " " << r << endl; }
}
intmain(){ int n; cin >> n; vector<int> nums(n, 0); for (int i = 0; i < n; i++) { cin >> nums[i]; } int index = 0; TreeNode* root = build(index, nums); for (int i = 0; i < 12; i++) { int ret = INT_MAX; int m = 0, l, r; helper(ret, l, r, m, i + 1, root); cout << i + 1 << " "; if (m) cout << ret << endl; elsecout << -1 << endl; } return0; }
Given a complete binary tree, count the number of nodes.
Note:
Definition of a complete binary tree from Wikipedia: In a complete binary tree every level, except possibly the last, is completely filled, and all nodes in the last level are as far left as possible. It can have between 1 and 2h nodes inclusive at the last level h.
Given a root node reference of a BST and a key, delete the node with the given key in the BST. Return the root node reference (possibly updated) of the BST.
Basically, the deletion can be divided into two stages:
Search for a node to remove. If the node is found, delete the node. Note: Time complexity should be O(height of tree).
Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.
Design an algorithm to serialize and deserialize a binary search tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary search tree can be serialized to a string and this string can be deserialized to the original tree structure.
The encoded string should be as compact as possible.
/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ classCodec { public: voidhelper(TreeNode* root, string& ret){ if (!root) ret += ",#"; else { ret += "," + to_string(root->val); helper(root->left, ret); helper(root->right, ret); } } // Encodes a tree to a single string. stringserialize(TreeNode* root){ string ret; helper(root, ret); return ret.substr(1); } TreeNode* helper1(string& data, int& index){ string ans; while (index < data.size() && data[index] != ',') { ans.push_back(data[index++]); } if (index < data.size()) index ++; if (ans == "#") returnNULL; int syn = 1; if (ans[0] == '-') { ans.erase(ans.begin()); syn = -1; } int val = 0; for (auto i : ans) { val = val * 10 + (i - '0'); } val *= syn; TreeNode* ret = new TreeNode(val); ret->left = helper1(data, index); ret->right = helper1(data, index); return ret; } // Decodes your encoded data to tree. TreeNode* deserialize(string data){ int index = 0; return helper1(data, index); } };
// Your Codec object will be instantiated and called as such: // Codec codec; // codec.deserialize(codec.serialize(root));
structTrieNode { TrieNode* child[26]; bool isKey; TrieNode() : isKey(false) { memset(child, NULL, sizeof(child)); } }; classTrie { public: TrieNode* root; /** Initialize your data structure here. */ Trie() { root = new TrieNode(); } /** Inserts a word into the trie. */ voidinsert(string word){ TrieNode* cur = root; for (auto i : word) { int c = i - 'a'; if (!cur->child[c]) cur->child[c] = new TrieNode(); cur = cur->child[c]; } cur->isKey = true; } /** Returns if the word is in the trie. */ boolsearch(string word){ TrieNode* cur = root; for (auto i : word) { int c = i - 'a'; if (!cur->child[c]) returnfalse; cur = cur->child[c]; } return cur->isKey; } /** Returns if there is any word in the trie that starts with the given prefix. */ boolstartsWith(string prefix){ TrieNode* cur = root; for (auto i : prefix) { int c = i - 'a'; if (!cur->child[c]) returnfalse; cur = cur->child[c]; } returntrue; } };
/** * Your Trie object will be instantiated and called as such: * Trie obj = new Trie(); * obj.insert(word); * bool param_2 = obj.search(word); * bool param_3 = obj.startsWith(prefix); */
structTrieNode { TrieNode* child[2]; TrieNode() { memset(child, NULL, sizeof(child)); } }; classSolution { public: intfindMaximumXOR(vector<int>& nums){ TrieNode* root = new TrieNode(); for (auto n : nums) { TrieNode* cur = root; // 必须是从左往右，因为不是这样的话就不是最大，这里用了贪心 for (int i = 31; i >= 0; i--) { int c = ((n >> i) & 1); if (!cur->child[c]) cur->child[c] = new TrieNode(); cur = cur->child[c]; } } int ret = 0; for (auto n : nums) { TrieNode* cur = root; int ans = 0; for (int i = 31; i >= 0; i--) { int c = ((n >> i) & 1); if (cur->child[!c]) { ans <<= 1; ans |= 1; cur = cur->child[!c]; } // 只要有一条路肯定能走到底，所以不用判断为空的情况 else { ans <<= 1; cur = cur->child[c]; } } for (int i = 0; i < 32; i++) { cout << ((2147483648 >> i) & 1); } cout << endl; ret = max(ret, ans); } return ret; } };
Given a 2D board and a list of words from the dictionary, find all words in the board.
Each word must be constructed from letters of sequentially adjacent cell, where “adjacent” cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once in a word.
1 2 3 4 5 6 7 8 9 10 11 12
Example:
Input: words = ["oath","pea","eat","rain"] and board = [ ['o','a','a','n'], ['e','t','a','e'], ['i','h','k','r'], ['i','f','l','v'] ]
structTrieNode { TrieNode* child[26]; bool isKey; TrieNode() : isKey(false) { memset(child, NULL, sizeof(child)); } }; classSolution { public: voidhelper(TrieNode* root, vector<vector<char>>& board, int x, int y, string ans, unordered_set<string>& ret){ ans = ans + board[x][y]; if (root->isKey) { ret.insert(ans); } board[x][y] = '\0'; int a[4] = {0, 0, -1, 1}, b[4] = {-1, 1, 0, 0}; int m = board.size(), n = board[0].size(); for (int i = 0; i < 4; i++) { int X = x + a[i], Y = y + b[i]; if (X >= 0 && X < m && Y >= 0 && Y < n && board[X][Y] != '\0') { int c = board[X][Y] - 'a'; if (root->child[c]) { helper(root->child[c], board, X, Y, ans, ret); } } } board[x][y] = ans.back(); } vector<string> findWords(vector<vector<char>>& board, vector<string>& words) { if (board.empty() || board[0].empty()) returnvector<string>(); TrieNode* root = new TrieNode(); for (auto s : words) { auto cur = root; for (auto i : s) { int c = i - 'a'; if (!cur->child[c]) cur->child[c] = new TrieNode(); cur = cur->child[c]; } cur->isKey = true; } unordered_set<string> ret_set; for (int i = 0; i < board.size(); i++) { for (int j = 0; j < board[0].size(); j++) { int c = board[i][j] - 'a'; if (root->child[c]) helper(root->child[c], board, i, j, "", ret_set); } } vector<string> ret; for (auto s : ret_set) { ret.push_back(s); } return ret; } };
classSolution { public: voidheapfy(vector<int>& nums, int index, int max){ int left = index * 2 + 1; int right = left + 1; int smallest = index; if (left < max && nums[left] < nums[smallest]) smallest = left; if (right < max && nums[right] < nums[smallest]) smallest = right; if (index != smallest) { swap(nums[index], nums[smallest]); heapfy(nums, smallest, max); } } inthelper(vector<int>& nums, int k){ int n = nums.size(); if (n < k) return-1; vector<int> ans; for (int i = 0; i < k; i++) ans.push_back(nums[i]); for (int i = k / 2; i >= 0; i--) heapfy(ans, i, k); for (int i = k; i < n; i++) { if (nums[i] > ans[0]) { ans[0] = nums[i]; heapfy(ans, 0, k); } } return ans[0]; } intfindKthLargest(vector<int>& nums, int k){ return helper(nums, k); } };
classSolution { public: voidheapfy(vector<int>& nums, int index, int max, unordered_map<int, int>& m){ int left = index * 2 + 1; int right = left + 1; int smallest = index; if (left < max && m[nums[left]] < m[nums[smallest]]) smallest = left; if (right < max && m[nums[right]] < m[nums[smallest]]) smallest = right; if (smallest != index) { swap(nums[smallest], nums[index]); heapfy(nums, smallest, max, m); } } vector<int> topKFrequent(vector<int>& nums, int k) { unordered_map<int, int> m; vector<int> ans; for (auto i : nums) { m[i] ++; if (m[i] == 1) ans.push_back(i); } int len = ans.size(); if (len < k) return ans; vector<int> ret; for (int i = 0; i < k; i++) ret.push_back(ans[i]); for (int i = k / 2 - 1; i >= 0; i--) heapfy(ret, i, k, m); for (int i = k; i < len; i++) { if (m[ans[i]] > m[ret[0]]) { ret[0] = ans[i]; for (int j = k / 2 - 1; j >= 0; j--) heapfy(ret, j, k, m); } } return ret; } };
You are given two integer arrays nums1 and nums2 sorted in ascending order and an integer k.
Define a pair (u,v) which consists of one element from the first array and one element from the second array.
Find the k pairs (u1,v1),(u2,v2) …(uk,vk) with the smallest sums.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
Example 1: Given nums1 = [1,7,11], nums2 = [2,4,6], k = 3 Return: [1,2],[1,4],[1,6] The first 3 pairs are returned from the sequence: [1,2],[1,4],[1,6],[7,2],[7,4],[11,2],[7,6],[11,4],[11,6]
Example 2: Given nums1 = [1,1,2], nums2 = [1,2,3], k = 2 Return: [1,1],[1,1] The first 2 pairs are returned from the sequence: [1,1],[1,1],[1,2],[2,1],[1,2],[2,2],[1,3],[1,3],[2,3]
Example 3: Given nums1 = [1,2], nums2 = [3], k = 3 Return: [1,3],[2,3] All possible pairs are returned from the sequence: [1,3],[2,3]
Median is the middle value in an ordered integer list. If the size of the list is even, there is no middle value. So the median is the mean of the two middle value.
For example, [2,3,4], the median is 3
[2,3], the median is (2 + 3) / 2 = 2.5
Design a data structure that supports the following two operations:
void addNum(int num) - Add a integer number from the data stream to the data structure. double findMedian() - Return the median of all elements so far.
/** * Your MedianFinder object will be instantiated and called as such: * MedianFinder obj = new MedianFinder(); * obj.addNum(num); * double param_2 = obj.findMedian(); */
Median is the middle value in an ordered integer list. If the size of the list is even, there is no middle value. So the median is the mean of the two middle value.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
Examples: [2,3,4] , the median is 3
[2,3], the median is (2 + 3) / 2 = 2.5
Given an array nums, there is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves right by one position. Your job is to output the median array for each window in the original array.
For example, Given nums = [1,3,-1,-3,5,3,6,7], and k = 3.
Design a simplified version of Twitter where users can post tweets, follow/unfollow another user and is able to see the 10 most recent tweets in the user’s news feed. Your design should support the following methods:
postTweet(userId, tweetId): Compose a new tweet. getNewsFeed(userId): Retrieve the 10 most recent tweet ids in the user’s news feed. Each item in the news feed must be posted by users who the user followed or by the user herself. Tweets must be ordered from most recent to least recent. follow(followerId, followeeId): Follower follows a followee. unfollow(followerId, followeeId): Follower unfollows a followee.
// User 1 posts a new tweet (id = 5). twitter.postTweet(1, 5);
// User 1's news feed should return a list with 1 tweet id -> [5]. twitter.getNewsFeed(1);
// User 1 follows user 2. twitter.follow(1, 2);
// User 2 posts a new tweet (id = 6). twitter.postTweet(2, 6);
// User 1's news feed should return a list with 2 tweet ids -> [6, 5]. // Tweet id 6 should precede tweet id 5 because it is posted after tweet id 5. twitter.getNewsFeed(1);
// User 1 unfollows user 2. twitter.unfollow(1, 2);
// User 1's news feed should return a list with 1 tweet id -> [5], // since user 1 is no longer following user 2. twitter.getNewsFeed(1);
structtweet { int id; int time; tweet(int id, int time) : id(id), time(time) {}; }; classTwitter { public: unordered_map<int, unordered_set<int>> fo; unordered_map<int, vector<tweet>> po; int current; /** Initialize your data structure here. */ Twitter() { current = 0; } /** Compose a new tweet. */ voidpostTweet(int userId, int tweetId){ current ++; po[userId].push_back(tweet(tweetId, current)); } voidheapfy(vector<tweet>& nums, int index, int max){ int left = index * 2 + 1; int right = left + 1; int smallest = index; if (left < max && nums[left].time > nums[smallest].time) smallest = left; if (right < max && nums[right].time > nums[smallest].time) smallest = right; if (smallest != index) { swap(nums[smallest], nums[index]); heapfy(nums, smallest, max); } } /** Retrieve the 10 most recent tweet ids in the user's news feed. Each item in the news feed must be posted by users who the user followed or by the user herself. Tweets must be ordered from most recent to least recent. */ vector<int> getNewsFeed(int userId) { // 此处在实际使用中应该使用多路归并的思路，但是这里为了简便就将所有数据放到堆中然后选出top10 vector<tweet> ans; for (auto i : fo[userId]) { for (auto j : po[i]) { ans.push_back(j); } } for (auto i : po[userId]) { ans.push_back(i); } int len = ans.size(); for (int i = len / 2 - 1; i >= 0; i--) heapfy(ans, i, len); vector<int> ret; for (int i = len - 1; i >= 0 && ret.size() < 10; i--) { ret.push_back(ans[0].id); swap(ans[i], ans[0]); // 此处注意堆排序调整只需要调整一个路径就可以 heapfy(ans, 0, i); } return ret; } /** Follower follows a followee. If the operation is invalid, it should be a no-op. */ voidfollow(int followerId, int followeeId){ if (followerId == followeeId) return; fo[followerId].insert(followeeId); } /** Follower unfollows a followee. If the operation is invalid, it should be a no-op. */ voidunfollow(int followerId, int followeeId){ fo[followerId].erase(followeeId); } };
/** * Your Twitter object will be instantiated and called as such: * Twitter obj = new Twitter(); * obj.postTweet(userId,tweetId); * vector<int> param_2 = obj.getNewsFeed(userId); * obj.follow(followerId,followeeId); * obj.unfollow(followerId,followeeId); */
voidheapfy(vector<pair<int, int>>& ans, vector<vector<int>>& nums, int index, int max){ int left = index * 2 + 1; int right = left + 1; int smallest = index; if (left < max && nums[ans[left].first][ans[left].second] < nums[ans[smallest].first][ans[smallest].second]) smallest = left; if (right < max && nums[ans[right].first][ans[right].second] < nums[ans[smallest].first][ans[smallest].second]) smallest = right; if (index != smallest) { swap(ans[index], ans[smallest]); heapfy(ans, nums, smallest, max); } }
vector<int> helper(vector<vector<int>>& nums) { int n = nums.size(); vector<int> ret; vector<pair<int, int>> ans; int N = 0; for (int i = 0; i < n; i++) { N += nums[i].size(); ans.push_back(make_pair(i, 0)); } for (int i = n /2; i >= 0; i--) { heapfy(ans, nums, i, n); } while (ret.size() < N) { auto temp = ans[0]; ret.push_back(nums[temp.first][temp.second]); cout << temp.first << ":" << temp.second << ": "<< ret.back() << endl; ans.erase(ans.begin()); if (temp.second + 1 < nums[temp.first].size()) { ans.push_back(make_pair(temp.first, temp.second + 1)); } int len = ans.size(); for (int i = len / 2; i >= 0; i--) heapfy(ans, nums, i, len); } return ret;
}
intmain(){ int n; cin >> n; vector<vector<int>> nums; for (int i = 0; i < n; i++) { int t; cin >> t; vector<int> ans(t, 0); for (int j = 0; j < t; j++) { cin >> ans[j]; } nums.push_back(ans); } auto ret = helper(nums); for (auto i : ret) { cout << i << " "; } return0; }
Implement pow(x, n), which calculates x raised to the power n (xn).
1 2
Input: 2.00000, 10 Output: 1024.00000
代码
1 2 3 4 5 6 7 8 9 10 11 12 13 14
classSolution { public: doublemyPow(double x, int n){ double ret = 1.0; // 注意要整型溢出 long N = abs((long) n); while (N) { if (N & 1) ret *= x; N >>= 1; x *= x; } return n > 0 ? ret : 1 / ret; } };
Input: 43261596 Output: 964176192 Explanation: 43261596 represented in binary as 00000010100101000001111010011100, return 964176192 represented in binary as 00111001011110000010100101000000.
The Hamming distance between two integers is the number of positions at which the corresponding bits are different.
Now your job is to find the total Hamming distance between all pairs of the given numbers.
1 2 3 4 5 6 7
Input: 4, 14, 2
Output: 6
Explanation: In binary representation, the 4 is 0100, 14 is 1110, and 2 is 0010 (just showing the four bits relevant in this case). So the answer will be: HammingDistance(4, 14) + HammingDistance(4, 2) + HammingDistance(14, 2) = 2 + 2 + 2 = 6.
代码
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
classSolution { public: inttotalHammingDistance(vector<int>& nums){ // 此题主要思想是将每一位分开计算 int ret = 0, n = nums.size(); for (int i = 0; i < 31; i++) { int cnt = 0; for (auto j : nums) { cnt += (j >> i) & 1; } ret += cnt * (n - cnt); } return ret; } };
Given an array containing n distinct numbers taken from 0, 1, 2, …, n, find the one that is missing from the array.
1 2 3 4 5 6 7
Example 1: Input: [3,0,1] Output: 2
Example 2: Input: [9,6,4,2,3,5,7,0,1] Output: 8
代码
1 2 3 4 5 6 7 8 9 10 11 12 13
classSolution { public: // 从1到n都被抑或一遍，然后再被覆盖一遍就会消失，被抑或一遍的就会剩下。 intmissingNumber(vector<int>& nums){ int n = nums.size(); int ans = n; for (int i = 0; i < n; i++) { ans ^= i; ans ^= nums[i]; } return ans; } };
Given an array of numbers nums, in which exactly two elements appear only once and all the other elements appear exactly twice. Find the two elements that appear only once.
1 2 3 4
Example:
Input: [1,2,1,3,2,5] Output: [3,5]
代码
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
classSolution { public: vector<int> singleNumber(vector<int>& nums) { int ans = 0; for (auto i : nums) { ans ^= i; } // 此步比较重要，选取一位为1的数，说明该位出现过一次 int m = (ans & (ans - 1)) ^ ans; int a = 0, b = 0; for (auto i : nums) { if (i & m) a ^= i; else b ^= i; } returnvector<int>{a, b}; } };
Given a positive integer n and you can do operations as follow:
If n is even, replace n with n/2. If n is odd, you can replace n with either n + 1 or n - 1. What is the minimum number of replacements needed for n to become 1?
classSolution { public: intintegerReplacement(int N){ longlong n = N; int ret = 0; while (n != 1) { ret ++; if (n & 1) { if (n & 2 && n != 3) n++; else n --; } else n >>= 1; } return ret; } };
voidfind_negative_cycle(int index, vector<int>& parents, int n){ cout << "负环:" << endl; int x = parents[index]; while (index != parents[x]) { cout << x << endl; x = parents[x]; } }
inthelper(int n, vector<pair<int, int>>& grap){ if (n == 1) return0; vector<unordered_set<int>> count(n, unordered_set<int>()); for (auto i : grap) { if (i.first == i.second) continue; // 去掉环 count[i.first].insert(i.second); count[i.second].insert(i.first); } int ret = 0; vector<int> current; for (int i = 0; i < n; i++) { int len = count[i].size(); if (len == 1) current.push_back(i); } while (true) { vector<int> next; ret ++; for (auto i : current) { // 默认所有current中的点都是悬挂点 // 所以遍历叶子节点的相邻点并去掉与之相连的边，这些边就不能被访问到。 for (auto j : count[i]) { count[j].erase(i); if (count[j].size() == 1) next.push_back(j); } } if (next.empty()) break; current = next; } // 终止集合是单点是迭代次数的二倍，集合为两个点还要多算连接这两个点的边 // 因为终止条件是next为空，所以会将终止集合也多算一次迭代，所以需要减去。 return current.size() == 1 ? ret * 2 - 2: ret * 2 - 1; }
intmain(){ int n, k; cin >> k >> n; vector<pair<int, int>> grap; for (int i = 0; i < k; i ++) { int x, y; cin >> x >> y; grap.push_back(make_pair(x, y)); } cout << helper(n, grap) << endl; return0; } /* 5 4 0 1 1 2 2 3 0 2 3 3 */
intfind(int x, vector<int>& set){ int y = x; while (set[x] != x) { x = set[x]; } while (x != y) { int t = set[y]; set[y] = x; y = t; } return x; }
voidmerge(int x, int y, vector<int>& set){ int p1 = find(x, set); int p2 = find(y, set); if (p1 != p2) { set[p1] = p2; } } intmain(){ int n, k; cin >> n >> k; vector<int> set(n + 1, 0); for (int i = 1; i <= n; i++) { set[i] = i; } for (int i = 0; i < k; i++) { int x, y; cin >> x >> y; merge(x, y, set); } int ret = 0; for (int i = 1; i <= n; i++) { if (set[i] == i) ret ++; } cout << ret << endl; return0; }
intfind(int x, vector<int>& set){ int y = x; while (x != set[x]) { x = set[x]; } while (y != x) { int t = set[y]; set[y] = x; y = t; } return x; }
voidmerge(int x, int y, vector<int>& set){ int p1 = find(x, set); int p2 = find(y, set); if (p1 != p2) { set[p1] = p2; } }
voidhelper(vector<unordered_set<int>>& edges){ int n = edges.size(); vector<int> set(n, 0); for (int i = 0; i < n; i++) { set[i] = i; } for (int i = 0; i < n; i++) { for (auto j : edges[i]) { merge(i, j, set); } } vector<unordered_set<int>> ret(n, unordered_set<int>()); for (int i = 0; i < n; i++) { ret[set[i]].insert(i); } for (auto i : ret) { if (i.empty()) continue; for (auto j : i) { cout << j << " "; } cout << endl; } }
intmain(){ int n, k; cin >> n >> k; vector<unordered_set<int>> edges(n, unordered_set<int>()); for (int i = 0; i < k; i++) { int x, y; cin >> x >> y; edges[x].insert(y); edges[y].insert(x); } helper(edges); return0; }
voidhelper(int n, vector<pair<int, int>>& edges){ vector<int> degree(n, 0); vector<unordered_set<int>> count(n, unordered_set<int>()); for (auto i : edges) { degree[i.second]++; count[i.first].insert(i.second); } vector<int> cur; for (int i = 0; i < n; i++) { if (degree[i] == 0) { cur.push_back(i); } } vector<vector<int>> ret; while (!cur.empty()) { vector<int> ans; for (auto i : cur) { for (auto j : count[i]) { degree[j] --; if (degree[j] == 0) ans.push_back(j); } } ret.push_back(cur); cur = ans; } for (auto i : ret) { for (auto j : i) { cout << j << " "; } cout << endl; } }
intmain(){ int n, k; cin >> n >> k; vector<pair<int, int>> edges; for (int i = 0; i < k; i++) { int x, y; cin >> x >>y; edges.push_back(make_pair(x, y)); } helper(n, edges); return0; }
intBFS(vector<int>& pre, int start, int end, vector<vector<int>>& cap){ queue<int> q; int n = cap.size(); for (int i = 0; i < n; i++) { pre[i] = -1; } vector<int> flow(n, 0); // 保存流 // 初始化 pre[start] = start; flow[start] = 0x7FFFFFFF; q.push(start); while (!q.empty()) { // 用bfs搜索整个路 int index = q.front(); q.pop(); if (index == end) break; // 到达终点为可增路 for (int i = 0; i < n; i++) { if (i != start && cap[index][i] > 0 && pre[i] == -1) { // 更新流 pre[i] = index; flow[i] = min(flow[index], cap[index][i]); q.push(i); } } } // 可增路无法到达终点 if (pre[end] == -1) return-1; elsereturn flow[end]; }
inthelper(int n, vector<vector<int>>& cap, vector<int>& pre, int start, int end){ int ret = 0; int increase = 0; // 单次可增路的增大流容量 while ((increase = BFS(pre, start, end, cap)) != -1) { // 返回-1代表没有可增路 int temp = end; while (temp != start) { // 更新可增路上的容量 int last = pre[temp]; cap[last][temp] -= increase; // 反向也要增加 cap[temp][last] += increase; temp = last; } ret += increase; } return ret; }
intmain(){ int n, m; cin >> n >> m; vector<vector<int>> cap(n, vector<int>(n, 0)); vector<int> pre(n, -1); // 用来标记可增路的路径 for (int i = 0; i < m; i++) { int x, y, v; cin >> x >> y >> v; if (x == y) continue; cap[x][y] = v; } cout << helper(n, cap, pre, 0, n - 1) << endl;; return0; }
intdfs(int start, int end, vector<vector<int>>& cap, vector<bool>& visited, int flow){ int n = visited.size(); if (start == end) { return flow; } for (int i = 0; i < n; i++) { if (cap[start][i] > 0 && !visited[i]) { visited[i] = true; int f = dfs(i, end, cap, visited, min(flow, cap[start][i])); if (f > 0) { cap[start][i] -= f; cap[i][start] += f; return f; }
} } // 没有可增路返回0 return0; }
inthelper(int n, vector<vector<int>>& cap, int start, int end){ int ret = 0; while (true) { vector<bool> visited(n, false); int flow = dfs(start, end, cap, visited, 0x7FFFFFFF); if (flow == 0) break; ret += flow;
} return ret;
}
intmain(){ int n, m; cin >> n >> m; vector<vector<int>> cap(n, vector<int>(n, 0)); for (int i = 0; i < m; i++) { int x, y, v; cin >> x >> y >> v; cap[x][y] = v; } cout << helper(n, cap, 0, n - 1) << endl; return0; } /* 4 5 0 1 40 1 2 30 1 3 20 0 3 20 2 3 10 */
intbfs(int start, int end, vector<vector<int>>& cap, vector<int>& dep){ queue<int> q; q.push(start); int n = dep.size(); for (int i = 0; i < n; i++) { dep[i] = -1; } dep[start] = 0; while (!q.empty()) { int index = q.front(); q.pop(); for (int i = 0; i < n; i++) { if (cap[index][i] > 0 && dep[i] == -1) { dep[i] = dep[index] + 1; q.push(i); } } } return dep[end] != -1; }
intdfs(int start, int end, vector<vector<int>>& cap, vector<int>& dep, int flow){ if (start == end) return flow; int n = dep.size(); for (int i = 0; i < n; i++) { if (cap[start][i] > 0 && dep[i] == dep[start] + 1) { int temp = dfs(i, end, cap, dep, min(flow, cap[start][i])); if (temp != 0) { cap[start][i] -= temp; cap[i][start] += temp; return temp; } } } return0; }
inthelper(int n, int start, int end, vector<vector<int>>& cap){ int ret = 0; vector<int> dep(n, -1); while (bfs(start, end, cap, dep)) { while (true) { int temp = dfs(start, end, cap, dep, 0x7FFFFFFF); if (!temp) break; ret += temp; } } return ret; }
intmain(){ int n, m; cin >> n >> m; vector<vector<int>> cap(n, vector<int>(n, 0)); for (int i = 0; i < m; i++) { int x, y, v; cin >> x >> y >> v; cap[x][y] = v; } cout << helper(n, 0, n - 1, cap) << endl; return0; } /* 4 5 0 1 40 1 2 30 1 3 20 0 3 20 2 3 10 */
classSolution { public: intrectCover(int number){ if (number <= 2) return number; int pre = 1, cur = 2; for (int i = 3; i <= number; i++) { cur += pre; pre = cur - pre; } return cur; } };
classSolution { public: doublePower(double base, int exponent){ int syn = exponent > 0 ? 1 : -1; double ret = 1.0; longlong N = abs((longlong) exponent); // 注意可能取负溢出 while (N) { if (N & 1) ret *= base; base *= base; N >>= 1; } return syn == 1 ? ret : 1/ ret; } };
voidhelper(vector<int>& nums){ int n = nums.size(); int left = 0, right = n - 1; while (left < right) { while (left < right && nums[left] % 2) left++; while (left < right && nums[right] % 2 == 0) right --; if (left < right) { swap(nums[left], nums[right]); left ++, right --; } } }
intmain(){ int n; cin >> n; vector<int> nums(n, 0); for (int i = 0; i < n; i++) { cin >> nums[i]; } helper(nums); for (auto i : nums) { cout << i << " "; } cout << endl; return0; }
// 堆排序思路 classSolution { public: voidheapfy(vector<int>& nums, int index, int max){ int left = index * 2 + 1; int right = left + 1; int small = index; if (left < max && nums[left] < nums[small]) small = left; if (right < max && nums[right] < nums[small]) small = right; if (small != index) { swap(nums[index], nums[small]); heapfy(nums, small, max); } } voidhelper(vector<int>& nums, vector<int>& ret, int k){ int len = nums.size(); for (int i = len / 2; i >= 0; i--) heapfy(nums, i, len); for (int i = len - 1; i >= 0 && ret.size() < k; i--) { ret.push_back(nums[0]); swap(nums[0], nums[i]); heapfy(nums, 0, i); } } vector<int> GetLeastNumbers_Solution(vector<int> input, int k) { int len = input.size(); vector<int> ret; if (k > len) return ret; helper(input, ret, k); return ret; } };
classSolution { public: intFindGreatestSumOfSubArray(vector<int> array){ if (array.empty()) return0; int ret = array[0], ans = array[0]; for (int i = 1; i < array.size(); i++) { ans += array[i]; ret = max(ret, ans); if (ans < 0) ans = 0; } return ret; } };
classSolution { public: intGetNumberOfK(vector<int> data ,int k){ int len = data.size(); if (len == 0) return0; int left = 0, right = len - 1; while (left < right) { int mid = left + ((right - left) >> 1); // 手推，左端不相等向右移 if (data[mid] < k) left = mid + 1; // 小于等于更新右边界 else right = mid; // 因为有left = mid + 1，所以不会出现left = right - 1的时候left不更新的情况。 } if (data[left] != k) return0; right = len - 1; int low = left, ret; while (left < right) { // 手推，大于的时候右边界向左移 // 等于的时候保存当前值，然后将左值向右移 int mid = left + ((right - left) >> 1); if (data[mid] > k) right = mid - 1, ret = mid; else left = mid + 1; } return ret - low + 1; } };
singel number iii
一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
classSolution { public: voidFindNumsAppearOnce(vector<int> data,int* num1,int *num2){ int ans = 0; for (auto i : data) { ans ^= i; } // 此处位操作比较关键 int c = ans ^ (ans & (ans - 1)); *num1 = 0, * num2 = 0; for (auto i : data) { if (i & c) *num1 ^= i; else *num2 ^= i; } } };
和为s的连续正数序列
小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!
classSolution { public: vector<vector<int> > FindContinuousSequence(int sum) { vector<vector<int>> ret; // 双指针法 if (sum < 3) return ret; int ans = 3; int left = 1, right = 2; while (left < ((sum + 1) >> 1) && right < sum) { while (ans > sum) { ans -= left; left ++; } if (ans == sum) { vector<int> temp; for (int i = left; i <= right; i++) temp.push_back(i); ret.push_back(temp); } right ++; ans += right; } return ret; } };
classSolution { public: stringLeftRotateString(string str, int n){ int len = str.size(); if (!len) return""; n = (n + len) % len; reverse(str.begin(), str.begin() + n); reverse(str.begin() + n, str.end()); reverse(str.begin(), str.end()); return str; } };
翻转单词顺序
牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？
classSolution { public: intLastRemaining_Solution(int n, int m){ if (!n) return-1; int ret = 0; for (int i = 2; i <= n; i++) { ret = (ret + m) % i; } return ret; } };
classSolution { public: // Parameters: // numbers: an array of integers // length: the length of array numbers // duplication: (Output) the duplicated number in the array number // Return value: true if the input is valid, and there are some duplications in the array number // otherwise false boolduplicate(int numbers[], int length, int* duplication){ for (int i = 0; i < length; i++) { if (numbers[abs(numbers[i])] < 0) { *duplication = abs(numbers[i]); returntrue; } numbers[numbers[i]] *= -1; } returnfalse; } };
classSolution { public: int store[256]; int index = 0; Solution() { memset(store, -1, sizeof(store)); } //Insert one char from stringstream voidInsert(char ch){ if (store[ch] == -1) store[ch] = index; else store[ch] = -2; index ++; } //return the first appearence once char in current stringstream charFirstAppearingOnce(){ int ret_index = INT_MAX; char ret = '\0'; for (int i = 0; i < 256; i++) { if (store[i] >= 0 && ret_index > store[i]) { ret_index = store[i]; ret = (char) i; } } if (ret == '\0') return'#'; elsereturn ret; }
classSolution { public: vector<int> maxInWindows(constvector<int>& num, unsignedint size) { int len = (longlong)size; int n = num.size(); if (!len) returnvector<int>(); deque<int> d; vector<int> ret; for (int i = 0; i < n; i++) { while (!d.empty() && num[d.back()] <= num[i]) d.pop_back(); d.push_back(i); while (!d.empty() && d.front() <= i - len) d.pop_front(); if (i >= len - 1) ret.push_back(num[d.front()]); } return ret; } };
矩阵中的路径
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。 例如 a b c e s f c s a d e e 矩阵中包含一条字符串”bcced”的路径，但是矩阵中不包含”abcb”路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。
classSolution { public: int m, n; boolhelper(char* matrix, constchar* s, int x, int y){ if (*s == '\0') returntrue; if (x < 0 || x >= m || y >= n || y < 0) returnfalse; char temp = matrix[x * n + y]; if (*s != temp) returnfalse; matrix[x * n + y] = '\0'; if (helper(matrix, s + 1, x + 1, y) || helper(matrix, s + 1, x, y + 1) || helper(matrix, s + 1, x - 1, y) || helper(matrix, s + 1, x, y - 1)) returntrue; matrix[x * n + y] = temp; returnfalse; } boolhasPath(char* matrix, int rows, int cols, char* str){ m = rows, n = cols; for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { if (helper(matrix, str, i, j)) returntrue; } } returnfalse; }
classSolution { public: int m, n, k; boolcheck(int x, int y){ int ans = 0; while (x) { ans += x % 10; x /= 10; } while (y) { ans += y % 10; y /=10; } return ans > k; } voidhelper(int x, int y, vector<vector<bool>>& visited, int& ret){ if (x < 0 || x >= m || y < 0 || y >= n || visited[x][y] || check(x, y)) return; ret ++; visited[x][y] = true; int a[4] = {0, 0, -1, 1}, b[4] = {-1, 1, 0, 0}; for (int i = 0; i < 4; i++) { helper(x + a[i], y + b[i], visited, ret); } } intmovingCount(int threshold, int rows, int cols){ m = rows, n = cols, k = threshold; if (m < 0 || n < 0) { return0; } vector<vector<bool>> visited(m, vector<bool>(n, false)); int ret = 0; helper(0, 0, visited, ret); return ret; } };
doublehelper(vector<pair<double, double>>& nums, vector<pair<double, double>>& rule){ double ans = 0; double ret = 0; for (auto i : nums) { ans += i.first; ret += i.second == 1.0 ? i.first * 0.8 : i.first; } for (auto i : rule) { if (i.first <= ans) { ret = ret > (ans - i.second) ? (ans - i.second) : ret; } } return ret; }
intmain(){ int n, m; cin >> n >> m; vector<pair<double, double>> nums, rule; for (int i = 0; i < n; i++) { double a, b; cin >> a >> b; nums.push_back(make_pair(a, b)); } for (int i = 0; i < m; i++) { double a, b; cin >> a >> b; rule.push_back(make_pair(a, b)); } printf("%.2f\n", helper(nums, rule)); return0; }
第一行三个整数n，m，k分别表示要买的可乐数、小美喝的可乐数以及可供选择的可乐种数。接下来k行，每行两个整数a，b分别表示某种可乐分别给予小美和小团的快乐程度。 对于所有数据，1 <= n <= 10,000, 0 <= m <= n, 1 <= k <= 10,000, -10,000 <= a, b <= 10,000
#include<iostream> #include<vector> #include<utility> usingnamespacestd; voidhelper(vector<pair<double, double>>& nums, int n, int m){ double ret = -10E9; int index = -1; int len = nums.size(); for (int i = 0; i < len; i++) { auto temp = nums[i]; double ans = temp.first * m / n + temp.second * (n - m) / n; if (ret <= ans) { ret = ans; index = i; } } if (nums.empty()) return; if (index == 0) cout << n; elsecout << "0"; for (int i = 1; i < len; i++) { if (i == index) { cout << " " << n; } elsecout << " 0"; } cout << endl; }
intmain(){ int n, m, k; cin >> n >> m >> k; vector<pair<double, double>> nums; for (int i = 0; i < k; i++) { double a, b; cin >> a >> b; nums.push_back(make_pair(a, b)); } helper(nums, n, m); return0; }
voidhelper(vector<vector<longlong>>& nums, vector<longlong> w, constint n, constint m, constint k, vector<vector<int>>& ret){ vector<longlong> score(n, 0); vector<longlong> mark(n, 0); vector<longlong> max_score(m, 0); vector<longlong> ans(m, 1); for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { max_score[i] = max_score[i] < nums[j][i] ? nums[j][i] : max_score[i]; } if (max_score[i] == 0) { max_score[i] = 1; } } // 直接将所有max_score连称会溢出 for (int i = 0; i < m; i++) { ans[i] = w[i]; for (int j = 0; j < m; j++) { if (j != i) ans[i] *= max_score[j]; } }
for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { score[i] += nums[i][j] * ans[j]; } mark[i] = score[i]; } sort(mark.begin(), mark.end(), greater<longlong>()); for (int i = 0; i < n; i++) { if (mark[k-1] <= score[i]) ret[0][i] ++; // 胜利的局数 if (k != n && mark[k] >= score[i]) ret[1][i] ++; // 失败的局数 } }
intmain(){ int n, m, k, C; cin >> n >> m >> k >> C; vector<longlong> w(m, 0); for (int i = 0; i < m; i++) { cin >> w[i]; } int x, y; vector<vector<longlong>> nums(n, vector<longlong>(m, 0)); for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { cin >> nums[i][j]; if (nums[i][j] == -1) x = i, y = j; } } vector<vector<int>> ret(2, vector<int>(n, 0)); for (int i = 0; i <= C; i++) { nums[x][y] = i; helper(nums, w, n, m, k, ret); } for (int i = 0; i < n; i++) { if (ret[1][i] == 0) cout << 1 << endl; elseif (ret[0][i] == 0) cout << 2 << endl; elsecout << 3 << endl; } return0; }
E 你的城市
题目描述
2018年第一季度，美团旅行的酒店业务以5770万的订单总量，成为行业第一名。 与此同时，美团旅行也提供机票、火车票、船票等各种服务，不断开辟新的目的旅游城市。最近新开的目的地，就包括对小A有特殊意义的偏僻小城C。 “我来到 你的城市 熟悉的那一条街。”小A哼着歌，从北京出发，要去C城。这对他非常重要，必须当天到达，虽然交通并不是非常方便。 但是，错过火车并不是一个小概率事件。为了保险起见，小A决定选择一个即使错过火车也存在补救措施的交通方案。（即假使未赶上原方案中的任何一班火车，依然可以改乘其他的车次能够在当天到达C城，但同时小A是一个乐观主义者，所以他认为改乘以后的所有车次都不会延误。）当然了，在满足上述条件的情况下，小A希望花费的钱越少越好（只考虑计划中的，不考虑发生意外时换乘带来的代价）。 城市及交通网可以看做一张n个点m条边的有向图。每个点代表一个城市（1号点代表北京，n号点代表C城）。每条边由一个五元组<x, y, c, ts, td>组成，表示存在一个车次，由ts时刻从城市x出发，在td时刻到达城市y，且花费为c元。 为了简化问题，ts，td均为以半小时为基本单位（具体格式见样例及Hint）。并假设每次中转最少需要花费半个小时，且中转只能发生在同一城市（即到达一个城市距离再次从这个城市出发至少需要间隔半个小时），注意，小 A 如果因为没赶上车次需要改乘，也需要半个小时的时间。 问小A到达C城最少需要花费多少钱（行程必须在这一天内完成，可以在0:00上车，也可以在24:00到达）。
输入描述:
第一行，两个正整数n, m。n表示城市数量，m表示当天不同班次的火车数量。 接下来m行，每行3个整数x, y, c加两个字符串ts, td，均以空格作为分隔，表示当天的某一班火车。其中x, y, c, ts, td的含义如前描述。 所有的车次都是当天的，没有隔夜的票。 2 <= n <= 500, m <= 15000, c <= 1000, ts < td，所有数均为正整数。 车次保证不过夜，时间范围0:00, 0:30, 1:00, … , 23:00, 23:30, 24:00，可能存在重复车次。
##题目描述 美团外卖日订单已经超过2000万，背后有一个非常复杂的智能调度系统。 我们考虑一个简化的情形，有n个外卖小哥要去 n 家商店取货，第 i 个外卖小哥到达商店 j 需要时间 e[i][j] 。现在有 m 对外卖小哥和商店的合作关系。假定每个外卖小哥只能取到一个货物，每个商店只需要一位外卖小哥取货。 询问最少多少时间，能有 k 位外卖小哥到达 k 个商店取到货物？对于每个 k ，都输出一个数表示最少使用时间，如果无解输出 -1。
输入描述:
第一行输入两个整数 n , m （1 <= n <= 1000 , 1 <= m <= 100000）。 接下来 m 行，每行输入 3 个整数 i , j , e[i][j] (1 <= i, j <= n , 0 <= e[i][j] <= 10^9)，定义如题所述。 注：本题测试用例较多，请耐心等待判题结果，也可以去排行榜刷新查看自己的提交结果。
输出描述:
输出一行n个整数，第 i 个整数，表示当 k=i 时，需要的最少时间，如果无解输出-1，结尾无空格。
Welcome to your week 4 assignment (part 1 of 2)! You have previously trained a 2-layer Neural Network (with a single hidden layer). This week, you will build a deep neural network, with as many layers as you want!
In this notebook, you will implement all the functions required to build a deep neural network.
In the next assignment, you will use these functions to build a deep neural network for image classification.
After this assignment you will be able to:
Use non-linear units like ReLU to improve your model
Build a deeper neural network (with more than 1 hidden layer)
Implement an easy-to-use neural network class
Notation:
Superscript $[l]$ denotes a quantity associated with the $l^{th}$ layer.
Example: $a^{[L]}$ is the $L^{th}$ layer activation. $W^{[L]}$ and $b^{[L]}$ are the $L^{th}$ layer parameters.
Superscript $(i)$ denotes a quantity associated with the $i^{th}$ example.
Example: $x^{(i)}$ is the $i^{th}$ training example.
Lowerscript $i$ denotes the $i^{th}$ entry of a vector.
Example: $a^{[l]}_i$ denotes the $i^{th}$ entry of the $l^{th}$ layer’s activations).
Let’s get started!
1 - Packages
Let’s first import all the packages that you will need during this assignment.
numpy is the main package for scientific computing with Python.
dnn_utils provides some necessary functions for this notebook.
testCases provides some test cases to assess the correctness of your functions
np.random.seed(1) is used to keep all the random function calls consistent. It will help us grade your work. Please don’t change the seed.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
import numpy as np import h5py import matplotlib.pyplot as plt from testCases_v4 import * from dnn_utils_v2 import sigmoid, sigmoid_backward, relu, relu_backward
%matplotlib inline plt.rcParams['figure.figsize'] = (5.0, 4.0) # set default size of plots plt.rcParams['image.interpolation'] = 'nearest' plt.rcParams['image.cmap'] = 'gray'
%load_ext autoreload %autoreload 2
np.random.seed(1)
/opt/conda/lib/python3.5/site-packages/matplotlib/font_manager.py:273: UserWarning: Matplotlib is building the font cache using fc-list. This may take a moment. warnings.warn('Matplotlib is building the font cache using fc-list. This may take a moment.')/opt/conda/lib/python3.5/site-packages/matplotlib/font_manager.py:273: UserWarning: Matplotlib is building the font cache using fc-list. This may take a moment. warnings.warn('Matplotlib is building the font cache using fc-list. This may take a moment.')
2 - Outline of the Assignment
To build your neural network, you will be implementing several “helper functions”. These helper functions will be used in the next assignment to build a two-layer neural network and an L-layer neural network. Each small helper function you will implement will have detailed instructions that will walk you through the necessary steps. Here is an outline of this assignment, you will:
Initialize the parameters for a two-layer network and for an $L$-layer neural network.
Implement the forward propagation module (shown in purple in the figure below).
Complete the LINEAR part of a layer’s forward propagation step (resulting in $Z^{[l]}$).
We give you the ACTIVATION function (relu/sigmoid).
Combine the previous two steps into a new [LINEAR->ACTIVATION] forward function.
Stack the [LINEAR->RELU] forward function L-1 time (for layers 1 through L-1) and add a [LINEAR->SIGMOID] at the end (for the final layer $L$). This gives you a new L_model_forward function.
Compute the loss.
Implement the backward propagation module (denoted in red in the figure below).
Complete the LINEAR part of a layer’s backward propagation step.
We give you the gradient of the ACTIVATE function (relu_backward/sigmoid_backward)
Combine the previous two steps into a new [LINEAR->ACTIVATION] backward function.
Stack [LINEAR->RELU] backward L-1 times and add [LINEAR->SIGMOID] backward in a new L_model_backward function
Finally update the parameters.
Figure 1
Note that for every forward function, there is a corresponding backward function. That is why at every step of your forward module you will be storing some values in a cache. The cached values are useful for computing gradients. In the backpropagation module you will then use the cache to calculate the gradients. This assignment will show you exactly how to carry out each of these steps.
#### 3 - Initialization
You will write two helper functions that will initialize the parameters for your model. The first function will be used to initialize parameters for a two layer model. The second one will generalize this initialization process to $L$ layers.
##### 3.1 - 2-layer Neural Network
Exercise: Create and initialize the parameters of the 2-layer neural network.
Instructions: - The model’s structure is: LINEAR -> RELU -> LINEAR -> SIGMOID. - Use random initialization for the weight matrices. Use np.random.randn(shape)*0.01 with the correct shape. - Use zero initialization for the biases. Use np.zeros(shape).
The initialization for a deeper L-layer neural network is more complicated because there are many more weight matrices and bias vectors. When completing the initialize_parameters_deep, you should make sure that your dimensions match between each layer. Recall that $n^{[l]}$ is the number of units in layer $l$. Thus for example if the size of our input $X$ is $(12288, 209)$ (with $m=209$ examples) then:
Shape of W
Shape of b
Activation
Shape of Activation
Layer 1
$(n^{[1]},12288)$
$(n^{[1]},1)$
$Z^{[1]} = W^{[1]} X + b^{[1]} $
$(n^{[1]},209)$
Layer 2
$(n^{[2]}, n^{[1]})$
$(n^{[2]},1)$
$Z^{[2]} = W^{[2]} A^{[1]} + b^{[2]}$
$(n^{[2]}, 209)$
$\vdots$
$\vdots$
$\vdots$
$\vdots$
$\vdots$
Layer L-1
$(n^{[L-1]}, n^{[L-2]})$
$(n^{[L-1]}, 1)$
$Z^{[L-1]} = W^{[L-1]} A^{[L-2]} + b^{[L-1]}$
$(n^{[L-1]}, 209)$
Layer L
$(n^{[L]}, n^{[L-1]})$
$(n^{[L]}, 1)$
$Z^{[L]} = W^{[L]} A^{[L-1]} + b^{[L]}$
$(n^{[L]}, 209)$
Remember that when we compute $W X + b$ in python, it carries out broadcasting. For example, if:
$$ W = \begin{bmatrix} j & k & l\\ m & n & o \\ p & q & r \end{bmatrix}\;\;\; X = \begin{bmatrix} a & b & c\\ d & e & f \\ g & h & i \end{bmatrix} \;\;\; b =\begin{bmatrix} s \\ t \\ u \end{bmatrix}\tag{2}$$
Then $WX + b$ will be:
$$ WX + b = \begin{bmatrix} (ja + kd + lg) + s & (jb + ke + lh) + s & (jc + kf + li)+ s\\ (ma + nd + og) + t & (mb + ne + oh) + t & (mc + nf + oi) + t\\ (pa + qd + rg) + u & (pb + qe + rh) + u & (pc + qf + ri)+ u \end{bmatrix}\tag{3} $$
Exercise: Implement initialization for an L-layer Neural Network.
Instructions: - The model’s structure is [LINEAR -> RELU] $ \times$ (L-1) -> LINEAR -> SIGMOID. I.e., it has $L-1$ layers using a ReLU activation function followed by an output layer with a sigmoid activation function. - Use random initialization for the weight matrices. Use np.random.randn(shape) * 0.01. - Use zeros initialization for the biases. Use np.zeros(shape). - We will store $n^{[l]}$, the number of units in different layers, in a variable layer_dims. For example, the layer_dims for the “Planar Data classification model” from last week would have been [2,4,1]: There were two inputs, one hidden layer with 4 hidden units, and an output layer with 1 output unit. Thus means W1‘s shape was (4,2), b1 was (4,1), W2 was (1,4) and b2 was (1,1). Now you will generalize this to $L$ layers! - Here is the implementation for $L=1$ (one layer neural network). It should inspire you to implement the general case (L-layer neural network).
1 2 3
if L == 1: parameters["W" + str(L)] = np.random.randn(layer_dims[1], layer_dims[0]) * 0.01 parameters["b" + str(L)] = np.zeros((layer_dims[1], 1))
##### 4.1 - Linear Forward Now that you have initialized your parameters, you will do the forward propagation module. You will start by implementing some basic functions that you will use later when implementing the model. You will complete three functions in this order:
- LINEAR - LINEAR -> ACTIVATION where ACTIVATION will be either ReLU or Sigmoid. - [LINEAR -> RELU] $\times$ (L-1) -> LINEAR -> SIGMOID (whole model)
The linear forward module (vectorized over all the examples) computes the following equations:
$$Z^{[l]} = W^{[l]}A^{[l-1]} +b^{[l]}\tag{4}$$
where $A^{[0]} = X$.
Exercise: Build the linear part of forward propagation.
Reminder: The mathematical representation of this unit is $Z^{[l]} = W^{[l]}A^{[l-1]} +b^{[l]}$. You may also find np.dot() useful. If your dimensions don’t match, printing W.shape may help.
deflinear_forward(A, W, b): """ Implement the linear part of a layer's forward propagation. Arguments: A -- activations from previous layer (or input data): (size of previous layer, number of examples) W -- weights matrix: numpy array of shape (size of current layer, size of previous layer) b -- bias vector, numpy array of shape (size of the current layer, 1) Returns: Z -- the input of the activation function, also called pre-activation parameter cache -- a python dictionary containing "A", "W" and "b" ; stored for computing the backward pass efficiently """ ### START CODE HERE ### (≈ 1 line of code) Z = np.dot(W, A) + b ### END CODE HERE ### assert(Z.shape == (W.shape[0], A.shape[1])) cache = (A, W, b) return Z, cache
In this notebook, you will use two activation functions:
- Sigmoid: $\sigma(Z) = \sigma(W A + b) = \frac{1}{ 1 + e^{-(W A + b)}}$. We have provided you with the sigmoid function. This function returns two items: the activation value “a“ and a “cache“ that contains “Z“ (it’s what we will feed in to the corresponding backward function). To use it you could just call:
1
A, activation_cache = sigmoid(Z)
- ReLU: The mathematical formula for ReLu is $A = RELU(Z) = max(0, Z)$. We have provided you with the relu function. This function returns two items: the activation value “A“ and a “cache“ that contains “Z“ (it’s what we will feed in to the corresponding backward function). To use it you could just call:
1
A, activation_cache = relu(Z)
For more convenience, you are going to group two functions (Linear and Activation) into one function (LINEAR->ACTIVATION). Hence, you will implement a function that does the LINEAR forward step followed by an ACTIVATION forward step.
Exercise: Implement the forward propagation of the LINEAR->ACTIVATION layer. Mathematical relation is: $A^{[l]} = g(Z^{[l]}) = g(W^{[l]}A^{[l-1]} +b^{[l]})$ where the activation “g” can be sigmoid() or relu(). Use linear_forward() and the correct activation function.
deflinear_activation_forward(A_prev, W, b, activation): """ Implement the forward propagation for the LINEAR->ACTIVATION layer Arguments: A_prev -- activations from previous layer (or input data): (size of previous layer, number of examples) W -- weights matrix: numpy array of shape (size of current layer, size of previous layer) b -- bias vector, numpy array of shape (size of the current layer, 1) activation -- the activation to be used in this layer, stored as a text string: "sigmoid" or "relu" Returns: A -- the output of the activation function, also called the post-activation value cache -- a python dictionary containing "linear_cache" and "activation_cache"; stored for computing the backward pass efficiently """ if activation == "sigmoid": # Inputs: "A_prev, W, b". Outputs: "A, activation_cache". ### START CODE HERE ### (≈ 2 lines of code) Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = sigmoid(Z) ### END CODE HERE ### elif activation == "relu": # Inputs: "A_prev, W, b". Outputs: "A, activation_cache". ### START CODE HERE ### (≈ 2 lines of code) Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = relu(Z) ### END CODE HERE ### assert (A.shape == (W.shape[0], A_prev.shape[1])) cache = (linear_cache, activation_cache)
return A, cache
1 2 3 4 5 6 7
A_prev, W, b = linear_activation_forward_test_case()
A, linear_activation_cache = linear_activation_forward(A_prev, W, b, activation = "sigmoid") print("With sigmoid: A = " + str(A))
A, linear_activation_cache = linear_activation_forward(A_prev, W, b, activation = "relu") print("With ReLU: A = " + str(A))
With sigmoid: A = [[ 0.96890023 0.11013289]] With ReLU: A = [[ 3.43896131 0. ]]
Expected output:
With sigmoid: A
[[ 0.96890023 0.11013289]]
With ReLU: A
[[ 3.43896131 0. ]]
Note: In deep learning, the “[LINEAR->ACTIVATION]” computation is counted as a single layer in the neural network, not two layers.
##### d) L-Layer Model
For even more convenience when implementing the $L$-layer Neural Net, you will need a function that replicates the previous one (linear_activation_forward with RELU) $L-1$ times, then follows that with one linear_activation_forward with SIGMOID.
Figure 2 : [LINEAR -> RELU] $\times$ (L-1) -> LINEAR -> SIGMOID model
Exercise: Implement the forward propagation of the above model.
Instruction: In the code below, the variable AL will denote $A^{[L]} = \sigma(Z^{[L]}) = \sigma(W^{[L]} A^{[L-1]} + b^{[L]})$. (This is sometimes also called Yhat, i.e., this is $\hat{Y}$.)
Tips: - Use the functions you had previously written - Use a for loop to replicate [LINEAR->RELU] (L-1) times - Don’t forget to keep track of the caches in the “caches” list. To add a new value c to a list, you can use list.append(c).
defL_model_forward(X, parameters): """ Implement forward propagation for the [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID computation Arguments: X -- data, numpy array of shape (input size, number of examples) parameters -- output of initialize_parameters_deep() Returns: AL -- last post-activation value caches -- list of caches containing: every cache of linear_activation_forward() (there are L-1 of them, indexed from 0 to L-1) """
caches = [] A = X L = len(parameters) // 2# number of layers in the neural network # Implement [LINEAR -> RELU]*(L-1). Add "cache" to the "caches" list. for l in range(1, L): A_prev = A ### START CODE HERE ### (≈ 2 lines of code) A, cache = linear_activation_forward(A_prev, parameters["W" + str(l)], parameters["b" + str(l)], "relu") caches.append(cache) ### END CODE HERE ### # Implement LINEAR -> SIGMOID. Add "cache" to the "caches" list. ### START CODE HERE ### (≈ 2 lines of code) AL, cache = linear_activation_forward(A, parameters["W" + str(L)], parameters["b" + str(L)], "sigmoid") caches.append(cache) ### END CODE HERE ### assert(AL.shape == (1,X.shape[1])) return AL, caches
AL = [[ 0.03921668 0.70498921 0.19734387 0.04728177]] Length of caches list = 3
AL
[[ 0.03921668 0.70498921 0.19734387 0.04728177]]
Length of caches list
3
Great! Now you have a full forward propagation that takes the input X and outputs a row vector $A^{[L]}$ containing your predictions. It also records all intermediate values in “caches”. Using $A^{[L]}$, you can compute the cost of your predictions.
#### 5 - Cost function
Now you will implement forward and backward propagation. You need to compute the cost, because you want to check if your model is actually learning.
Exercise: Compute the cross-entropy cost $J$, using the following formula: $$-\frac{1}{m} \sum\limits_{i = 1}^{m} (y^{(i)}\log\left(a^{[L] (i)}\right) + (1-y^{(i)})\log\left(1- a^{L}\right)) \tag{7}$$
defcompute_cost(AL, Y): """ Implement the cost function defined by equation (7). Arguments: AL -- probability vector corresponding to your label predictions, shape (1, number of examples) Y -- true "label" vector (for example: containing 0 if non-cat, 1 if cat), shape (1, number of examples) Returns: cost -- cross-entropy cost """ m = Y.shape[1]
# Compute loss from aL and y. ### START CODE HERE ### (≈ 1 lines of code) cost = np.sum(np.multiply(np.log(AL),Y) + np.multiply(np.log(1 - AL), 1 - Y)) / (-m) ### END CODE HERE ### cost = np.squeeze(cost) # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17). assert(cost.shape == ()) return cost
1 2 3
Y, AL = compute_cost_test_case()
print("cost = " + str(compute_cost(AL, Y)))
cost = 0.414931599615
Expected Output:
cost
0.41493159961539694
#### 6 - Backward propagation module
Just like with forward propagation, you will implement helper functions for backpropagation. Remember that back propagation is used to calculate the gradient of the loss function with respect to the parameters.
Reminder:
Figure 3 : Forward and Backward propagation for LINEAR->RELU->LINEAR->SIGMOID The purple blocks represent the forward propagation, and the red blocks represent the backward propagation.
Now, similar to forward propagation, you are going to build the backward propagation in three steps:
LINEAR backward
LINEAR -> ACTIVATION backward where ACTIVATION computes the derivative of either the ReLU or sigmoid activation
For layer $l$, the linear part is: $Z^{[l]} = W^{[l]} A^{[l-1]} + b^{[l]}$ (followed by an activation).
Suppose you have already calculated the derivative $dZ^{[l]} = \frac{\partial \mathcal{L} }{\partial Z^{[l]}}$. You want to get $(dW^{[l]}, db^{[l]} dA^{[l-1]})$.
Figure 4
The three outputs $(dW^{[l]}, db^{[l]}, dA^{[l]})$ are computed using the input $dZ^{[l]}$.Here are the formulas you need: $$ dW^{[l]} = \frac{\partial \mathcal{L} }{\partial W^{[l]}} = \frac{1}{m} dZ^{[l]} A^{[l-1] T} \tag{8}$$ $$ db^{[l]} = \frac{\partial \mathcal{L} }{\partial b^{[l]}} = \frac{1}{m} \sum_{i = 1}^{m} dZ^{l}\tag{9}$$ $$ dA^{[l-1]} = \frac{\partial \mathcal{L} }{\partial A^{[l-1]}} = W^{[l] T} dZ^{[l]} \tag{10}$$
Exercise: Use the 3 formulas above to implement linear_backward().
deflinear_backward(dZ, cache): """ Implement the linear portion of backward propagation for a single layer (layer l) Arguments: dZ -- Gradient of the cost with respect to the linear output (of current layer l) cache -- tuple of values (A_prev, W, b) coming from the forward propagation in the current layer Returns: dA_prev -- Gradient of the cost with respect to the activation (of the previous layer l-1), same shape as A_prev dW -- Gradient of the cost with respect to W (current layer l), same shape as W db -- Gradient of the cost with respect to b (current layer l), same shape as b """ A_prev, W, b = cache m = A_prev.shape[1]
### START CODE HERE ### (≈ 3 lines of code) dW = np.dot(dZ, A_prev.T) / m db = np.sum(dZ, axis=1, keepdims=True) / m dA_prev = np.dot(W.T, dZ) ### END CODE HERE ### assert (dA_prev.shape == A_prev.shape) assert (dW.shape == W.shape) assert (db.shape == b.shape) return dA_prev, dW, db
1 2 3 4 5 6 7
# Set up some test inputs dZ, linear_cache = linear_backward_test_case()
Next, you will create a function that merges the two helper functions: linear_backward and the backward step for the activation linear_activation_backward.
To help you implement linear_activation_backward, we provided two backward functions:
sigmoid_backward: Implements the backward propagation for SIGMOID unit. You can call it as follows:
1
dZ = sigmoid_backward(dA, activation_cache)
relu_backward: Implements the backward propagation for RELU unit. You can call it as follows:
1
dZ = relu_backward(dA, activation_cache)
If $g(.)$ is the activation function, sigmoid_backward and relu_backward compute $$dZ^{[l]} = dA^{[l]} * g’(Z^{[l]}) \tag{11}$$.
Exercise: Implement the backpropagation for the LINEAR->ACTIVATION layer.
deflinear_activation_backward(dA, cache, activation): """ Implement the backward propagation for the LINEAR->ACTIVATION layer. Arguments: dA -- post-activation gradient for current layer l cache -- tuple of values (linear_cache, activation_cache) we store for computing backward propagation efficiently activation -- the activation to be used in this layer, stored as a text string: "sigmoid" or "relu" Returns: dA_prev -- Gradient of the cost with respect to the activation (of the previous layer l-1), same shape as A_prev dW -- Gradient of the cost with respect to W (current layer l), same shape as W db -- Gradient of the cost with respect to b (current layer l), same shape as b """ linear_cache, activation_cache = cache if activation == "relu": ### START CODE HERE ### (≈ 2 lines of code) dZ = relu_backward(dA, activation_cache) dA_prev, dW, db = linear_backward(dZ, linear_cache) ### END CODE HERE ###
elif activation == "sigmoid": ### START CODE HERE ### (≈ 2 lines of code) dZ = sigmoid_backward(dA, activation_cache) dA_prev, dW, db = linear_backward(dZ, linear_cache) ### END CODE HERE ### return dA_prev, dW, db
Now you will implement the backward function for the whole network. Recall that when you implemented the L_model_forward function, at each iteration, you stored a cache which contains (X,W,b, and z). In the back propagation module, you will use those variables to compute the gradients. Therefore, in the L_model_backward function, you will iterate through all the hidden layers backward, starting from layer $L$. On each step, you will use the cached values for layer $l$ to backpropagate through layer $l$. Figure 5 below shows the backward pass.
Figure 5 : Backward pass
Initializing backpropagation: To backpropagate through this network, we know that the output is, $A^{[L]} = \sigma(Z^{[L]})$. Your code thus needs to compute dAL $= \frac{\partial \mathcal{L}}{\partial A^{[L]}}$. To do so, use this formula (derived using calculus which you don’t need in-depth knowledge of):
1
dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL)) # derivative of cost with respect to AL
You can then use this post-activation gradient dAL to keep going backward. As seen in Figure 5, you can now feed in dAL into the LINEAR->SIGMOID backward function you implemented (which will use the cached values stored by the L_model_forward function). After that, you will have to use a for loop to iterate through all the other layers using the LINEAR->RELU backward function. You should store each dA, dW, and db in the grads dictionary. To do so, use this formula :
$$grads[“dW” + str(l)] = dW^{[l]}\tag{15} $$
For example, for $l=3$ this would store $dW^{[l]}$ in grads["dW3"].
Exercise: Implement backpropagation for the [LINEAR->RELU] $\times$ (L-1) -> LINEAR -> SIGMOID model.
defL_model_backward(AL, Y, caches): """ Implement the backward propagation for the [LINEAR->RELU] * (L-1) -> LINEAR -> SIGMOID group Arguments: AL -- probability vector, output of the forward propagation (L_model_forward()) Y -- true "label" vector (containing 0 if non-cat, 1 if cat) caches -- list of caches containing: every cache of linear_activation_forward() with "relu" (it's caches[l], for l in range(L-1) i.e l = 0...L-2) the cache of linear_activation_forward() with "sigmoid" (it's caches[L-1]) Returns: grads -- A dictionary with the gradients grads["dA" + str(l)] = ... grads["dW" + str(l)] = ... grads["db" + str(l)] = ... """ grads = {} L = len(caches) # the number of layers m = AL.shape[1] Y = Y.reshape(AL.shape) # after this line, Y is the same shape as AL # Initializing the backpropagation ### START CODE HERE ### (1 line of code) dAL = -(np.divide(Y, AL) - np.divide((1-Y), (1-AL))) ### END CODE HERE ### # Lth layer (SIGMOID -> LINEAR) gradients. Inputs: "dAL, current_cache". Outputs: "grads["dAL-1"], grads["dWL"], grads["dbL"] ### START CODE HERE ### (approx. 2 lines) current_cache = caches[L - 1] grads["dA" + str(L-1)], grads["dW" + str(L)], grads["db" + str(L)] = linear_activation_backward(dAL, current_cache, "sigmoid") ### END CODE HERE ### # Loop from l=L-2 to l=0 for l in reversed(range(L-1)): # lth layer: (RELU -> LINEAR) gradients. # Inputs: "grads["dA" + str(l + 1)], current_cache". Outputs: "grads["dA" + str(l)] , grads["dW" + str(l + 1)] , grads["db" + str(l + 1)] ### START CODE HERE ### (approx. 5 lines) current_cache = caches[l] dA_prev_temp, dW_temp, db_temp = linear_activation_backward(grads["dA" + str(l + 1)], current_cache, "relu") grads["dA" + str(l)] = dA_prev_temp grads["dW" + str(l + 1)] = dW_temp grads["db" + str(l + 1)] = db_temp ### END CODE HERE ###
Congrats on implementing all the functions required for building a deep neural network!
We know it was a long assignment but going forward it will only get better. The next part of the assignment is easier.
In the next assignment you will put all these together to build two models:
A two-layer neural network
An L-layer neural network
You will in fact use these models to classify cat vs non-cat images!
Deep Neural Network for Image Classification: Application
When you finish this, you will have finished the last programming assignment of Week 4, and also the last programming assignment of this course!
You will use use the functions you’d implemented in the previous assignment to build a deep network, and apply it to cat vs non-cat classification. Hopefully, you will see an improvement in accuracy relative to your previous logistic regression implementation.
After this assignment you will be able to:
Build and apply a deep neural network to supervised learning.
Let’s get started!
1 - Packages
Let’s first import all the packages that you will need during this assignment.
numpy is the fundamental package for scientific computing with Python.
h5py is a common package to interact with a dataset that is stored on an H5 file.
PIL and scipy are used here to test your model with your own picture at the end.
dnn_app_utils provides the functions implemented in the “Building your Deep Neural Network: Step by Step” assignment to this notebook.
np.random.seed(1) is used to keep all the random function calls consistent. It will help us grade your work.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
import time import numpy as np import h5py import matplotlib.pyplot as plt import scipy from PIL import Image from scipy import ndimage from dnn_app_utils_v3 import *
%matplotlib inline plt.rcParams['figure.figsize'] = (5.0, 4.0) # set default size of plots plt.rcParams['image.interpolation'] = 'nearest' plt.rcParams['image.cmap'] = 'gray'
%load_ext autoreload %autoreload 2
np.random.seed(1)
/opt/conda/lib/python3.5/site-packages/matplotlib/font_manager.py:273: UserWarning: Matplotlib is building the font cache using fc-list. This may take a moment. warnings.warn('Matplotlib is building the font cache using fc-list. This may take a moment.')/opt/conda/lib/python3.5/site-packages/matplotlib/font_manager.py:273: UserWarning: Matplotlib is building the font cache using fc-list. This may take a moment. warnings.warn('Matplotlib is building the font cache using fc-list. This may take a moment.')
2 - Dataset
You will use the same “Cat vs non-Cat” dataset as in “Logistic Regression as a Neural Network” (Assignment 2). The model you had built had 70% test accuracy on classifying cats vs non-cats images. Hopefully, your new model will perform a better!
Problem Statement: You are given a dataset (“data.h5”) containing:
- a training set of m_train images labelled as cat (1) or non-cat (0)- a test set of m_test images labelled as cat and non-cat- each image is of shape (num_px, num_px, 3) where 3 is for the 3 channels (RGB).
Let’s get more familiar with the dataset. Load the data by running the cell below.
The following code will show you an image in the dataset. Feel free to change the index and re-run the cell multiple times to see other images.
1 2 3 4
# Example of a picture index = 10 plt.imshow(train_x_orig[index]) print ("y = " + str(train_y[0,index]) + ". It's a " + classes[train_y[0,index]].decode("utf-8") + " picture.")
Number of training examples: 209Number of testing examples: 50Each image is of size: (64, 64, 3)train_x_orig shape: (209, 64, 64, 3)train_y shape: (1, 209)test_x_orig shape: (50, 64, 64, 3)test_y shape: (1, 50)
As usual, you reshape and standardize the images before feeding them to the network. The code is given in the cell below.
Figure 1: Image to vector conversion.
1 2 3 4 5 6 7 8 9 10
# Reshape the training and test examples train_x_flatten = train_x_orig.reshape(train_x_orig.shape[0], -1).T # The "-1" makes reshape flatten the remaining dimensions test_x_flatten = test_x_orig.reshape(test_x_orig.shape[0], -1).T
# Standardize data to have feature values between 0 and 1. train_x = train_x_flatten/255. test_x = test_x_flatten/255.
$12,288$ equals $64 \times 64 \times 3$ which is the size of one reshaped image vector.
3 - Architecture of your model
Now that you are familiar with the dataset, it is time to build a deep neural network to distinguish cat images from non-cat images.
You will build two different models:
A 2-layer neural network
An L-layer deep neural network
You will then compare the performance of these models, and also try out different values for $L$.
Let’s look at the two architectures.
3.1 - 2-layer neural network
Figure 2: 2-layer neural network. The model can be summarized as: INPUT -> LINEAR -> RELU -> LINEAR -> SIGMOID -> OUTPUT.
Detailed Architecture of figure 2:
The input is a (64,64,3) image which is flattened to a vector of size $(12288,1)$.
The corresponding vector: $[x_0,x_1,…,x_{12287}]^T$ is then multiplied by the weight matrix $W^{[1]}$ of size $(n^{[1]}, 12288)$.
You then add a bias term and take its relu to get the following vector: $[a_0^{[1]}, a_1^{[1]},…, a_{n^{[1]}-1}^{[1]}]^T$.
You then repeat the same process.
You multiply the resulting vector by $W^{[2]}$ and add your intercept (bias).
Finally, you take the sigmoid of the result. If it is greater than 0.5, you classify it to be a cat.
3.2 - L-layer deep neural network
It is hard to represent an L-layer deep neural network with the above representation. However, here is a simplified network representation:
Figure 3: L-layer neural network. The model can be summarized as: [LINEAR -> RELU] $\times$ (L-1) -> LINEAR -> SIGMOID
Detailed Architecture of figure 3:
The input is a (64,64,3) image which is flattened to a vector of size (12288,1).
The corresponding vector: $[x_0,x_1,…,x_{12287}]^T$ is then multiplied by the weight matrix $W^{[1]}$ and then you add the intercept $b^{[1]}$. The result is called the linear unit.
Next, you take the relu of the linear unit. This process could be repeated several times for each $(W^{[l]}, b^{[l]})$ depending on the model architecture.
Finally, you take the sigmoid of the final linear unit. If it is greater than 0.5, you classify it to be a cat.
3.3 - General methodology
As usual you will follow the Deep Learning methodology to build the model:
1. Initialize parameters / Define hyperparameters2. Loop for num_iterations: a. Forward propagation b. Compute cost function c. Backward propagation d. Update parameters (using parameters, and grads from backprop) 4. Use trained parameters to predict labels
Let’s now implement those two models!
4 - Two-layer neural network
Question: Use the helper functions you have implemented in the previous assignment to build a 2-layer neural network with the following structure: LINEAR -> RELU -> LINEAR -> SIGMOID. The functions you may need and their inputs are:
deftwo_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False): """ Implements a two-layer neural network: LINEAR->RELU->LINEAR->SIGMOID. Arguments: X -- input data, of shape (n_x, number of examples) Y -- true "label" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples) layers_dims -- dimensions of the layers (n_x, n_h, n_y) num_iterations -- number of iterations of the optimization loop learning_rate -- learning rate of the gradient descent update rule print_cost -- If set to True, this will print the cost every 100 iterations Returns: parameters -- a dictionary containing W1, W2, b1, and b2 """ np.random.seed(1) grads = {} costs = [] # to keep track of the cost m = X.shape[1] # number of examples (n_x, n_h, n_y) = layers_dims # Initialize parameters dictionary, by calling one of the functions you'd previously implemented ### START CODE HERE ### (≈ 1 line of code) parameters = initialize_parameters(n_x, n_h, n_y) ### END CODE HERE ### # Get W1, b1, W2 and b2 from the dictionary parameters. W1 = parameters["W1"] b1 = parameters["b1"] W2 = parameters["W2"] b2 = parameters["b2"] # Loop (gradient descent)
for i in range(0, num_iterations):
# Forward propagation: LINEAR -> RELU -> LINEAR -> SIGMOID. Inputs: "X, W1, b1, W2, b2". Output: "A1, cache1, A2, cache2". ### START CODE HERE ### (≈ 2 lines of code) A1, cache1 = linear_activation_forward(X, W1, b1, "relu") A2, cache2 = linear_activation_forward(A1, W2, b2, "sigmoid") ### END CODE HERE ### # Compute cost ### START CODE HERE ### (≈ 1 line of code) cost = compute_cost(A2, Y) ### END CODE HERE ### # Initializing backward propagation dA2 = - (np.divide(Y, A2) - np.divide(1 - Y, 1 - A2)) # Backward propagation. Inputs: "dA2, cache2, cache1". Outputs: "dA1, dW2, db2; also dA0 (not used), dW1, db1". ### START CODE HERE ### (≈ 2 lines of code) dA1, dW2, db2 = linear_activation_backward(dA2, cache2, "sigmoid") dA0, dW1, db1 = linear_activation_backward(dA1, cache1, "relu") ### END CODE HERE ### # Set grads['dWl'] to dW1, grads['db1'] to db1, grads['dW2'] to dW2, grads['db2'] to db2 grads['dW1'] = dW1 grads['db1'] = db1 grads['dW2'] = dW2 grads['db2'] = db2 # Update parameters. ### START CODE HERE ### (approx. 1 line of code) parameters = update_parameters(parameters, grads, learning_rate) ### END CODE HERE ###
# Retrieve W1, b1, W2, b2 from parameters W1 = parameters["W1"] b1 = parameters["b1"] W2 = parameters["W2"] b2 = parameters["b2"] # Print the cost every 100 training example if print_cost and i % 100 == 0: print("Cost after iteration {}: {}".format(i, np.squeeze(cost))) if print_cost and i % 100 == 0: costs.append(cost) # plot the cost
Run the cell below to train your parameters. See if your model runs. The cost should be decreasing. It may take up to 5 minutes to run 2500 iterations. Check if the “Cost after iteration 0” matches the expected output below, if not click on the square (⬛) on the upper bar of the notebook to stop the cell and try to find your error.
Cost after iteration 0: 0.693049735659989Cost after iteration 100: 0.6464320953428849Cost after iteration 200: 0.6325140647912678Cost after iteration 300: 0.6015024920354665Cost after iteration 400: 0.5601966311605748Cost after iteration 500: 0.515830477276473Cost after iteration 600: 0.4754901313943325Cost after iteration 700: 0.43391631512257495Cost after iteration 800: 0.4007977536203886Cost after iteration 900: 0.35807050113237987Cost after iteration 1000: 0.3394281538366413Cost after iteration 1100: 0.30527536361962654Cost after iteration 1200: 0.2749137728213015Cost after iteration 1300: 0.24681768210614827Cost after iteration 1400: 0.1985073503746611Cost after iteration 1500: 0.17448318112556593Cost after iteration 1600: 0.1708076297809661Cost after iteration 1700: 0.11306524562164737Cost after iteration 1800: 0.09629426845937163Cost after iteration 1900: 0.08342617959726878Cost after iteration 2000: 0.0743907870431909Cost after iteration 2100: 0.06630748132267938Cost after iteration 2200: 0.05919329501038176Cost after iteration 2300: 0.05336140348560564Cost after iteration 2400: 0.048554785628770226
Expected Output:
Cost after iteration 0
0.6930497356599888
Cost after iteration 100
0.6464320953428849
…
…
Cost after iteration 2400
0.048554785628770206
Good thing you built a vectorized implementation! Otherwise it might have taken 10 times longer to train this.
Now, you can use the trained parameters to classify images from the dataset. To see your predictions on the training and test sets, run the cell below.
Note: You may notice that running the model on fewer iterations (say 1500) gives better accuracy on the test set. This is called “early stopping” and we will talk about it in the next course. Early stopping is a way to prevent overfitting.
Congratulations! It seems that your 2-layer neural network has better performance (72%) than the logistic regression implementation (70%, assignment week 2). Let’s see if you can do even better with an $L$-layer model.
5 - L-layer Neural Network
Question: Use the helper functions you have implemented previously to build an $L$-layer neural network with the following structure: [LINEAR -> RELU]$\times$(L-1) -> LINEAR -> SIGMOID. The functions you may need and their inputs are:
defL_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):#lr was 0.009 """ Implements a L-layer neural network: [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID. Arguments: X -- data, numpy array of shape (number of examples, num_px * num_px * 3) Y -- true "label" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples) layers_dims -- list containing the input size and each layer size, of length (number of layers + 1). learning_rate -- learning rate of the gradient descent update rule num_iterations -- number of iterations of the optimization loop print_cost -- if True, it prints the cost every 100 steps Returns: parameters -- parameters learnt by the model. They can then be used to predict. """
np.random.seed(1) costs = [] # keep track of cost # Parameters initialization. (≈ 1 line of code) ### START CODE HERE ### parameters = initialize_parameters_deep(layers_dims) ### END CODE HERE ### # Loop (gradient descent) for i in range(0, num_iterations):
# Forward propagation: [LINEAR -> RELU]*(L-1) -> LINEAR -> SIGMOID. ### START CODE HERE ### (≈ 1 line of code) AL, caches = L_model_forward(X, parameters) ### END CODE HERE ### # Compute cost. ### START CODE HERE ### (≈ 1 line of code) cost = compute_cost(AL, Y) ### END CODE HERE ### # Backward propagation. ### START CODE HERE ### (≈ 1 line of code) grads = L_model_backward(AL, Y, caches) ### END CODE HERE ### # Update parameters. ### START CODE HERE ### (≈ 1 line of code) parameters = update_parameters(parameters, grads, learning_rate) ### END CODE HERE ### # Print the cost every 100 training example if print_cost and i % 100 == 0: print ("Cost after iteration %i: %f" %(i, cost)) if print_cost and i % 100 == 0: costs.append(cost) # plot the cost plt.plot(np.squeeze(costs)) plt.ylabel('cost') plt.xlabel('iterations (per tens)') plt.title("Learning rate =" + str(learning_rate)) plt.show() return parameters
You will now train the model as a 4-layer neural network.
Run the cell below to train your model. The cost should decrease on every iteration. It may take up to 5 minutes to run 2500 iterations. Check if the “Cost after iteration 0” matches the expected output below, if not click on the square (⬛) on the upper bar of the notebook to stop the cell and try to find your error.
Cost after iteration 0: 0.771749Cost after iteration 100: 0.672053Cost after iteration 200: 0.648263Cost after iteration 300: 0.611507Cost after iteration 400: 0.567047Cost after iteration 500: 0.540138Cost after iteration 600: 0.527930Cost after iteration 700: 0.465477Cost after iteration 800: 0.369126Cost after iteration 900: 0.391747Cost after iteration 1000: 0.315187Cost after iteration 1100: 0.272700Cost after iteration 1200: 0.237419Cost after iteration 1300: 0.199601Cost after iteration 1400: 0.189263Cost after iteration 1500: 0.161189Cost after iteration 1600: 0.148214Cost after iteration 1700: 0.137775Cost after iteration 1800: 0.129740Cost after iteration 1900: 0.121225Cost after iteration 2000: 0.113821Cost after iteration 2100: 0.107839Cost after iteration 2200: 0.102855Cost after iteration 2300: 0.100897Cost after iteration 2400: 0.092878
Congrats! It seems that your 4-layer neural network has better performance (80%) than your 2-layer neural network (72%) on the same test set.
This is good performance for this task. Nice job!
Though in the next course on “Improving deep neural networks” you will learn how to obtain even higher accuracy by systematically searching for better hyperparameters (learning_rate, layers_dims, num_iterations, and others you’ll also learn in the next course).
6) Results Analysis
First, let’s take a look at some images the L-layer model labeled incorrectly. This will show a few mislabeled images.
A few types of images the model tends to do poorly on include:
Cat body in an unusual position
Cat appears against a background of a similar color
Unusual cat color and species
Camera Angle
Brightness of the picture
Scale variation (cat is very large or small in image)
7) Test with your own image (optional/ungraded exercise)
Congratulations on finishing this assignment. You can use your own image and see the output of your model. To do that:
1. Click on "File" in the upper bar of this notebook, then click "Open" to go on your Coursera Hub.2. Add your image to this Jupyter Notebook's directory, in the "images" folder3. Change your image's name in the following code4. Run the code and check if the algorithm is right (1 = cat, 0 = non-cat)!
1 2 3 4 5 6 7 8 9 10 11 12 13
## START CODE HERE ## my_image = "my_image.jpg"# change this to the name of your image file my_label_y = [1] # the true class of your image (1 -> cat, 0 -> non-cat) ## END CODE HERE ##
Welcome to your week 3 programming assignment. It’s time to build your first neural network, which will have a hidden layer. You will see a big difference between this model and the one you implemented using logistic regression.
You will learn how to:
Implement a 2-class classification neural network with a single hidden layer
Use units with a non-linear activation function, such as tanh
Compute the cross entropy loss
Implement forward and backward propagation
1 - Packages
Let’s first import all the packages that you will need during this assignment.
numpy is the fundamental package for scientific computing with Python.
sklearn provides simple and efficient tools for data mining and data analysis.
matplotlib is a library for plotting graphs in Python.
testCases provides some test examples to assess the correctness of your functions
planar_utils provide various useful functions used in this assignment
1 2 3 4 5 6 7 8 9 10 11 12
# Package imports import numpy as np import matplotlib.pyplot as plt from testCases_v2 import * import sklearn import sklearn.datasets import sklearn.linear_model from planar_utils import plot_decision_boundary, sigmoid, load_planar_dataset, load_extra_datasets
%matplotlib inline
np.random.seed(1) # set a seed so that the results are consistent
2 - Dataset
First, let’s get the dataset you will work on. The following code will load a “flower” 2-class dataset into variables X and Y.
1
X, Y = load_planar_dataset()
Visualize the dataset using matplotlib. The data looks like a “flower” with some red (label y=0) and some blue (y=1) points. Your goal is to build a model to fit this data.
- a numpy-array (matrix) X that contains your features (x1, x2)- a numpy-array (vector) Y that contains your labels (red:0, blue:1).
Lets first get a better sense of what our data is like.
Exercise: How many training examples do you have? In addition, what is the shape of the variables X and Y?
Hint: How do you get the shape of a numpy array? (help)
1 2 3 4 5 6 7 8 9
### START CODE HERE ### (≈ 3 lines of code) shape_X = X.shape shape_Y = Y.shape m = X.shape[1] # training set size ### END CODE HERE ###
print ('The shape of X is: ' + str(shape_X)) print ('The shape of Y is: ' + str(shape_Y)) print ('I have m = %d training examples!' % (m))
The shape of X is: (2, 400)The shape of Y is: (1, 400)I have m = 400 training examples!
Expected Output:
shape of X
(2, 400)
shape of Y
(1, 400)
m
400
3 - Simple Logistic Regression
Before building a full neural network, lets first see how logistic regression performs on this problem. You can use sklearn’s built-in functions to do that. Run the code below to train a logistic regression classifier on the dataset.
/opt/conda/lib/python3.5/site-packages/sklearn/utils/validation.py:515: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel(). y = column_or_1d(y, warn=True)
You can now plot the decision boundary of these models. Run the code below.
1 2 3 4 5 6 7 8
# Plot the decision boundary for logistic regression plot_decision_boundary(lambda x: clf.predict(x), X, Y) plt.title("Logistic Regression")
Accuracy of logistic regression: 47 % (percentage of correctly labelled datapoints)
Expected Output:
Accuracy
47%
Interpretation: The dataset is not linearly separable, so logistic regression doesn’t perform well. Hopefully a neural network will do better. Let’s try this now!
4 - Neural Network model
Logistic regression did not work well on the “flower dataset”. You are going to train a Neural Network with a single hidden layer.
Given the predictions on all the examples, you can also compute the cost $J$ as follows: $$J = - \frac{1}{m} \sum\limits_{i = 0}^{m} \large\left(\small y^{(i)}\log\left(a^{[2] (i)}\right) + (1-y^{(i)})\log\left(1- a^{[2] (i)}\right) \large \right) \small \tag{6}$$
Reminder: The general methodology to build a Neural Network is to:
1. Define the neural network structure ( # of input units, # of hidden units, etc). 2. Initialize the model's parameters3. Loop: - Implement forward propagation - Compute loss - Implement backward propagation to get the gradients - Update parameters (gradient descent)
You often build helper functions to compute steps 1-3 and then merge them into one function we call nn_model(). Once you’ve built nn_model() and learnt the right parameters, you can make predictions on new data.
4.1 - Defining the neural network structure
Exercise: Define three variables:
- n_x: the size of the input layer- n_h: the size of the hidden layer (set this to 4) - n_y: the size of the output layer
Hint: Use shapes of X and Y to find n_x and n_y. Also, hard code the hidden layer size to be 4.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
# GRADED FUNCTION: layer_sizes
deflayer_sizes(X, Y): """ Arguments: X -- input dataset of shape (input size, number of examples) Y -- labels of shape (output size, number of examples) Returns: n_x -- the size of the input layer n_h -- the size of the hidden layer n_y -- the size of the output layer """ ### START CODE HERE ### (≈ 3 lines of code) n_x = X.shape[0] # size of input layer n_h = 4 n_y = Y.shape[0] # size of output layer ### END CODE HERE ### return (n_x, n_h, n_y)
1 2 3 4 5
X_assess, Y_assess = layer_sizes_test_case() (n_x, n_h, n_y) = layer_sizes(X_assess, Y_assess) print("The size of the input layer is: n_x = " + str(n_x)) print("The size of the hidden layer is: n_h = " + str(n_h)) print("The size of the output layer is: n_y = " + str(n_y))
The size of the input layer is: n_x = 5The size of the hidden layer is: n_h = 4The size of the output layer is: n_y = 2
Expected Output (these are not the sizes you will use for your network, they are just used to assess the function you’ve just coded).
n_x
5
n_h
4
n_y
2
4.2 - Initialize the model’s parameters
Exercise: Implement the function initialize_parameters().
Instructions:
Make sure your parameters’ sizes are right. Refer to the neural network figure above if needed.
You will initialize the weights matrices with random values.
Use: np.random.randn(a,b) * 0.01 to randomly initialize a matrix of shape (a,b).
You will initialize the bias vectors as zeros.
Use: np.zeros((a,b)) to initialize a matrix of shape (a,b) with zeros.
Look above at the mathematical representation of your classifier.
You can use the function sigmoid(). It is built-in (imported) in the notebook.
You can use the function np.tanh(). It is part of the numpy library.
The steps you have to implement are:
Retrieve each parameter from the dictionary “parameters” (which is the output of initialize_parameters()) by using parameters[".."].
Implement Forward Propagation. Compute $Z^{[1]}, A^{[1]}, Z^{[2]}$ and $A^{[2]}$ (the vector of all your predictions on all the examples in the training set).
Values needed in the backpropagation are stored in “cache“. The cache will be given as an input to the backpropagation function.
# Note: we use the mean here just to make sure that your output matches ours. print(np.mean(cache['Z1']) ,np.mean(cache['A1']),np.mean(cache['Z2']),np.mean(cache['A2']))
Now that you have computed $A^{[2]}$ (in the Python variable “A2“), which contains $a^{2}$ for every example, you can compute the cost function as follows:
Exercise: Implement compute_cost() to compute the value of the cost $J$.
Instructions:
There are many ways to implement the cross-entropy loss. To help you, we give you how we would have implemented $- \sum\limits_{i=0}^{m} y^{(i)}\log(a^{2})$:
1 2
logprobs = np.multiply(np.log(A2),Y) cost = - np.sum(logprobs) # no need to use a for loop!
(you can use either np.multiply() and then np.sum() or directly np.dot()).
defcompute_cost(A2, Y, parameters): """ Computes the cross-entropy cost given in equation (13) Arguments: A2 -- The sigmoid output of the second activation, of shape (1, number of examples) Y -- "true" labels vector of shape (1, number of examples) parameters -- python dictionary containing your parameters W1, b1, W2 and b2 Returns: cost -- cross-entropy cost given equation (13) """ m = Y.shape[1] # number of example
# Compute the cross-entropy cost ### START CODE HERE ### (≈ 2 lines of code) logprobs = np.multiply(np.log(A2), Y) # 此方法不行，因为生成的类型是numpy.ndarray cost = -(float(np.dot(np.log(A2), Y.T)) + np.dot(np.log(1.0 - A2), (1 - Y.T))) / m # 此方法做法是做内积，所以生成的是np.float64 cost = - np.sum(np.multiply(np.log(A2), Y) + np.multiply(np.log(1. - A2), 1. - Y)) / m ### END CODE HERE ### cost = np.squeeze(cost) # makes sure cost is the dimension we expect. # E.g., turns [[17]] into 17 assert(isinstance(cost, float)) return cost
Using the cache computed during forward propagation, you can now implement backward propagation.
Question: Implement the function backward_propagation().
Instructions: Backpropagation is usually the hardest (most mathematical) part in deep learning. To help you, here again is the slide from the lecture on backpropagation. You’ll want to use the six equations on the right of this slide, since you are building a vectorized implementation.
Tips:
To compute dZ1 you’ll need to compute $g^{[1]’}(Z^{[1]})$. Since $g^{[1]}(.)$ is the tanh activation function, if $a = g^{[1]}(z)$ then $g^{[1]’}(z) = 1-a^2$. So you can compute $g^{[1]’}(Z^{[1]})$ using (1 - np.power(A1, 2)).
defbackward_propagation(parameters, cache, X, Y): """ Implement the backward propagation using the instructions above. Arguments: parameters -- python dictionary containing our parameters cache -- a dictionary containing "Z1", "A1", "Z2" and "A2". X -- input data of shape (2, number of examples) Y -- "true" labels vector of shape (1, number of examples) Returns: grads -- python dictionary containing your gradients with respect to different parameters """ m = X.shape[1] # First, retrieve W1 and W2 from the dictionary "parameters". ### START CODE HERE ### (≈ 2 lines of code) W1 = parameters['W1'] W2 = parameters['W2'] ### END CODE HERE ### # Retrieve also A1 and A2 from dictionary "cache". ### START CODE HERE ### (≈ 2 lines of code) A1 = cache['A1'] A2 = cache['A2'] ### END CODE HERE ### # Backward propagation: calculate dW1, db1, dW2, db2. ### START CODE HERE ### (≈ 6 lines of code, corresponding to 6 equations on slide above) dZ2 = A2 - Y dW2 = np.dot(dZ2, A1.T) / m db2 = np.sum(dZ2, axis = 1, keepdims = True) / m dZ1 = np.dot(W2.T, dZ2) * (1 - np.power(A1, 2)) dW1 = np.dot(dZ1, X.T) / m db1 = np.sum(dZ1, axis = 1, keepdims = True) / m ### END CODE HERE ### grads = {"dW1": dW1, "db1": db1, "dW2": dW2, "db2": db2} return grads
Question: Implement the update rule. Use gradient descent. You have to use (dW1, db1, dW2, db2) in order to update (W1, b1, W2, b2).
General gradient descent rule: $ \theta = \theta - \alpha \frac{\partial J }{ \partial \theta }$ where $\alpha$ is the learning rate and $\theta$ represents a parameter.
Illustration: The gradient descent algorithm with a good learning rate (converging) and a bad learning rate (diverging). Images courtesy of Adam Harley.
defnn_model(X, Y, n_h, num_iterations = 10000, print_cost=False): """ Arguments: X -- dataset of shape (2, number of examples) Y -- labels of shape (1, number of examples) n_h -- size of the hidden layer num_iterations -- Number of iterations in gradient descent loop print_cost -- if True, print the cost every 1000 iterations Returns: parameters -- parameters learnt by the model. They can then be used to predict. """ np.random.seed(3) n_x = layer_sizes(X, Y)[0] n_y = layer_sizes(X, Y)[2] # Initialize parameters, then retrieve W1, b1, W2, b2. Inputs: "n_x, n_h, n_y". Outputs = "W1, b1, W2, b2, parameters". ### START CODE HERE ### (≈ 5 lines of code) parameters = initialize_parameters(n_x, n_h, n_y) W1 = parameters['W1'] b1 = parameters['b1'] W2 = parameters['W2'] b2 = parameters['b2'] ### END CODE HERE ### # Loop (gradient descent)
for i in range(0, num_iterations): ### START CODE HERE ### (≈ 4 lines of code) # Forward propagation. Inputs: "X, parameters". Outputs: "A2, cache". A2, cache = forward_propagation(X, parameters) # Cost function. Inputs: "A2, Y, parameters". Outputs: "cost". cost = compute_cost(A2, Y, parameters) # Backpropagation. Inputs: "parameters, cache, X, Y". Outputs: "grads". grads = backward_propagation(parameters, cache, X, Y) # Gradient descent parameter update. Inputs: "parameters, grads". Outputs: "parameters". parameters = update_parameters(parameters, grads) ### END CODE HERE ### # Print the cost every 1000 iterations if print_cost and i % 1000 == 0: print ("Cost after iteration %i: %f" %(i, cost))
def predict(parameters, X): """ Using the learned parameters, predicts a class for each example in X Arguments: parameters -- python dictionary containing your parameters X -- input data of size (n_x, m) Returns predictions -- vector of predictions of our model (red: 0 / blue: 1) """ # Computes probabilities using forward propagation, and classifies to 0/1 using 0.5 as the threshold. ### START CODE HERE ### (≈ 2 lines of code) A2, cache = forward_propagation(X, parameters) predictions = list(map(lambda x : 0 if x < 0.5 else 1, A2[0])) predictions = np.array([predictions]) ### END CODE HERE ### return predictions
1 2 3 4
parameters, X_assess = predict_test_case()
predictions = predict(parameters, X_assess) print("predictions mean = " + str(np.mean(predictions)))
predictions mean = 0.666666666667
Expected Output:
predictions mean
0.666666666667
It is time to run the model and see how it performs on a planar dataset. Run the following code to test your model with a single hidden layer of $n_h$ hidden units.
1 2 3 4 5 6
# Build a model with a n_h-dimensional hidden layer parameters = nn_model(X, Y, n_h = 4, num_iterations = 10000, print_cost=True)
# Plot the decision boundary plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y) plt.title("Decision Boundary for hidden layer size " + str(4))
Cost after iteration 0: 0.693048Cost after iteration 1000: 0.288083Cost after iteration 2000: 0.254385Cost after iteration 3000: 0.233864Cost after iteration 4000: 0.226792Cost after iteration 5000: 0.222644Cost after iteration 6000: 0.219731Cost after iteration 7000: 0.217504Cost after iteration 8000: 0.219471Cost after iteration 9000: 0.218612<matplotlib.text.Text at 0x7f0bbeb25898>
Accuracy is really high compared to Logistic Regression. The model has learnt the leaf patterns of the flower! Neural networks are able to learn even highly non-linear decision boundaries, unlike logistic regression.
Run the following code. It may take 1-2 minutes. You will observe different behaviors of the model for various hidden layer sizes.
1 2 3 4 5 6 7 8 9 10 11 12
# This may take about 2 minutes to run
plt.figure(figsize=(16, 32)) hidden_layer_sizes = [1, 2, 3, 4, 5, 20, 50] for i, n_h in enumerate(hidden_layer_sizes): plt.subplot(5, 2, i+1) plt.title('Hidden Layer of size %d' % n_h) parameters = nn_model(X, Y, n_h, num_iterations = 5000) plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y) predictions = predict(parameters, X) accuracy = float((np.dot(Y,predictions.T) + np.dot(1-Y,1-predictions.T))/float(Y.size)*100) print ("Accuracy for {} hidden units: {} %".format(n_h, accuracy))
Accuracy for 1 hidden units: 67.5 %Accuracy for 2 hidden units: 67.25 %Accuracy for 3 hidden units: 90.75 %Accuracy for 4 hidden units: 90.5 %Accuracy for 5 hidden units: 91.25 %Accuracy for 20 hidden units: 90.0 %Accuracy for 50 hidden units: 90.25 %
Interpretation:
The larger models (with more hidden units) are able to fit the training set better, until eventually the largest models overfit the data.
The best hidden layer size seems to be around n_h = 5. Indeed, a value around here seems to fits the data well without also incurring noticable overfitting.
You will also learn later about regularization, which lets you use very large models (such as n_h = 50) without much overfitting.
Optional questions:
Note: Remember to submit the assignment but clicking the blue “Submit Assignment” button at the upper-right.
Some optional/ungraded questions that you can explore if you wish:
What happens when you change the tanh activation for a sigmoid activation or a ReLU activation?
Play with the learning_rate. What happens?
What if we change the dataset? (See part 5 below!)
You’ve learnt to:
Build a complete neural network with a hidden layer
Make a good use of a non-linear unit
Implemented forward propagation and backpropagation, and trained a neural network
See the impact of varying the hidden layer size, including overfitting.
Nice work!
5) Performance on other datasets
If you want, you can rerun the whole notebook (minus the dataset part) for each of the following datasets.
# Code Highlight theme # Available value: # normal | night | night eighties | night blue | night bright # https://github.com/chriskempson/tomorrow-theme highlight_theme: night
# Social Links. # Usage: `Key: permalink || icon` # Key is the link label showing to end users. # Value before `||` delimeter is the target permalink. # Value after `||` delimeter is the name of FontAwesome icon. If icon (with or without delimeter) is not specified, globe icon will be loaded. social: #GitHub: https://github.com/yourname || github 邮件: mailto:wuzqbupt@gmail.com || envelope 知乎: https://www.zhihu.com/people/wu-ze-qun || globe 微博: https://weibo.com/u/1922768971 || weibo 领英: https://www.linkedin.com/in/zequn-wu-038a5b133/ || linkedin
# Show PV/UV of the website/page with busuanzi. # Get more information on http://ibruce.info/2015/04/04/busuanzi/ busuanzi_count: # count values only if the other configs are false enable: true # custom uv span for the whole site site_uv: true site_uv_header: <i class="fa fa-user"></i> site_uv_footer: # custom pv span for the whole site site_pv: true site_pv_header: <i class="fa fa-eye"></i> site_pv_footer: # custom pv span for one page only page_pv: true page_pv_header: <i class="fa fa-file-o"></i> page_pv_footer:
本地搜索
安装hexo-generator-searchdb，在站点的根目录下执行以下命令：
1
$ npm install hexo-generator-searchdb --save
配置_config.yml，增加以下内容：
1 2 3 4 5
search: path: search.xml field: post format: html limit: 10000
配置themes\next_config.yml，启用本地搜索功能
1 2 3 4 5
search: path: search.xml field: post format: html limit: 10000
Congratulations, Shadowsocks-go server install completed! Your Server IP :your_server_ip Your Server Port :your_server_port Your Password :your_password Your Encryption Method:your_encryption_method
Welcome to visit:https://teddysun.com/392.html Enjoy it!
