百度2014研发类校园招聘笔试题
1. 动态链接库和静态链接库的优缺点
2. 轮询任务调度和可抢占式调度有什么区别？
3. 列出数据库中常用的锁及其应用场景
1. 给定N是一个正整数，求比N大的最小“不重复数”，这里的不重复是指没有两个相等的相邻位，如1102中的11是相等的两个相邻位故不是不重复数，而12301是不重复数。
2. 设N是一个大整数，求长度为N的字符串的最长回文子串。
3. 坐标轴上从左到右依次的点为a[0]、a[1]、a[2]……a[n-1]，设一根木棒的长度为L，求L最多能覆盖坐标轴的几个点？
1. 在现代系统的设计过程中，为了减轻请求的压力，通常采用缓存技术，为了进一步提升缓存的命中率，同常采用分布是缓存方案。调度模块针对不同内容的用户请求分配给不同的缓存服务器向用户提供服务。请给出一个分布式缓存方案，满足如下要求：
1） 单台缓存服务器故障，整个分布式缓存集群，可以继续提供服务。
2）通过一定得分配策略，可以保证充分利用每个缓存服务的存储空间，及负载均衡。当部分服务器故障或系统扩容时，改分配策略可以保证较小的缓存文件重分配开销。
一、简答题
a. 共享：多个应用程序可以使用同一个动态库，启动多个应用程序的时候，只需要将动态库加载到内存一次即可；
b. 开发模块好：要求设计者对功能划分的比较好。
缺点是不能解决引用计数等问题。
（2）静态库(Static Library)：函数和数据被编译进一个二进制文件(通常扩展名为.LIB)。在使用静态库的情况下，在编译链接可执行文件时，链接器从库中复制这些函数和数据并把它们和应用程序的其它模块组合起来创建最终的可执行文件(.EXE文件)。静态链接库作为代码的一部分，在编译时被链接。优缺点如下：
代码的装载速度快，因为编译时它只会把你需要的那部分链接进去，应用程序相对比较大。但是如果多个应用程序使用的话，会被装载多次，浪费内存。
1）共享锁
SQL Server中，共享锁用于所有的只读数据操作。共享锁是非独占的，允许多个并发事务读取其锁定的资源。默认情况下，数据被读取后，SQL Server立即释放共享锁。例如，执行查询“SELECT * FROM my_table”时，首先锁定第一页，读取之后，释放对第一页的锁定，然后锁定第二页。这样，就允许在读操作过程中，修改未被锁定的第一页。但是，事务 隔离级别连接选项设置和SELECT语句中的锁定设置都可以改变SQL Server的这种默认设置。例如，“ SELECT * FROM my_table HOLDLOCK”就要求在整个查询过程中，保持对表的锁定，直到查询完成才释放锁定。
2）修改锁
修 改锁在修改操作的初始化阶段用来锁定可能要被修改的资源，这样可以避免使用共享锁造成的死锁现象。因为使用共享锁时，修改数据的操作分为两步，首先获得一 个共享锁，读取数据，然后将共享锁升级为独占锁，然后再执行修改操作。这样如果同时有两个或多个事务同时对一个事务申请了共享锁，在修改数据的时候，这些 事务都要将共享锁升级为独占锁。这时，这些事务都不会释放共享锁而是一直等待对方释放，这样就造成了死锁。如果一个数据在修改前直接申请修改锁，在数据修 改的时候再升级为独占锁，就可以避免死锁。修改锁与共享锁是兼容的，也就是说一个资源用共享锁锁定后，允许再用修改锁锁定。
3）独占锁
独占锁是为修改数据而保留的。它所锁定的资源，其他事务不能读取也不能修改。独占锁不能和其他锁兼容。
4）结构锁
结构锁分为结构修改锁（Sch-M）和结构稳定锁（Sch-S）。执行表定义语言操作时，SQL Server采用Sch-M锁，编译查询时，SQL Server采用Sch-S锁。
5）意向锁
意 向锁说明SQL Server有在资源的低层获得共享锁或独占锁的意向。例如，表级的共享意向锁说明事务意图将独占锁释放到表中的页或者行。意向锁又可以分为共享意向锁、 独占意向锁和共享式独占意向锁。共享意向锁说明事务意图在共享意向锁所锁定的低层资源上放置共享锁来读取数据。独占意向锁说明事务意图在共享意向锁所锁定 的低层资源上放置独占锁来修改数据。共享式独占锁说明事务允许其他事务使用共享锁来读取顶层资源，并意图在该资源低层上放置独占锁。
6）批量修改锁
批量复制数据时使用批量修改锁。可以通过表的TabLock提示或者使用系统存储过程sp_tableoption的“table lock on bulk load”选项设定批量修改锁。
二、算法设计题
1 // 求比指定数大且最小的“不重复数” 2 3 #include <stdio.h> 4 5 void minNotRep(int n) 6 { 7 // 需要多次判断 8 while(1) 9 { 10 int a[20], len = 0, i, b = 0; 11 // flag为true表示是“重复数”，为false表示表示是“不重复数” 12 bool flag = false; 13 14 // 将n的各位上数字存到数组a中 15 while(n) 16 { 17 a[len++] = n % 10; 18 n = n / 10; 19 } 20 21 // 从高位开始遍历是否有重复位 22 for(i = len - 1; i > 0; i--) 23 { 24 // 有重复位则次高位加1（最高位有可能进位但这里不需要额外处理） 25 if(a[i] == a[i - 1] && !flag) 26 { 27 a[i - 1]++; 28 flag = true; 29 } 30 else if(flag) 31 { 32 // 将重复位后面的位置为0101...形式 33 a[i - 1] = b; 34 b = (b == 0) ? 1 : 0; 35 } 36 } 37 38 // 重组各位数字为n，如果是“不重复数”则输出退出否则继续判断 39 for(i = len - 1; i >= 0; i--) 40 { 41 n = n * 10 + a[i]; 42 } 43 44 if(!flag) 45 { 46 printf("%d\n", n); 47 break; 48 } 49 } 50 } 51 52 int main() 53 { 54 int N; 55 56 while(scanf("%d", &N)) 57 { 58 minNotRep(N + 1); 59 } 60 61 return 0; 62 }
-
当i==j时，P[i][j]=true
-
当i+1==j时，P[i][j]=str[i]==str[j]
-
其他，P[i][j]=P[i+1][j-1]&&(str[i]==str[j])
那么P[i][j]中j-i+1最大的且值为true的就是最长回文子串。这样，这个方法的时间复杂度为O(n^2)，空间复杂度为O(n^2)。比暴力法有很大的改进。
Source Code：
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 5 int longestPalSubstr(char *str) 6 { 7 int n = strlen(str); 8 int i, j, len, maxlen = 0, maxi = 0, maxj = 0; 9 bool **P = (bool**)malloc(sizeof(bool) * n); 10 11 for(i = 0; i < n; i++) 12 { 13 P[i] = (bool*)malloc(sizeof(bool) * n); 14 } 15 16 // initialize P[i][i] 17 for(i = 0; i < n; i++) 18 { 19 P[i][i] = true; 20 } 21 22 // compute P[n][n] by length 23 for(len = 2; len <= n; len++) 24 { 25 for(i = 0; i < n - len + 1; i++) 26 { 27 j = i + len - 1; 28 if(len == 2) 29 { 30 P[i][j] = (str[i] == str[j]); 31 } 32 else 33 { 34 P[i][j] = ((str[i] == str[j]) && P[i + 1][j - 1]); 35 } 36 } 37 } 38 39 // int k; 40 for(i = 0; i < n; i++) 41 { 42 for(j = i; j < n; j++) 43 { 44 // printf("%d ", P[i][j]); 45 if(P[i][j] && maxlen < (j - i + 1)) 46 { 47 maxlen = j - i + 1; 48 maxi = i; 49 maxj = j; 50 } 51 } 52 // printf("\n"); 53 // for(k = 0; k <= i; k++) 54 // printf(" "); 55 } 56 57 printf("The longest palin substr is "); 58 for(i = maxi; i <= maxj; i++) 59 { 60 printf("%c", str[i]); 61 } 62 printf(", maxlen is %d\n\n", maxlen); 63 64 return maxlen; 65 } 66 67 int main() 68 { 69 char str[100]; 70 71 while(1) 72 { 73 gets(str); 74 if(strlen(str) == 0) break; 75 longestPalSubstr(str); 76 } 77 78 return 0; 79 }
算法3：第三个方法，可以从上面那个方法的状态转移方程获得启发，对于每一个回文子串可以先确定一个中心，然后向两边扩展，这样可以在时间复杂度O(n^2)，空间复杂度O(1)的情况下完成，需要注意的是，长度为奇数和偶数的中心的情况是不同的。
Source Code：
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 5 int longestPalSubstr(char *str) 6 { 7 int len = strlen(str); 8 int i, maxLen = 1, start = 0; 9 int low, high; 10 11 // 将每个字符作为中心向两边扩展判断 12 for(i = 1; i < len; i++) 13 { 14 // 处理长度为偶数的情况 15 low = i - 1; 16 high = i; 17 while(low >= 0 && high < len && str[low] == str[high]) 18 { 19 if(maxLen < high - low + 1) 20 { 21 start = low; 22 maxLen = high - low + 1; 23 } 24 low--; 25 high++; 26 } 27 28 // 处理长度为奇数的情况 29 low = i - 1; 30 high = i + 1; 31 while(low >= 0 && high < len && str[low] == str[high]) 32 { 33 if(maxLen < high - low + 1) 34 { 35 start = low; 36 maxLen = high - low + 1; 37 } 38 low--; 39 high++; 40 } 41 } 42 43 printf("The longest palin substr is "); 44 for(i = start; i < start + maxLen; i++) 45 { 46 printf("%c", str[i]); 47 } 48 printf(", maxlen is %d\n\n", maxLen); 49 50 return maxLen; 51 } 52 53 int main() 54 { 55 char str[100]; 56 57 while(1) 58 { 59 gets(str); 60 if(strlen(str) == 0) break; 61 longestPalSubstr(str); 62 } 63 64 return 0; 65 }
算法4：第四个方法采用后缀数组，将最长回文子串的问题转化为最长公共前缀的问题。具体的做法就是：将整个字符串翻转之后，拼接到原字符串后，注意用特殊字 符分开，这样问题就变成了新的字符串的某两个后缀的最长公共前缀的问题了。这个方法比较强大，很多字符串的问题都能够巧妙的解决。不过实现起来也相对比较:难，好的实现和差的实现时间复杂度相差很大。由于对后缀数组不是很清楚，未写代码，等学习了后缀数组再过来补。
算法5：第五个方法叫做Manacher算法，是一种线性时间的方法，非常巧妙。首先，我们在上面的方法中个，都要考虑回文长度为奇数或者偶数的情况。这个:方法，引入一个技巧，使得奇数和偶数的情况统一处理了。具体做法如下：
abba转换为#a#b#b#a#，也就是在每一个字符两边都加上一个特殊字符。
然后创建一个新的P[i]表示，以第i个字符为中心的回文字串的半径。例如上面的例子，对应的P如下,设S为原始字符串：
| S | # | a | # | b | # | b | # | a | # |
| P | 1 | 2 | 1 | 2 | 5 | 2 | 1 | 2 | 1 |
通过观察上面的表，大家可以发现P[i]-1就是实际回文字串的长度。如果知道P，遍历一次就知道最长的回文子串。可以该如何计算P呢？这是这个算法最核心的部分。
下面的讨论基本转自博客：http://www.felix021.com/blog/read.php?2040 该博客中对Manacher算法介绍得也非常好，向大家推荐。
算法引入两个变量id和mx，id表示最长回文子串的中心位置，mx表示最长回文字串的边界位置，即：mx=id+P[id]。
在这里有一个非常有用而且神奇的结论：如果mx > i，那么P[i] >= MIN(P[2 * id - i], mx - i) 分开理解就是：
-
如果mx - i > P[j], 则P[i]=P[j]
-
否则，P[i] = mx - i.
这两个该如何理解呢？具体的解释请看下面的两个图。
（1）当 mx - i > P[j] 的时候，以S[j]为中心的回文子串包含在以S[id]为中心的回文子串中，由于 i 和 j 对称，以S[i]为中心的回文子串必然包含在以S[id]为中心的回文子串中，所以必有 P[i] = P[j]，见下图。
（2）当 P[j] >= mx - i 的时候，以S[j]为中心的回文子串不一定完全包含于以S[id]为中心的回文子串中，但是基于对称性可知，下图中两个绿框所包围的部分是相同的，也就是 说以S[i]为中心的回文子串，其向右至少会扩张到mx的位置，也就是说 P[i] >= mx - i。至于mx之后的部分是否对称，就只能老老实实去匹配了。
对于 mx <= i 的情况，无法对 P[i]做更多的假设，只能P[i] = 1，然后再去匹配了。
理解了上面的一点，就没有问题了。
Source Code:
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 5 int longestPalSubstr(char *str) 6 { 7 char s[100]; 8 int i, maxLen = 1, start = 0, j; 9 int len = strlen(str); 10 int mx = 0, id = 0, min; 11 12 s[0] = '$'; 13 s[1] = '#'; 14 for(i = 0, j = 2; i < len; i++, j += 2) 15 { 16 s[j] = str[i]; 17 s[j + 1] = '#'; 18 } 19 s[j] = '\0'; 20 21 len = len * 2 + 1; 22 int *p = (int *)malloc(sizeof(int) * len); 23 memset(p, 0, len); 24 p[0] = 1; 25 26 for(i = 1; i < len; i++) 27 { 28 min = p[2 * id - i] > (mx - i) ? (mx - i) : p[2 * id - i]; 29 p[i] = mx > i ? min : 1; 30 while(s[i + p[i]] == s[i - p[i]]) 31 { 32 p[i]++; 33 } 34 if(i + p[i] > mx) 35 { 36 mx = i + p[i]; 37 id = i; 38 } 39 } 40 41 for(i = 0; i < len; i++) 42 { 43 //printf("%d ", p[i]); 44 if(maxLen < p[i] - 1) 45 { 46 maxLen = p[i] - 1; 47 start = i - maxLen; 48 } 49 } 50 51 printf("The longest palin substr is "); 52 for(i = start; i < start + 2 * maxLen + 1; i++) 53 { 54 if(s[i] != '#') 55 { 56 printf("%c", s[i]); 57 } 58 } 59 printf(", maxlen is %d\n\n", maxLen); 60 61 return maxLen; 62 } 63 64 int main() 65 { 66 char str[100]; 67 68 while(1) 69 { 70 gets(str); 71 if(strlen(str) == 0) break; 72 longestPalSubstr(str); 73 } 74 75 return 0; 76 }
有两点需要注意：
1 // 求最大覆盖点 2 3 #include <stdio.h> 4 5 int maxCover(int a[], int n, int L) 6 { 7 int count = 2, maxCount = 1, start; 8 int i = 0, j = 1; 9 10 while(i < n && j < n) 11 { 12 13 while((j < n) && (a[j] - a[i] <= L)) 14 { 15 j++; 16 count++; 17 } 18 19 // 退回到满足条件的j 20 j--; 21 count--; 22 23 if(maxCount < count) 24 { 25 start = i; 26 maxCount = count; 27 } 28 i++; 29 j++; 30 } 31 32 printf("covered point: "); 33 for(i = start; i < start + maxCount; i++) 34 { 35 printf("%d ", a[i]); 36 } 37 printf("\n"); 38 39 return maxCount; 40 } 41 42 int main() 43 { 44 // test 45 int a[] = {1, 3, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18, 21}; 46 47 printf("max count: %d\n\n", maxCover(a, 13, 8)); 48 49 int b[] = {1,2,3,4,5,100,1000}; 50 51 printf("max count: %d\n", maxCover(b, 7, 8)); 52 53 return 0; 54 }
