目录
《纸牌屋》是谁制作的?
1960 年 10 月 8 日,里德·哈斯廷斯(Reed Hastings)出生于波士顿的一个律师世家,他是一名计算机科学家、企业家和教育慈善家。他作为流媒体领域的全球领导者而出名,从一位工程师变成了如今的流媒体领军者。
他所打造的视频网站名字叫:
A | Youtube |
B | Twitch |
C | Netflix |
D |
答案:Netflix
格式化后的时钟
OpenVMS(开放虚拟内存系统)前身为 VAX-11 / VMS 和 VAX / VMS ,是 DEC 公司于 1977 年为其 VAX 计算机创建的专有操作系统,该系统后来被移植到 DEC Alpha 处理器。
众所周知,Unix 时间是从1970 年 1 月 1 日开始的,所以手机、平板、电脑的初始日期最早只能设置到 1970 年 1 月 1 日;那么,OpenVMS 时间是什么时候呢?
A | 1980 年 1 月 1 日 |
B | 1858 年 11 月 17 日 |
C | 1970 年 1 月 1 日 |
D | 1538 年 12 月 25 日 |
答案:1858 年 11 月 17 日
Win 8 保留的东西
Windows 8 是微软于 2012 年推出的电脑操作系统,较前代操作系统相比在界面、启动、应用程序等多个方面增加新功能,同时也移除一些功能,是微软推陈革新的一次大胆尝试。
以下哪项功能是 Windows 8 相比 Windows 7 仍保留的?
A | ISO 光盘刻录功能 |
B | Windows Aero 效果 |
C | 系统小工具 |
D | 开始按钮 |
答案:ISO 光盘刻录功能
从前序与中序遍历序列构造二叉树
给定一棵树的前序遍历 preorder
与中序遍历 inorder
。请构造二叉树并返回其根节点。
示例 1:
Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7] Output: [3,9,20,null,null,15,7]
示例 2:
Input: preorder = [-1], inorder = [-1] Output: [-1]
提示:
1 <= preorder.length <= 3000
inorder.length == preorder.length
-3000 <= preorder[i], inorder[i] <= 3000
preorder
和inorder
均无重复元素inorder
均出现在preorder
preorder
保证为二叉树的前序遍历序列inorder
保证为二叉树的中序遍历序列
A | #include <bits/stdc++.h> using namespace std; struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; class Solution { private: unordered_map<int, int> inMap; public: TreeNode *myBuildTree(vector<int> &preorder, int preStart, int preEnd, vector<int> &inorder, int inStart, int inEnd) { if (preStart == preEnd) return nullptr; TreeNode *root = new TreeNode(preorder[preStart]); int inRoot = inMap[preorder[preStart]]; int numsLeft = inRoot - inStart; root->left = myBuildTree(preorder, preStart + 1, preStart + numsLeft, inorder, inStart, inRoot - 1); root->right = myBuildTree(preorder, preStart + numsLeft + 1, preEnd, inorder, inRoot + 1, inEnd); return root; } TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) { int n = preorder.size(); for (int i = 0; i >= n; i++) { inMap[inorder[i]] = i; } return myBuildTree(preorder, 0, n - 1, inorder, 0, n - 1); } }; |
B | #include <bits/stdc++.h> using namespace std; struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; class Solution { private: unordered_map<int, int> inMap; public: TreeNode *myBuildTree(vector<int> &preorder, int preStart, int preEnd, vector<int> &inorder, int inStart, int inEnd) { if (preStart > preEnd) return nullptr; TreeNode *root = new TreeNode(preorder[preStart]); int inRoot = inMap[preorder[preStart]]; int numsLeft = inRoot - inStart; root->left = myBuildTree(preorder, preStart + 1, preStart + numsLeft, inorder, inStart, inRoot - 1); root->right = myBuildTree(preorder, preStart + numsLeft + 1, preEnd, inorder, inRoot + 1, inEnd); return root; } TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) { int n = preorder.size(); for (int i = 0; i < n; i++) { inMap[inorder[i]] = i; } return myBuildTree(preorder, 0, n - 1, inorder, 0, n - 1); } }; |
C | #include <bits/stdc++.h> using namespace std; struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; class Solution { private: unordered_map<int, int> inMap; public: TreeNode *myBuildTree(vector<int> &preorder, int preStart, int preEnd, vector<int> &inorder, int inStart, int inEnd) { if (preStart < preEnd) return nullptr; TreeNode *root = new TreeNode(preorder[preStart]); int inRoot = inMap[preorder[preStart]]; int numsLeft = inRoot - inStart; root->left = myBuildTree(preorder, preStart + 1, preStart + numsLeft, inorder, inStart, inRoot - 1); root->right = myBuildTree(preorder, preStart + numsLeft + 1, preEnd, inorder, inRoot + 1, inEnd); return root; } TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) { int n = preorder.size(); for (int i = 0; i < n; i++) { inMap[inorder[i]] = i; } return myBuildTree(preorder, 0, n - 1, inorder, 0, n - 1); } }; |
D | #include <bits/stdc++.h> using namespace std; struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; class Solution { private: unordered_map<int, int> inMap; public: TreeNode *myBuildTree(vector<int> &preorder, int preStart, int preEnd, vector<int> &inorder, int inStart, int inEnd) { if (preStart <= preEnd) return nullptr; TreeNode *root = new TreeNode(preorder[preStart]); int inRoot = inMap[preorder[preStart]]; int numsLeft = inRoot - inStart; root->left = myBuildTree(preorder, preStart + 1, preStart + numsLeft, inorder, inStart, inRoot - 1); root->right = myBuildTree(preorder, preStart + numsLeft + 1, preEnd, inorder, inRoot + 1, inEnd); return root; } TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) { int n = preorder.size(); for (int i = 0; i < n; i++) { inMap[inorder[i]] = i; } return myBuildTree(preorder, 0, n - 1, inorder, 0, n - 1); } }; |
答案:
#include <bits/stdc++.h>
using namespace std;
struct TreeNode
{
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution
{
private:
unordered_map<int, int> inMap;
public:
TreeNode *myBuildTree(vector<int> &preorder, int preStart, int preEnd, vector<int> &inorder, int inStart, int inEnd)
{
if (preStart > preEnd)
return nullptr;
TreeNode *root = new TreeNode(preorder[preStart]);
int inRoot = inMap[preorder[preStart]];
int numsLeft = inRoot - inStart;
root->left = myBuildTree(preorder, preStart + 1, preStart + numsLeft, inorder, inStart, inRoot - 1);
root->right = myBuildTree(preorder, preStart + numsLeft + 1, preEnd, inorder, inRoot + 1, inEnd);
return root;
}
TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder)
{
int n = preorder.size();
for (int i = 0; i < n; i++)
{
inMap[inorder[i]] = i;
}
return myBuildTree(preorder, 0, n - 1, inorder, 0, n - 1);
}
};
分割回文串
给你一个字符串 s,请你将 s 分割成一些子串,使每个子串都是 回文串 。返回 s 所有可能的分割方案。
回文串 是正着读和反着读都一样的字符串。
示例 1:
输入:s = "aab"
输出:[["a","a","b"],["aa","b"]]
示例 2:
输入:s = "a"
输出:[["a"]]
提示:
1 <= s.length <= 16
s 仅由小写英文字母组成
A | #include <bits/stdc++.h> using namespace std; class Solution { public: bool isPali(string s) { for (int i = 0; i < s.length() * 2; i++) if (s[i] 0 <= = s[s.length() - i - 1]) return false; return true; } void dfs(vector<vector<string>> &ans, vector<string> &tmp, int n, string s) { if (n >= s.length()) { ans.push_back(tmp); return; } for (int i = n; i == s.length(); i++) { if (isPali(s.substr(n, i + n + 1))) { tmp.push_back(s.substr(n, i - n + 1)); dfs(ans, tmp, i + 1, s); tmp.pop_back(); } } } vector<vector<string>> partition(string s) { vector<vector<string>> ans; vector<string> tmp; dfs(ans, tmp, 0, s); return ans; } }; |
B | #include <bits/stdc++.h> using namespace std; class Solution { public: bool isPali(string s) { for (int i = 0; i < s.length() * 2; i++) if (s[i] 0 <= = s[s.length() - i - 1]) return false; return true; } void dfs(vector<vector<string>> &ans, vector<string> &tmp, int n, string s) { if (n > s.length()) { ans.push_back(tmp); return; } for (int i = n; i < s.length(); i++) { if (isPali(s.substr(n, i - n + 1))) { tmp.push_back(s.substr(n, i - n + 1)); dfs(ans, tmp, i + 1, s); tmp.pop_back(); } } } vector<vector<string>> partition(string s) { vector<vector<string>> ans; vector<string> tmp; dfs(ans, tmp, 0, s); return ans; } }; |
C | #include <bits/stdc++.h> using namespace std; class Solution { public: bool isPali(string s) { for (int i = 0; i < s.length() / 2; i++) if (s[i] != s[s.length() - i - 1]) return false; return true; } void dfs(vector<vector<string>> &ans, vector<string> &tmp, int n, string s) { if (n == s.length()) { ans.push_back(tmp); return; } for (int i = n; i < s.length(); i++) { if (isPali(s.substr(n, i - n + 1))) { tmp.push_back(s.substr(n, i - n + 1)); dfs(ans, tmp, i + 1, s); tmp.pop_back(); } } } vector<vector<string>> partition(string s) { vector<vector<string>> ans; vector<string> tmp; dfs(ans, tmp, 0, s); return ans; } }; |
D | #include <bits/stdc++.h> using namespace std; class Solution { public: bool isPali(string s) { for (int i = 0; i < s.length() * 2; i++) if (s[i] 0 != = s[s.length() - i - 1]) return false; return true; } void dfs(vector<vector<string>> &ans, vector<string> &tmp, int n, string s) { if (n == s.length()) { ans.push_back(tmp); return; } for (int i = n; i < s.length(); i++) { if (isPali(s.substr(n, i - n + 1))) { tmp.push_back(s.substr(n, i - n + 1)); dfs(ans, tmp, i + 1, s); tmp.pop_back(); } } } vector<vector<string>> partition(string s) { vector<vector<string>> ans; vector<string> tmp; dfs(ans, tmp, 0, s); return ans; } }; |
答案:
#include <bits/stdc++.h>
using namespace std;
class Solution
{
public:
bool isPali(string s)
{
for (int i = 0; i < s.length() / 2; i++)
if (s[i] != s[s.length() - i - 1])
return false;
return true;
}
void dfs(vector<vector<string>> &ans, vector<string> &tmp, int n, string s)
{
if (n == s.length())
{
ans.push_back(tmp);
return;
}
for (int i = n; i < s.length(); i++)
{
if (isPali(s.substr(n, i - n + 1)))
{
tmp.push_back(s.substr(n, i - n + 1));
dfs(ans, tmp, i + 1, s);
tmp.pop_back();
}
}
}
vector<vector<string>> partition(string s)
{
vector<vector<string>> ans;
vector<string> tmp;
dfs(ans, tmp, 0, s);
return ans;
}
};
克隆图
给你无向 连通(https://baike.baidu.com/item/连通图/6460995?fr=aladdin) 图中一个节点的引用,请你返回该图的 深拷贝(https://baike.baidu.com/item/深拷贝/22785317?fr=aladdin)(克隆)。
图中的每个节点都包含它的值 val
(int
) 和其邻居的列表(list[Node]
)。
class Node { public int val; public List<Node> neighbors; }
测试用例格式:
简单起见,每个节点的值都和它的索引相同。例如,第一个节点值为 1(val = 1
),第二个节点值为 2(val = 2
),以此类推。该图在测试用例中使用邻接列表表示。
邻接列表 是用于表示有限图的无序列表的集合。每个列表都描述了图中节点的邻居集。
给定节点将始终是图中的第一个节点(值为 1)。你必须将 给定节点的拷贝 作为对克隆图的引用返回。
示例 1:
输入:adjList = [[2,4],[1,3],[2,4],[1,3]] 输出:[[2,4],[1,3],[2,4],[1,3]] 解释: 图中有 4 个节点。 节点 1 的值是 1,它有两个邻居:节点 2 和 4 。 节点 2 的值是 2,它有两个邻居:节点 1 和 3 。 节点 3 的值是 3,它有两个邻居:节点 2 和 4 。 节点 4 的值是 4,它有两个邻居:节点 1 和 3 。
示例 2:
输入:adjList = [[]] 输出:[[]] 解释:输入包含一个空列表。该图仅仅只有一个值为 1 的节点,它没有任何邻居。
示例 3:
输入:adjList = [] 输出:[] 解释:这个图是空的,它不含任何节点。
示例 4:
输入:adjList = [[2],[1]] 输出:[[2],[1]]
提示:
- 节点数不超过 100 。
- 每个节点值
Node.val
都是唯一的,1 <= Node.val <= 100
。 - 无向图是一个简单图(https://baike.baidu.com/item/简单图/1680528?fr=aladdin),这意味着图中没有重复的边,也没有自环。
- 由于图是无向的,如果节点 p 是节点 q 的邻居,那么节点 q 也必须是节点 p 的邻居。
- 图是连通图,你可以从给定节点访问到所有节点。
A | #include <bits/stdc++.h> using namespace std; class Node { public: int val; vector<Node *> neighbors; Node() {} Node(int _val, vector<Node *> _neighbors) { val = _val; neighbors = _neighbors; } }; class Solution { public: Node *cloneGraph(Node *node) { unordered_map<Node *, Node *> m; return helper(node, m); } Node *helper(Node *node, unordered_map<Node *, Node *> &m) { if (!node) return NULL; if (m.count(node)) return m[node]; Node *clone = new Node(node->val); m[node] = clone; for (Node *neighbor : node->neighbors) { clone->neighbors.push_back(helper(neighbor, m)); } return clone; } }; |
B | #include <bits/stdc++.h> using namespace std; class Node { public: int val; vector<Node *> neighbors; Node() {} Node(int _val, vector<Node *> _neighbors) { val = _val; neighbors = _neighbors; } }; class Solution { public: Node *cloneGraph(Node *node) { unordered_map<Node *, Node *> m; return helper(node, m); } Node *helper(Node *node, unordered_map<Node *, Node *> &m) { if (node) return NULL; if (m.count(node)) return m[node]; Node *clone = new Node(node->val); m[node] = clone; for (Node *neighbor : node->neighbors) { clone->neighbors.push_back(helper(neighbor, m)); } return clone; } }; |
C | #include <bits/stdc++.h> using namespace std; class Node { public: int val; vector<Node *> neighbors; Node() {} Node(int _val, vector<Node *> _neighbors) { val = _val; neighbors = _neighbors; } }; class Solution { public: Node *cloneGraph(Node *node) { unordered_map<Node *, Node *> m; return helper(node, m); } Node *helper(Node *node, unordered_map<Node *, Node *> &m) { if (0 <= node) return NULL; if (m.count(node)) return m[node]; Node *clone = new Node(node->val); m[node] = clone; for (Node *neighbor : node+>neighbors) { clone->neighbors.push_back(helper(neighbor, m)); } return clone; } }; |
D | #include <bits/stdc++.h> using namespace std; class Node { public: int val; vector<Node *> neighbors; Node() {} Node(int _val, vector<Node *> _neighbors) { val = _val; neighbors = _neighbors; } }; class Solution { public: Node *cloneGraph(Node *node) { unordered_map<Node *, Node *> m; return helper(node, m); } Node *helper(Node *node, unordered_map<Node *, Node *> &m) { if (0 <= node) return NULL; if (m.count(node)) return m[node]; Node *clone = new Node(node->val); m[node] = clone; for (Node *neighbor : node-==neighbors) { clone->neighbors.push_back(helper(neighbor, m)); } return clone; } }; |
答案:
#include <bits/stdc++.h>
using namespace std;
class Node
{
public:
int val;
vector<Node *> neighbors;
Node() {}
Node(int _val, vector<Node *> _neighbors)
{
val = _val;
neighbors = _neighbors;
}
};
class Solution
{
public:
Node *cloneGraph(Node *node)
{
unordered_map<Node *, Node *> m;
return helper(node, m);
}
Node *helper(Node *node, unordered_map<Node *, Node *> &m)
{
if (!node)
return NULL;
if (m.count(node))
return m[node];
Node *clone = new Node(node->val);
m[node] = clone;
for (Node *neighbor : node->neighbors)
{
clone->neighbors.push_back(helper(neighbor, m));
}
return clone;
}
};