一起养成写作习惯！这是我参与「掘金日新计划 · 4 月更文挑战」的第7天，点击查看活动详情。
七月在线 社区学员分享的面试题，这边做了解析，分享出来供大家参考，欢迎交流。
1、对Transformer的理解
Transformer本身是一个典型的encoder-decoder模型，Encoder端和Decoder端均有6个Block，Encoder端的Block包括两个模块，多头self-attention模块以及一个前馈神经网络模块；Decoder端的Block包括三个模块，多头self-attention模块，多头Encoder-Decoder attention交互模块，以及一个前馈神经网络模块；需要注意：Encoder端和Decoder端中的每个模块都有残差层和Layer Normalization层。
2、Leetcode—搜索旋转排序数组
思路一：暴力解法
直接遍历整个数组，找到目标值target
代码如下：
class Solution:
def search(self, nums: List[int], target: int) -> int:
for i,num in enumerate(nums):
if num == target:
return i
return -1
时间复杂度：O(n)
空间复杂度：O(1)
思路二：二分查找
先要设置整个数组的左右两端端点：left = 0，right = len(nums) - 1
1、若 target == nums[mid]，直接返回
2、若 nums[left] <= nums[mid]，说明左侧区间 [left,mid]「连续递增」。此时：
若 nums[left] <= target <= nums[mid]，说明 target 位于左侧。令 right = mid-1，在左侧区间查找；否则，令 left = mid+1，在右侧区间查找
3、否则，说明右侧区间 [mid,right]「连续递增」。
此时：
若 nums[mid] <= target <= nums[right]，说明 target 位于右侧区间。令 left = mid+1，在右侧区间查找
否则，令 right = mid-1，在左侧区间查找
代码如下：
class Solution:
def search(self, nums: List[int], target: int) -> int:
left = 0
right = len(nums) -1
while left <= right:
mid = left + (right - left) // 2
if nums[mid] == target:
return mid
elif nums[left] <= nums[mid]:
if nums[left] <= target < nums[mid]:
right = mid - 1
else:
left = mid + 1
else:
if nums[mid] < target <= nums[right]:
left = mid + 1
else:
right = mid - 1
return -1
时间复杂度：O(logn)
空间复杂度：O(1)
3、Leetcode—二叉树层序遍历
思路：
1、如果 root 为空，直接返回 [ ]
2、定义一个数组queue，并将 root 添加到 queue中，再定义一个res 数组保存结果
3、遍历 当前层 queue 的每个左子节点，右子节点，入队列，且要把 queue 更新成当前层的孩子节点列表，直到 queue 为空。
代码如下：
class Solution:
def levelOrder(self, root: TreeNode) -> List[List[int]]:
if not root:
return []
queue = [root]
res = []
while queue:
res.append([node.val for node in queue])
l1 = []
for node in queue:
if node.left:
l1.append(node.left)
if node.right:
l1.append(node.right)
queue = l1
return res
4、Coding: 最小标记代价（类似Leetcode的72题：编辑距离）
参考：www.cnblogs.com/lintcode/p/…
思路：动态规划
- 已知每个整数范围[1,100]，那么对于每个元素，为了调整到该元素和与之相邻的元素的差不大于target，该元素调整的范围就在[1,100]。所以对于数组A[]的每一位元素，我们都需要进行[1,100]范围内的可能状态的转移。
- 令dp[i][j]表示元素A[i]=j时，A[i]与A[i-1]差值不大于target所需要付出的最小代价。
- 当A[i]=j时，可行的A[i-1]的范围为[max(1, j - target)，min(100, j + target)]。而dp[i][j]为所有可行的A[i-1]中，花费代价最小的一种可能，再加上A[i]调整到 j 所需花费abs(j - A[i])。
- 当A[i]=j时，k在[max(1, j - target)，min(100, j + target)]范围内时，我们可以写出以下式子：
- 1.临界值：
- dp[0][j] = abs(j - A[0])
- 2.状态转移方程：
- dp[i][j] = min(dp[i][j], dp[i - 1][k] + abs(j - A[i]))
- 最后在所有最后一位的可能解dp[n-1][i]中的最小值，就是我们所求的最小代价。
代码如下：
public class Solution {
/*
* @param A: An integer array
* @param target: An integer
* @return: An integer
*/
public int MinAdjustmentCost(List<Integer> A, int target) {
int n = A.size();
// dp[i][j]表示元素A[i]=j时，A[i]与A[i-1]差值不大于target所需要付出的最小代价
int[][] dp = new int[n][101];
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 100; j++) {
// 初始化为极大值
dp[i][j] = Integer.MAX_VALUE;
}
}
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 100; j++) {
if (i == 0) {
// 临界值：第一个元素A[0]调整为j的代价
dp[0][j] = Math.abs(j - A.get(0));
}
else {
// left为A[i]=j时，A[i-1]与A[i]差值不大于target的A[i-1]最小值
// right为A[i]=j时，A[i-1]与A[i]差值不大于target的A[i-1]最大值
int left = Math.max(1, j - target);
int right = Math.min(100, j + target);
for (int k = left; k <= right; k++) {
// 当A[i-1]=k时，答案为A[i-1]=k的代价dp[i-1][k]，加上A[i]=j的调整代价abs(j-A[i])
dp[i][j] = Math.min(dp[i][j], dp[i - 1][k] + Math.abs(j - A.get(i)));
}
}
}
}
int mincost = Integer.MAX_VALUE;
for (int i = 1; i <= 100; i++) {
mincost = Math.min(mincost, dp[n - 1][i]);
}
return mincost;
}
}
复杂度
- 假设数组长度为n
- 空间复杂度O(10000*n)
- 时间复杂度O(n^2)
5、防止过拟合的方法
降低模型复杂度
增加更多的训练数据：使用更大的数据集训练模型
数据增强
正则化：L1、L2、添加BN层
添加Dropout策略
Early Stopping
6、数据不平衡问题处理
欠采样：从样本较多的类中再抽取，仅保留这些样本点的一部分；
过采样：复制少数类中的一些点，以增加其基数；
生成合成数据：从少数类创建新的合成点，以增加其基数。
添加额外特征：除了重采样外，我们还可以在数据集中添加一个或多个其他特征，使数据集更加丰富，这样我们可能获得更好的准确率结果。
