每日一练--IT冷知识&C/C++--第二天
目录
《纸牌屋》是谁制作的？
格式化后的时钟
Win 8 保留的东西
从前序与中序遍历序列构造二叉树
分割回文串
克隆图
《纸牌屋》是谁制作的？
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 <= 3000inorder.length == preorder.length-3000 <= preorder[i], inorder[i] <= 3000preorder和inorder均无重复元素inorder均出现在preorderpreorder保证为二叉树的前序遍历序列inorder保证为二叉树的中序遍历序列
| A | #include 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 public: TreeNode *myBuildTree(vector { 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 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 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 public: TreeNode *myBuildTree(vector { 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 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 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 public: TreeNode *myBuildTree(vector { 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 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 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 public: TreeNode *myBuildTree(vector { 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 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
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 inMap;
public:
TreeNode *myBuildTree(vector &preorder, int preStart, int preEnd, vector &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 &preorder, vector &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 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 { 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 vector dfs(ans, tmp, 0, s); return ans; } }; |
| B | #include 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 { 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 vector dfs(ans, tmp, 0, s); return ans; } }; |
| C | #include 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 { 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 vector dfs(ans, tmp, 0, s); return ans; } }; |
| D | #include 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 { 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 vector dfs(ans, tmp, 0, s); return ans; } }; |
答案：
#include
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> &ans, vector &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> partition(string s)
{
vector> ans;
vector 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 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 using namespace std; class Node { public: int val; vector Node() {} Node(int _val, vector { val = _val; neighbors = _neighbors; } }; class Solution { public: Node *cloneGraph(Node *node) { unordered_map return helper(node, m); } Node *helper(Node *node, unordered_map { 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 using namespace std; class Node { public: int val; vector Node() {} Node(int _val, vector { val = _val; neighbors = _neighbors; } }; class Solution { public: Node *cloneGraph(Node *node) { unordered_map return helper(node, m); } Node *helper(Node *node, unordered_map { 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 using namespace std; class Node { public: int val; vector Node() {} Node(int _val, vector { val = _val; neighbors = _neighbors; } }; class Solution { public: Node *cloneGraph(Node *node) { unordered_map return helper(node, m); } Node *helper(Node *node, unordered_map { 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 using namespace std; class Node { public: int val; vector Node() {} Node(int _val, vector { val = _val; neighbors = _neighbors; } }; class Solution { public: Node *cloneGraph(Node *node) { unordered_map return helper(node, m); } Node *helper(Node *node, unordered_map { 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
using namespace std;
class Node
{
public:
int val;
vector neighbors;
Node() {}
Node(int _val, vector _neighbors)
{
val = _val;
neighbors = _neighbors;
}
};
class Solution
{
public:
Node *cloneGraph(Node *node)
{
unordered_map m;
return helper(node, m);
}
Node *helper(Node *node, unordered_map &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;
}
};