商汤科技面试准备
秋招收到了东软医疗算法,明略科技算法,云从算法的Offer
但是在我沉淀了整个求职季之后
心心念念的商汤,终终终终终终终终终于给我发起面试邀请了
商汤一直是我最想进的企业,没有之一
一些长久以来,秋招面试的相关知识点,各种原文链接总结在这
我有很努力去争取
希望世界上最好的商汤科技的明天的面试
顺利通过,fighting and praying
参考原文
通过定义初始化零水平集,演化能量泛函,进行曲线的演化,在指定的迭代次数范围内,收缩到一个误差在指定范围内的边界停止达到分割的目的
3维图像的Hessian矩阵的是哪个特征值,代表了物体在空间中的形状,不同的特征值分别代表了长短,粗细以及凸扁,因此可以通过调节参数将图像中的管状结构增强,达到预处理的目的。
参考博客1(检测直线讲的好):https://blog.csdn.net/weixin_40196271/article/details/83346442
参考博客2(检测圆讲得好):https://blog.csdn.net/shanchuan2012/article/details/74010561
引用我自己的博客1和博客2,里面有原文链接,下面的论述想到什么写什么,没有严格按照时间顺序:
L1范数:符合拉普拉斯分布,完全不可微菱形去切等高线,会造成最优的值出现在坐标轴上,出现大量的0,造成稀疏,防止过拟合
L2范数:符合高斯分布,完全可微的,圆形去切等高线,一般最优值不会出现在坐标轴上,L2让系数缩小但不为0,加速优化。
L1会趋向于产生少量的特征,而其它特征都是0。
L2会选择更多的特征,这些特征都会趋近于0。
L1在特征选择时非常有用,而L2只是一种防止过拟合的方法。
在所有特征中只有少数特征起重要作用的情况下,选择L1范数比较合适。
而如果所有特征中,大部分特征都能起作用,而且起的作用很平均,那么使用L2范数也许更合适。
引用我自己的博客
引用我自己的博客
分为五个步骤:
分为以下步骤:
参考链接:https://www.cnblogs.com/bourneli/p/3645049.html
分为以下四个步骤:
以下对于Kmeans的特点的论述内容引用自另一篇博客
引用自博客:https://zhuanlan.zhihu.com/p/29925372具体的步骤如下:
引用自博客:https://blog.csdn.net/isunbin/article/details/93722162
在C++中,内存分成5个区,堆、栈、自由存储区、全局/静态存储区和常量存储区。
内存区 | 作用 |
---|---|
堆 | new的对象在这里,若不delete系统自动回收 |
栈 | 存放函数内局部变量,集成在CPU上,容量有限 |
自由存储 | malloc分配的空间在这里,需要free掉 |
全局/静态存储 | 存放全局变量和静态变量 |
常量存储 | 不能被修改的常量(const) |
一个原博客中的例子:
void f()
{
int* p=new int[5];
}
在栈内存中新建了一个指向堆的指针
参考的原博客:https://www.cnblogs.com/qxxnxxFight/p/11131385.html
根据原博客的例子来说明问题:
定义了三个类,普通飞机(父类),直升机(子类),喷气式飞机(子类)
每个类都有一个叫fly和land的方法代表起飞和降落
因此同名函数的调用会涉及二义性,需要在继承中用虚函数来进行解决
一方面体现了继承,另一方面也体现了多态
具体例子参考原文
虚函数的定义需要注意一下几点:
const就近修饰,离const近的定义的变量类型对应的值,不能被修改
举例说明:
//定义指向常量的指针
const char * pstr = "str1"
//变量(char类型的)不能被改变,指针指向可以改变
//定义常指针
char * const pstr = "str1"
//指针(pstr)不能被改变,指向的变量的值可以改变
//定义指向常量的常指针
const char * const pstr = "str1"
//指针(pstr)不能被改变,指向的变量的值也不能改变
主要列举两种,其余的省略
def par(a, sta, end):
pivot = a[sta]
# 左指针i,右指针j
i, j = sta, end
while i < j:
# 从右往左找第一个比他小的数并交换位置
while i < j and pivot <= a[j]:
j -= 1
a[i] = a[j]
# 从左往右找第一个比他大的数并交换位置
while i < j and pivot >= a[i]:
i += 1
a[j] = a[i]
a[i] = pivot
return i
def quick_sort(a, sta, end):
if sta < end:
pivot = par(a, sta, end)
quick_sort(a, sta, pivot - 1)
quick_sort(a, pivot + 1, end)
else:
return
if __name__ == '__main__':
arr = [6, 2, 7, 3, 8, 9]
quick_sort(arr, 0, len(arr)-1)
print(arr)
from collections import deque
def heap_adj(a, sta, end):
key = a[sta]
# i是当前节点的坐标,j是其左子树
i, j = sta, 2*sta
while j < end:
# 左子树小于右子树,让j指向较大的节点
if a[j] < a[j+1]:
j += 1
# 当前的哨兵比较大的子树小,则交换位置,并且更新下标,继续判断
if key < a[j]:
a[i] = a[j]
i = j
j = 2*i
else:
break
# 最后交换哨兵到恰当的位置
a[i] = key
def heap_sort(a):
length = len(a) - 1
first = length >> 1
# 调整大根堆
for i in range(first):
heap_adj(a, first - i, length)
# 交换最后一个元素,继续调整大根堆
for i in range(length - 1):
a[1], a[length - i] = a[length - i], a[1]
heap_adj(a, 1, length - i - 1)
return [a[k] for k in range(1, len(a))]
if __name__ == '__main__':
L = deque([50, 16, 30, 10, 60, 90, 2, 80, 70])
L.appendleft(0)
print(heap_sort(L))
d p ( i , j ) = { 0 i = 0 , j = 0 d p ( i − 1 , j − 1 ) + 1 s 1 ( i ) = s 2 ( j ) m a x ( d p ( i − 1 , j ) , d p ( i , j − 1 ) ) o t h e r s dp(i,j)=\left\{ \begin{array}{lr} 0 & i=0, j=0\\ dp(i-1,j-1)+1 & s_1(i)=s_2(j)\\ max(dp(i-1,j), dp(i,j-1)) & others \end{array} \right. dp(i,j)=⎩⎨⎧0dp(i−1,j−1)+1max(dp(i−1,j),dp(i,j−1))i=0,j=0s1(i)=s2(j)others
def find_lcsubstr(s1, s2):
dp = [[0] * (len(s2) + 1) for _ in range(len(s1) + 1)]
s_max = 0
p = 0
for i in range(len(s1)):
for j in range(len(s2)):
if s1[i] == s2[j]:
dp[i + 1][j + 1] = dp[i][j] + 1
if dp[i + 1][j + 1] > s_max:
s_max = dp[i + 1][j + 1]
p = i + 1
return s1[p - s_max:p], s_max
print(find_lcsubstr('abcdfg', 'abdfg'))
d p ( i , j ) = { 0 i = 0 , j = 0 d p ( i − 1 , j − 1 ) + 1 s 1 ( i ) = s 2 ( j ) 0 o t h e r s dp(i,j)=\left\{ \begin{array}{lr} 0 & i=0, j=0\\ dp(i-1,j-1)+1 & s_1(i)=s_2(j)\\ 0 & others \end{array} \right. dp(i,j)=⎩⎨⎧0dp(i−1,j−1)+10i=0,j=0s1(i)=s2(j)others
def find_lcseque(s1, s2):
dp = [[0]*(len(s2) + 1) for _ in range(len(s1) + 1)]
direction = [[None]*(len(s2) + 1) for _ in range(len(s1) + 1)]
for i in range(len(s1)):
for j in range(len(s2)):
if s1[i] == s2[j]:
dp[i + 1][j + 1] = dp[i][j] + 1
direction[i + 1][j + 1] = 'ok'
elif dp[i + 1][j] > dp[i][j + 1]:
dp[i + 1][j + 1] = dp[i + 1][j]
direction[i + 1][j + 1] = 'left'
else:
dp[i + 1][j + 1] = dp[i][j + 1]
direction[i + 1][j + 1] = 'up'
(i, j) = (len(s1), len(s2))
s = []
while dp[i][j]:
c = direction[i][j]
if c == 'ok':
s.append(s1[i - 1])
i -= 1
j -= 1
if c == 'left':
j -= 1
if c == 'up':
i -= 1
s.reverse()
return ''.join(s)
print(find_lcseque('abdfg', 'abcdfg'))