Leetcode：200题总结(二)
【每一次总结一页中已经做过的题目】
▲二因为维vector的初始化：
```
vector
for(auto& a:ans)
a.assign(m,0);
```
542 . 01 Matrix
求最邻近的cell为0的距离。**涉及图和最短距离，用BFS很容易理解**(借助队列)
679 . 24 Game
24点游戏，给定一组包含4个元素的序列，判断是否有解。涉及“ ×，/，+，-，（，）”。 没看题解我是想不到这题是用回溯法解题的，太菜了。另外，该题还要注意除数不能为0的问题还有精度问题，因为序列中的数据是double型的，还有两个数的运算结果可以作为一个新的数与其他还未参与运算的数进行各种有效的运算。
四个数可以任意两两组合，尝试不同的运算方式，看是否有解。
```
class Solution {
public:
bool solve(vector
{
if(card.empty())
return false;
if(card.size()==1)
return abs(card[0]-24) < 1e-6;
for(int i=0; i
double a=card[i],b=card[j];
vector
for(int k=0; k
temp.push_back(card[k]);
temp.push_back(a+b);
if(solve(temp))
return true;
temp.pop_back();
temp.push_back(a-b);
if(solve(temp))
return true;
temp.pop_back();
temp.push_back(b-a);
if(solve(temp))
return true;
temp.pop_back();
temp.push_back(a*b);
if(solve(temp))
return true;
temp.pop_back();
if(a)
{
temp.push_back(b/a);
if(solve(temp))
return true;
temp.pop_back();
}
if(b)
{
temp.push_back(a/b);
if(solve(temp))
return true;
temp.pop_back();
}
}
return false;
}
bool judgePoint24(vector
{
vector
return solve(card);
}
};
```
67. Add Binary
二进制数字相加（字符串形式），我自己写的代码太繁琐，这里学习discuss里别人的代码。
```
class Solution
{
public:
string addBinary(string a, string b)
{
string s = "";
int c = 0, i = a.size() - 1, j = b.size() - 1;
while(i >= 0 || j >= 0 || c == 1) //这里还有c==1这个条件是考虑了最高位相加进位的情况。
{
c += i >= 0 ? a[i --] - '0' : 0;
c += j >= 0 ? b[j --] - '0' : 0;
s = char(c % 2 + '0') + s; //如果直接用 s+= ...，最后还要reverse，这样操作避免了这最后一步
c /= 2; //进位
}
return s;
}
};
```
415. Add Strings 以字符串形式表示的十进制数相加
这题与上面的题思路类似，我自己写的繁琐，这里贴出discuss里简明易理解的代码。值得学习！
```
string addStrings(string num1, string num2)
{
int sum = 0, i = num1.length() - 1, j = num2.length() - 1;
string str;
while (i >= 0 || j >= 0 || sum > 0) //sum>0 表示有进位
{
if (i >= 0) sum += (num1[i--] - '0');
if (j >= 0) sum += (num2[j--] - '0');
str = char(sum%10+'0')+str;
sum /= 10;
}
return str;
}
```
863. All Nodes Distance K in Binary Tree
求二叉树中与目标节点距离为K的节点。因为与目标节点距离为K的节点可以在目标节点的下层，也可以是在目标节点的上层。所以我们可以将二叉树转为一张图（借助unordered_map，标记每一个节点的父结点），然后采用BFS，层次遍历，一步一步扩展，直到扩展到与目标节点距离K的一层。
```
class Solution {
public:
unordered_map
unordered_set
//dfs 获取父结点
void dfs(TreeNode* root,TreeNode* target)
{
if(root==NULL||root==target) //只要知道目标节点的父节点
return ;
if(root->left)
p[root->left]=root,dfs(root->left,target);
if(root->right)
p[root->right]=root,dfs(root->right,target);
}
vector
vector
dfs(root,target);
queue
q.push(target);
//BFS 一步一步走，直到找到距离为K的节点
//利用确定下来的父结点，使得整棵树变成一张图
while(!q.empty()&&K>=0)
{
int n = q.size();
while(n--)
{
TreeNode* cur = q.front();
q.pop();
v.insert(cur);
if(K==0)
ans.push_back(cur->val);
if(cur->left&&!v.count(cur->left))
q.push(cur->left);
if(cur->right&&!v.count(cur->right))
q.push(cur->right);
if(p.count(cur)&&!v.count(p[cur]))
q.push(p[cur]);
}
K--;
}
return ans;
}
};
```
797. All Paths From Source to Target 给定一张有向图，求所有从0号节点到N-1号节点的路径。
很直接的用回溯法求解，从0号节点走到N-1号节点，找到一条路径后就往回走，继续找其他路径。
```
class Solution {
public:
void DFS(vector
{
if(u==graph.size()-1)
allpath.push_back(path);
else
{
for(auto v:graph[u])
{
path.push_back(v);
DFS(graph,path,allpath,v);
path.pop_back();
}
}
}
vector
{
vector
vector
getpath.push_back(0);
DFS(graph,getpath,path,0);
return path;
}
};
```
▲通过做题量提升对常用数据结构stack,queue,map,set等STL容器的使用。对于stack和queue，可以观察题意看是否有与stack或者queue类似的性质，有的话可以尝试采用stack和queue解题，会使思路清晰，易于理解。
```
class Solution {
public:
bool backspaceCompare(string S, string T) {
stack
for(char ch:S)
{
if(ch=='#')
{
if(!s.empty())
s.pop();
}
else
s.push(ch);
}
S="";
while(!s.empty())
S+=s.top(),s.pop();
for(char ch:T)
{
if(ch=='#')
{
if(!s.empty())
s.pop();
}
else
s.push(ch);
}
T="";
while(!s.empty())
T+=s.top(),s.pop();
return S==T;
}
};
```
110. Balanced Binary Tree 判断一棵树是不是平衡树（每一个节点的左右子树的高度相差至多为1）
主要掌握如何计算树的高度！
```
class Solution {
public:
int height(TreeNode* root,bool& tag)
{
int deep = 0;
if(root==NULL)
return deep;
int left = height(root->left,tag)+1;
int right = height(root->right,tag)+1;
deep = max(left,right);
if(abs(left-right)>1)
tag = false;
return deep;
}
bool isBalanced(TreeNode* root) {
bool tag=true; //tag用于指示树是不是平衡二叉树
height(root,tag);
return tag;
}
};
```