商汤科技2018年校招
交换机主要工作在（）？
正确答案: B 你的答案: B (正确)
网络层
数据链路层
物理层
传输层
解析：
网络层是路由器，数据链路层是交换机，物理层是光纤，传输层是TCP/UDP协议！
一个数据表express(No, SenderName, ReceiverName, SenderAddress, ReceiverAddress, Charge, Weight, Type)，以下不能完成对应操作的sql语句是（）？
正确答案: C 你的答案: C (正确)
查询所有重量在10kg以下的快递，并输出单号和收费<br>Select No, Charge From express Where Weight < 10
查询所有寄件人第一个字为“李”的快递单<br>Select * From express Where name like “李%”
统计表中快递单共有多少种类型<br>Select count（*） From (Select Type From express)
统计表中不同类型的快递单的平均重量，并按从大到小排列<br>Select Type, avg(Weight) From express Group by Type Order by avg(Weight)
完全⼆叉树中有330个叶子节点, 则在该⼆叉树中的节点个数为（）？
正确答案: C 你的答案: C (正确)
659
660
可能为659或者660
不可能为659和660
解析：
因为二叉树度为2的结点n2和叶子结点存在n0：n0=n2+1的关系，所以度为2的结点个数为329，又因为完全二叉树可能存在度为1的结点，所以结点个数为：330+329=659或330+329+1=660.
假设有一种无色的特殊颜料，与红色颜料混合后会变紫色，与黄色颜料混合会变为绿色，与红色、黄色颜料一起混合会变为黑色，发生颜色变化需要1小时。现有700瓶特殊颜料，其中一瓶已经变质，不管与什么颜料混合都会变为白色。只有一小时时间, 最少需要多少个调色盘才能找出变质的特殊颜料？
正确答案: A 你的答案: D (错误)
10
5
6
16
解析：
10个调色盘 ，分别当作10个二进制位。
700瓶颜料从1到700编号，写成二进制形式，对于每一瓶颜料，在其二进制为1的位所对应的调色盘上加入。
一小时后，按照变成白色该调色盘对应位为1的原则，写出一个二进制数就是变质颜料的编号。
开始的时候所有的颜料都按这种原则加入其对应的调色盘中，一小时后看调色盘的状态确定是哪一瓶颜料变质了。比如，一小时后，调色盘状态是前三盘变白了，其余没有，对应的颜料就是0000000111号，即第7瓶变质。
一个口袋装着若干蓝球和若干红球，随机抽出两个球。第一个球是蓝球的概率为0.5； 第一球是蓝球且第二个球是红球的概率为0.2。现如果已知第一个球是蓝球，则第二个球是红球的概率是多少？
正确答案: A 你的答案: B (错误)
0.4
0.2
0.1
0.5
解析：
条件概率
P(A and B) = P(A|B)P(B) = P(B|A)P(A)
P(A|B) = P(A and B)/P(B) = 0.2 / 0.5 = 0.4
一个狗妈妈有70块肉，狗宝宝距离狗妈妈60步。每次狗妈妈最多拿40块肉，每走2步需要吃掉一块肉，则它最多能把 ？ 块肉拿给狗宝宝。
你的答案 (正确) 20
解析：
根据题意，如果满载直接到终点会浪费掉30肉，而最优解一定要将这30肉消耗掉，以换取满载的情况下距离宝宝最近，因此一定要在起点与终点之间有一个折返点；
设：起点为O、折返点为A、终点为B。OA距离为X，最后剩余Y肉给宝宝；则：
第一次从O满载出发再返回有：40-(X/2)*2肉留在A点
第二次O载30肉出发到A点捡起第一次留下的肉应该满载：30-X/2+(40-(X/2)*2)=40得到X=20
则Y=70-(3x+(60-x))/2,代入x=20得Y=20
101枚硬币中有一枚假币，有一个无砝码的天平，在最坏情况下最少称 1 次，可以判断假币比真币重还是轻。
参考答案
(1) 2
解析：
方案1：
将硬币按A组(50)、B组(50)、C组(1)分组,先比较A、B两组:
1>.若A=B，则C为假币，再用A或B中任一个与C比，C重则假币重，C轻则真币重
2>.若A!=B，则A或B中含假币，将A组一分为二：A1(25)、A2(25),比较A1、A2:
<1>.若A1=A2，则A为真币，故：A>B => 真币重；A<B => 假币重
<2>.若A1!=A2，则A含假币，故：A<B => 真币重；A>B => 假币重
方案2：
1>.将硬币按A组(33)、B组(33)、C组(35)分组,先比较A、B两组:
1>.若A=B，则C含假币，再用A+B中任35个与C比，C重则假币重，C轻则真币重
2>.若A!=B，则C为真币，再用C中33个与A比较:
<1>.若C=A，则A为真币，故：A>B => 真币重；A<B => 假币重
<2>.若C!=A，则A含假币，故：A<B => 真币重；A>B => 假币重
注意不是找出假币，而是只要判断出假币比真币轻还是重
参考答案
(1) 4112241441
给定数组 [ 48,8,20,72,65,17,28,23 ]，构造一棵左子节点 < 父节点 < 右子节点 的二叉搜索树（Binary Search Tree）。把数字48删除，使用前序节点调整后，则数字28的左子节点是数字
参考答案
(1) 8
请阅读以下代码和输入，写出程序的输出结果。
#include<iostream>
using namespace std;
int main( ) {
const int MAX_N = 1000;
int n, ans;
int a[MAX_N], f[MAX_N];
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
f[i] = 1;
for (int j = 0; j < i; ++j) {
if ((a[j] < a[i]) && (f[j] >= f[i]))
f[i] = f[j] + 1;
}
}
ans = 0;
for (int i = 1; i < n; ++i) {
if (f[i] > ans) ans = f[i];
}
cout << ans << endl;
}输入
10
2 5 13 6 7 4 10 3 5 8
输出： 5
解析：
最长升序列个数
有一种将字母编码成数字的方式：'a'->1, 'b->2', ... , 'z->26'。
现在给一串数字，给出有多少种可能的译码结果。
示例1
输入
12
输出
2
说明
2种可能的译码结果（”ab” 或”l”）
示例2
输入
31717126241541717
输出
192
说明
192种可能的译码结果
我代码只过了80%的数据，超时了，put上去吧，虽然渣渣，后来回想下，如果把string转换成char[]数组，处理起来更方便点。
import java.util.Scanner;
public class Main{
static int sum = 0;
static int len = 0;
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String s = in.nextLine();
len = s.length()-1;
digui(0,s);
System.out.println(sum);
}
public static void digui(int k,String s){
if(k > len){
sum++;
return ;
}
if(k+1 <= len){
String a = s.substring(k,k+2);
if(a.compareTo("26") <= 0 && a.compareTo("10") >= 0){
digui(k+2, s);
}
digui(k+1,s);
}else{
String a = s.substring(k, k+1);
if(a.compareTo("0") != 0) {
digui(k+1,s);
}else{
return ;
}
}
}
}
看到牛客网的大牛是这样解决的：
#include<bits/stdc++.h>
using namespace std;
int numDecodings(string s) {
if(!s.size() || s.front() == '0') return 0;
int r1 = 1, r2 = 1;
for (int i = 1; i < s.size(); i++){
if (s[i] == '0') r1 = 0;
if (s[i-1] == '1' || s[i-1] == '2' && s[i] <= '6'){
r1 = r2+r1;
r2 = r1-r2;
}
else
r2 = r1;
}
return r1;
}
int main(){
string s;
while(cin >> s){
cout << numDecodings(s) << endl;
}
return 0;
}
给定四个空杯子，容量分别为S1 S2 S3 S4，允许进行以下操作：
1. 将某个杯子接满水
2. 将某个杯子里的水全部倒掉
3. 将杯子A中的水倒进杯子B，直到A倒空或者B被倒满
问最少要多少步操作才能使得这四个杯子装的水分别为T1 T2 T3 T4
思路：
倒水问题通用模板，适用于1个杯子（含有足够量的水）倒水给其余杯子
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<bitset>
using namespace std;
/*将4杯子倒水问题改为一个足够大的杯子倒向4个杯子*/
bitset<17043521> Hash;/*（大小为64*64^4+64*64^3+64*64^2+64*64^1+64*64^0）记录每次操作后的ABCD杯子的当前容量是否已经存在过*/
const int MAX_STEP = 100000;
int WQ[MAX_STEP][6];/*记录每步操作后0和ABCD的当前容量，最后一个记录操作次数*/
int Goal[5];/*0和ABCD杯子最终状态*/
int Cap[5]; /*0和ABCD杯子的最大容量*/
int goalval;
int head = 0;
int tail = 0;
void movw(int numfrom, int numto, int other1,int other2,int other3)/*numfrom倒入numto*/
{
int total = WQ[head][numfrom] + WQ[head][numto];/*numfrom和numto的总量*/
WQ[tail][other1] = WQ[head][other1];
WQ[tail][other2] = WQ[head][other2];
WQ[tail][other3] = WQ[head][other3];
WQ[tail][5] = WQ[head][5] + 1;
if (total>Cap[numto])/*总量和被倒入杯子的容量大小；大于numfrom就有剩余的，否则全部倒入numto*/
{
WQ[tail][numfrom] = total - Cap[numto];
WQ[tail][numto] = Cap[numto];
}
else
{
WQ[tail][numfrom] = 0;
WQ[tail][numto] = total;
}
int hashval = WQ[tail][1] * 262144 + WQ[tail][2] * 4096 + WQ[tail][3] * 64 + WQ[tail][4];/*把ABCD杯子需要的状态抽象为一个值*/
if (hashval == goalval) throw WQ[head][5] + 1;/*判断是否为最终状态*/
if (!Hash[hashval])/*该次操作之后的状态之前未存在过并记录*/
{
Hash[hashval] = true;
if (++tail == MAX_STEP) tail = 0;/*超出最大操作数*/
}
}
int main()
{
Hash.reset();
scanf("%d %d %d %d", &Cap[1], &Cap[2], &Cap[3],&Cap[4]);
scanf("%d %d %d %d", &Goal[1], &Goal[2], &Goal[3], &Goal[4]);
head = 0;
tail = 0;
goalval = Goal[1] * 262144 + Goal[2] * 4096 + Goal[3]*64+Goal[4];/*把ABCD杯子需要的状态抽象为一个值*/
/*处理全部杯子中最后容量都为0的情况*/
if (Goal[1] == 0 && Goal[2] == 0 && Goal[3] == 0 && Goal[4] == 0 ) {
printf("0");
return 0;
}
Cap[0] = 6400;/*0杯子为足够大的杯子，0杯子的容量*/
WQ[tail][0] = 6400;/*0杯子的当前容量*/
/*初始化ABCD杯子当前值为0*/
WQ[tail][1] = 0;
WQ[tail][2] = 0;
WQ[tail][3] = 0;
WQ[tail][4] = 0;
WQ[tail][5] = 0;
++tail;
try {
/*尝试每一种操作*/
while (head != tail)
{
/*A导入B，外层if判断A中当前容量不为零，内层判断B的最大容量不为0*/
if (WQ[head][0]) {
if(Cap[1])
movw(0, 1, 2, 3, 4);
if (Cap[2])
movw(0, 2, 1, 3, 4);
if (Cap[3])
movw(0, 3, 1, 2, 4);
if (Cap[4])
movw(0, 4, 1, 2, 3);
}
if (WQ[head][1]) {
if (Cap[0])
movw(1, 0, 2, 3, 4);
if (Cap[2])
movw(1, 2, 0, 3, 4);
if (Cap[3])
movw(1, 3, 0, 2, 4);
if (Cap[4])
movw(1, 4, 0, 2, 3);
}
if (WQ[head][2]) {
if (Cap[0])
movw(2, 0, 1, 3, 4);
if (Cap[1])
movw(2, 1, 0, 3, 4);
if (Cap[3])
movw(2, 3, 0, 1, 4);
if (Cap[4])
movw(2, 4, 0, 1, 3);
}
if (WQ[head][3]) {
if (Cap[0])
movw(3, 0, 1, 2, 4);
if (Cap[1])
movw(3, 1, 0, 2, 4);
if (Cap[2])
movw(3, 2, 0, 1, 4);
if (Cap[4])
movw(3, 4, 0, 1, 2);
}
if (WQ[head][4]) {
if (Cap[0])
movw(4, 0, 1, 2, 3);
if (Cap[1])
movw(4, 1, 0, 2, 3);
if (Cap[2])
movw(4, 2, 0, 1, 3);
if (Cap[3])
movw(4, 3, 0, 1, 2);
}
if (++head == MAX_STEP) {
head = 0;
}
}
printf("-1");
}
catch (int step)
{
printf("%d\n", step);
}
}研究地球空间科学的永强想研究海岸线的长度和海岸线面积之间的关系，为此他找来了很多航拍图像。在航拍图像上利用图像分割的方法，把图像的每个像素标记成陆地（1）和水面（0）。
示例图片：
现在永强想知道每张图中陆地部分的面积。
已知每张图最底部的一条边都是陆地，并且在一张图上陆地都是四邻域联通的。
但是永强发现分割的结果有很多的噪声，于是他定义了如下规则试图去除噪声：
a) 如果一个水面区域被陆地包围，则将这个区域记为陆地；
b) 在a的基础上如果一个陆地区域不和底边的陆地相连，那么这是一个岛屿，不计入陆地的面积。
输入描述:
第一行为两个整数m和n， 接下来m行每行会有n个数，0表示水面，1表示陆地。
输出描述:
去噪后陆地部分的面积。
示例1
输入
5 6
1 0 0 1 0 0
0 0 1 0 1 0
1 1 1 1 1 0
1 0 0 1 1 1
1 1 1 1 1 1
输出
21
大牛的code:
#include<iostream>
using namespace std;
int m,n;
int *p;
int sum;
/**让一个值为key的节点和他周围值为key的节点连通
*key!=set
*/
void link(int key,int sx,int sy,int set)
{
sum++;
p[sy*n+sx]=set;
if(sx-1>=0&&p[sy*n+sx-1]==key) link(key,sx-1,sy,set);
if(sx+1<n&&p[sy*n+sx+1]==key) link(key,sx+1,sy,set);
if(sy-1>=0&&p[(sy-1)*n+sx]==key) link(key,sx,sy-1,set);
if(sy+1<m&&p[(sy+1)*n+sx]==key) link(key,sx,sy+1,set);
}
int main()
{
int i,j;
cin>>m>>n;
p=new int[m*n];
for(i=0;i<m*n;i++)
{
cin>>p[i];
}
/*连通所有海洋且标记为-1*/
for(i=0;i<n;i++)
{
if(p[i]==0) link(0,i,0,-1);
}
for(i=0;i<m;i++)
{
if(p[i*n]==0) link(0,0,i,-1);
if(p[i*n+n-1]==0) link(0,n-1,i,-1);
}
/*其余的都为陆地，将地中海变为陆地*/
for(i=1;i<m-1;i++)
{
for(j=1;j<n-1;j++)
{
if(p[i*n+j]==0) p[i*n+j]=1;
}
}
sum=0;
/*计算陆地面积*/
link(1,0,m-1,2);
cout<<sum<<endl;
}