用最少数量的箭引爆气球
class Solution {
public:
class MyCompare{
public:
bool operator()(vector<int>& a, vector<int>& b){
return a[0] < b[0];
}
};
int findMinArrowShots(vector<vector<int>>& points) {
int count = 1;
MyCompare cmp;
sort(points.begin(), points.end(), cmp);
for(int i=1; i<points.size(); i++){
if(points[i][0] > points[i-1][1]){ //当前左边界大于前一个右边界
count++;
}else{
points[i][1] = min(points[i][1], points[i-1][1]); //更新右边界
}
}
return count;
}
};
填充每个节点的下一个右侧节点指针
给一个二叉树：
填充它的每个next指针，让指针指向其下一个右侧节点。
/*
// Definition for a Node.
class Node {
public:
int val;
Node* left;
Node* right;
Node* next;
Node() : val(0), left(NULL), right(NULL), next(NULL) {}
Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}
Node(int _val, Node* _left, Node* _right, Node* _next)
: val(_val), left(_left), right(_right), next(_next) {}
};
*/
class Solution {
public:
Node* connect(Node* root) {
if(root == nullptr){
return nullptr;
}
queue<Node*> que;
que.push(root);
while(!que.empty()){
int n = que.size();
Node* prev = nullptr;
for(int i=1; i<=n; i++){
Node* curr = que.front();
que.pop();
if(curr->left){
que.push(curr->left);
}
if(curr->right){
que.push(curr->right);
}
if(i != 1){
prev->next = curr;
}
prev = curr;
}
}
return root;
}
};
二叉搜索树迭代器
实现一个二叉搜索树迭代器BSTIterator，表示一个按中序遍历的迭代器。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class BSTIterator {
private:
void inorder(TreeNode* root, vector<int>& res){
if(!root){
return;
}
inorder(root->left, res);
res.push_back(root->val);
inorder(root->right, res);
}
vector<int> inorderTraversal(TreeNode* root){
vector<int> res;
inorder(root, res);
return res;
}
vector<int> arr;
int idx;
public:
BSTIterator(TreeNode* root) {
this->idx = 0;
arr = inorderTraversal(root);
}
int next() {
return arr[idx++];
}
bool hasNext() {
return idx < arr.size();
}
};
/**
* Your BSTIterator object will be instantiated and called as such:
* BSTIterator* obj = new BSTIterator(root);
* int param_1 = obj->next();
* bool param_2 = obj->hasNext();
*/
克隆图
给一个无向连通图中一个节点的引用，请返回该图的深拷贝。
深度优先搜索
图的深拷贝是构建一张与原图结构，值均一样的图，但是其中的节点不再是原来图节点的引用。
因此，为了深拷贝出整张图，我们需要知道整张图的结构以及对应节点的值。
/*
// Definition for a Node.
class Node {
public:
int val;
vector<Node*> neighbors;
Node() {
val = 0;
neighbors = vector<Node*>();
}
Node(int _val) {
val = _val;
neighbors = vector<Node*>();
}
Node(int _val, vector<Node*> _neighbors) {
val = _val;
neighbors = _neighbors;
}
};
*/
class Solution {
public:
unordered_map<Node*, Node*> visited;
Node* cloneGraph(Node* node) {
if(node == nullptr){
return node;
}
//如果该节点已经被访问过，直接从哈希表中取出对应的克隆节点返回
if(visited.find(node) != visited.end()){
return visited[node];
}
//克隆节点
Node* cloneNode = new Node(node->val);
visited[node] = cloneNode;
for(auto& neighbor : node->neighbors){
cloneNode->neighbors.emplace_back(cloneGraph(neighbor));
}
return cloneNode;
}
};
除法求值
广度优先搜索
将整个问题建模成一张图：给定图中的一些点（变量），以及某些边的权值（两个变量的比值），试求出任意两点（两个变量）求出其路径长（两个变量的比值）。
因此，我们首先要遍历equations数组，找出其中所有不同的字符串，并通过哈希表将每个不同的字符串映射成整数。
在构建完图之后，对于任何一个查询，就可以从起点出发，通过广度优先搜索的方式，不断更新起点与当前点之间的路径，直到搜索到终点为止。
寻找重复值
快慢指针
对nums数组建图，每个位置i连一条i->nums[i]的边，由于存在重复的数字target，因此，target这个位置至少有两条指向它的边，因此一定存在环。
那么问题等价于找环的入口。
我们将设置慢指针slow和快指针fast，慢指针每次走一步，快指针走两步，在有环的情况下一定相遇，此时再将慢指针放到slow，两个指针同时移动一步，相遇的点就是答案。
课程表二
现在共有numCourses门课程需要选，记为0到numCourses-1。
给定一个数组，它的每一个元素表示先后之间要修的课程顺序，[ai,bi]表示要学习ai，先要学习bi。
给出先修顺序。
class Solution {
public:
vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
//求拓扑顺序，每次找到入度为0的点，就是第一步要走的，随后减掉入度为0的相邻点的入度。
vector<int> inDegree(numCourses, 0); //求每个点的入度
vector<vector<int>> nextNode(numCourses); //求每个点相邻的点
vector<int> res;
for(auto &p : prerequisites){
inDegree[p[0]]++;
nextNode[p[1]].push_back(p[0]);
}
queue<int> que;
for(int i=0; i<numCourses; i++){
if(inDegree[i] == 0){
que.push(i);
}
}
while(!que.empty()){
int course = que.front();
que.pop();
res.push_back(course);
for(auto &p : nextNode[course]){
inDegree[p]--;
if(inDegree[p] == 0){
que.push(p);
}
}
}
if(res.size() != numCourses){
return {};
}
return res;
}
};
单词搜索
给定一个mxn二维字符网格board和一个字符串单词word，如果word存在于网格中返回true，否则返回false。
在一个信噪比为63:1，带宽为8KHz的信道上传输某个二进制信号，其最大数据速率可以达到？
- 根据香农定理，最大速率=Wlog2(1+S/N) = 48kHz
- 根据奈奎斯定义2W*log 2V = 16000b/s
线程的实现可分为三类，用户级线程，内核级线程以及混合线程。
TCP首部的固定长度为20Byte。
ORDER BY排序，默认是升序。
ORDER BY排序可以对多列或单列进行排序。
多列排序是前一列存在相同值才会根据后一列进行排序。
SELECT prod_price FROM Products ORDER BY prod_price DESC;表示查询结果根据prod_price倒序排。
临界资源是互斥共享资源，非共享数据不属于临界资源。
磁带机、打印机一次只能允许一个进程使用，CPU也是临界资源。
HTTP常用的首部字段Connection表示客户端要求服务器使用持久连接，以便其它请求复用。
HOST：客户端发送请求时，用来指定服务器的域名。
Content-Length：服务器返回数据时，表明本次回应的数据长度。
Connection字段最常用于客户端要求服务器使用持久连接，以便其它请求复用。
Content-Type字段用于服务器回应时，告诉客户端，本次数据是什么格式。
Content-Encoding字段说明数据的压缩方式。表示服务器返回的数据用了什么压缩格式。
Refer告知服务器请求的原始资源的URI。
统计每日新增用户数：
第一步查出用户第一次登录的日期，同时去重user_id，第二步group by date即可。
创建软链接：
ln -s file1 link1
SELinux是一种安全增强型Linux，默认的工作模式是强制模式，系统严格按照SELinux策略进行访问控制，任何违反策略的访问都会被拒绝。这种模式提供了最高的安全性。
查看防火墙状态的命令是：
- iptables -L
- systemctl status firewalld
TCP协议使用的传输协议是IP。
