编程之旅-Day10
目录
Day10-学习内容
1.剑指Offer
面试题25:合并两个排序的链表
面试题43:整数中1出现的次数
2.Leetcode
例1:求最短变换序列的长度
例2:重排链表
3.2017年校招真题
例1:下厨房
例2:将n变为Fibonacci数的最小步数
4.校招真题-单选题
1.剑指Offer
面试题25:合并两个排序的链表
题目描述：
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
考察点：代码的鲁棒性，是否考虑空链表的情况。
代码：
class Solution {
public:
ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
{
if(pHead1==nullptr){
return pHead2;
}
else if(pHead2==nullptr){
return pHead1;
}
ListNode* pMerge=nullptr;
if(pHead1->val<=pHead2->val){
pMerge=pHead1;
pMerge->next=Merge(pHead1->next,pHead2);
}
else{
pMerge=pHead2;
pMerge->next=Merge(pHead1,pHead2->next);
}
return pMerge;
}
};面试题43:整数中1出现的次数
题目描述：
求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。
思路：1.累加1到n每个整数1出现的次数，时间复杂度是O(nlogn)。
2.找出数字规律，利用递归快速求解，时间复杂度是O(logn)。
解析：1.数字转换为字符数组
char str[50];
sprintf(str,"%d",n);int first=*str-'0';
int sprintf(char *str, const char *format, ...) 发送格式化输出到 str 所指向的字符串。
2.atoi()：将字符串转换为整型值。
https://www.cnblogs.com/bluestorm/p/3168719.html
3.static_cast是一个强制类型转换操作符
https://www.cnblogs.com/QG-whz/p/4509710.html
代码：
class Solution {
public:
int NumberOf1Between1AndN_Solution(int n)
{
if(n<=0) return 0;
char str[50];
sprintf(str,"%d",n);
return NumberOf1(str);
}
int NumberOf1(const char *str){
if(!str||*str<'0'||*str>'9'||*str=='\0'){
return 0;
}
int first=*str-'0';
unsigned int length=static_cast(strlen(str));
if(length==1&&first==0){
return 0;
}
if(length==1&&first>0){
return 1;
}
int numFirstDigit=0;
if(first>1){
numFirstDigit=PowerBase10(length-1);
}
else if(first==1){
numFirstDigit=atoi(str+1)+1;
}
int numOtherDigit=first*(length-1)*PowerBase10(length-2);
int numRecursive=NumberOf1(str+1);
return numFirstDigit+numOtherDigit+numRecursive;
}
int PowerBase10(unsigned int n){
int result=1;
for(int i=0;i
2.Leetcode
例1:求最短变换序列的长度
题目描述：
Given two words (start and end), and a dictionary, find the length of shortest transformation sequence from start to end, such that:
- Only one letter can be changed at a time
- Each intermediate word must exist in the dictionary
For example,
Given:
start ="hit"
end ="cog"
dict =["hot","dot","dog","lot","log"]
As one shortest transformation is"hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length5.
Note:
- Return 0 if there is no such transformation sequence.
- All words have the same length.
- All words contain only lowercase alphabetic characters.
思路：
1.先把字典里面的start删掉，然后插入end。
2.每次找出与队头元素只相差一个字符的单词插入队列，队列一开始只有start。
3.访问过的单词不再访问，故需使用一个deletelist记录已访问的单词用于之后从字典中将其删除。
4.当队列里面包含end单词时停止循环，此长度就是最短长度。
代码：
class Solution {
public:
int ladderLength(string start, string end, unordered_set &dict) {
dict.insert(end);
dict.erase(start);
queue q;
q.push(start);
int length=0;
while(q.size()>0){
length++;
int queueLength=q.size();
for(int i=0;i deleteList;
for(unordered_set::iterator iter=dict.begin();iter!=dict.end();iter++){
int d=distance(start,*iter);
if(d==1){
q.push(*iter);
deleteList.push_back(*iter);
}
}
for(int i=0;i 例2:重排链表
题目描述：
Given a singly linked list L: L 0→L 1→…→L n-1→L n,
reorder it to: L 0→L n →L 1→L n-1→L 2→L n-2→…
You must do this in-place without altering the nodes' values.
For example,
Given{1,2,3,4}, reorder it to{1,4,2,3}.
思路：快慢指针找到中间节点，然后将后面的链表反转（前插法），合并链表，注意题目要求就地解决，即不能用辅助存储空间。
代码：
class Solution {
public:
void reorderList(ListNode *head) {
if(head==nullptr||head->next==nullptr||head->next->next==nullptr){
return;
}
ListNode *fast=head;
ListNode *low=head;
while(fast->next!=nullptr&&fast->next->next!=nullptr){ //快慢指针找中间节点
fast=fast->next->next;
low=low->next;
}
fast=low->next;
low->next=nullptr;
while(fast!=nullptr){ //对low后面的部分逆序
ListNode *temp=fast->next;
fast->next=low->next;
low->next=fast;
fast=temp;
}
ListNode *p=head;
ListNode *q=low->next;
while(q!=nullptr&&p!=nullptr){ //合并low前后两部分
low->next=q->next;
q->next=p->next;
p->next=q;
p=q->next;
q=low->next;
}
}
};3.2017年校招真题
例1:下厨房
题目描述：
牛牛想尝试一些新的料理，每个料理需要一些不同的材料，问完成所有的料理需要准备多少种不同的材料。
输入描述:
每个输入包含 1 个测试用例。每个测试用例的第 i 行，表示完成第 i 件料理需要哪些材料，各个材料用空格隔开，输入只包含大写英文字母和空格，输入文件不超过 50 行，每一行不超过 50 个字符。
输出描述:
输出一行一个数字表示完成所有料理需要多少种不同的材料。示例1
输入
BUTTER FLOUR
HONEY FLOUR EGG
输出
4解析：vector相关函数 https://www.cnblogs.com/aminxu/p/4686332.html
代码：
#include
#include
#include
using namespace std;
int main(){
string food;
vector vecfood;
while(cin>>food){
auto it=find(vecfood.begin(),vecfood.end(),food);
if(it==vecfood.end()){
vecfood.push_back(food);
}
}
cout< 例2:将n变为Fibonacci数的最小步数
题目描述：
Fibonacci数列是这样定义的：
F[0] = 0
F[1] = 1
for each i ≥ 2: F[i] = F[i-1] + F[i-2]
因此，Fibonacci数列就形如：0, 1, 1, 2, 3, 5, 8, 13, ...，在Fibonacci数列中的数我们称为Fibonacci数。给你一个N，你想让其变为一个Fibonacci数，每一步你可以把当前数字X变为X-1或者X+1，现在给你一个数N求最少需要多少步可以变为Fibonacci数。
输入描述:
输入为一个正整数N(1 ≤ N ≤ 1,000,000)
输出描述:输出一个最小的步数变为Fibonacci数"示例1
输入
15
输出
2思路：分别求出比n大的最小fabonacci数和比n小的最大fabonacci数，n与这两个数差的最小值即为最小步数。
代码：
#include
using namespace std;
int main(){
int n,upperlim,lowerlim,f;
int f1=0;
int f2=1;
cin>>n;
while(1){
f=f1+f2;
f1=f2;
f2=f;
if(f 4.校招真题-单选题
例1:阿里巴巴国际站的股票代码是1688，这个数字具有这样的特性，首先是个首位为1的4位数，其次恰巧有且仅有1个数字出现了两次。类似的数字还有：1861,1668等。这样的数字一共有()个。（F）
A.144 B.180 C.216 D.270 E.288 F.432
解析：
分两种情况讨论：
（1）若这个四位数的重复数字为1，那么首先从三个空位中选出一个给1，第二步从剩下9个可选数字中选出2个有序的排列到剩下的两个空位中去，那么有C(1，3)*A(2，9)=3*(9!/(9-2)!)=3*9*8=216种可能；
（2）若这个四位数的重复数字不为1，那么首先从9个可选数字中选出一个作为重复数字(C(1,9))，并放到三个空位中的两个（这两个数字相同，故只涉及组合）(C(2, 3))，然后从剩下8个数字中选出一个（它的位置在重复数字确定后就自然固定了，不可选）即可，故有C(1,9)*C(2, 3)*C(1, 8)=216种可能。
总共：216+216=432
例2:工程师M发明了一种游戏：M将一个小球随机放入完全相同的三个盒子中的某一个，玩家选中装有球的盒子即获胜；开始时M会让玩家选择一个盒子（选择任何一个获胜概率均为1/3）;玩家做出选择后，M会打开没有被选择的两个盒子中的一个空盒，此时M会询问玩家是否更改选择（可以坚持第一次选择，也可以选择另一个没有打开的盒子），下列叙述正确的有（E）。
A.改选后，玩家获胜的概率还是1/3
B.若不改选，玩家的获胜概率是1/2
C.无论怎么选择，获胜的概率都是1/2
D.坚持原来的选择获胜概率更高
E.选择另一个没有被打开的盒子获胜概率更高
F.获胜概率取决于随机因素（如小球的实际位置）
解析：
三个盒子A，B，C。其中，1表示有球，0表示没球。
选取三个盒子概率都一样。我们假设选择了A。
此时有三种情况如下所示：
情况一：我选中了有球的盒子，我更换的话将失败，不更换的话将成功。
情况二：我选中了没球的盒子，我更换的话将成功，不更换的话将失败。
情况三：我选中了没球的盒子，我更换的话将成功，不更换的话将失败。
综上，我们发现更换了成功的概率是2/3；二不更换成功的概率是1/3。
因此选择E。
例3:下列不是进程间的通信方式的是（B）
A.管道 B.回调 C.共享内存 D.消息队列 E.socket F.信号量
解析：
管道：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。
回调： 是一种编程机制
共享内存：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号量，配合使用，来实现进程间的同步和通信。
消息队列：消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。
socket：socket也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同及其间的进程通信。
信号量:信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。
例4:已知IBM的PowerPC是big-endian字节序列而Intel的X86是little-endian字节序，如果在地址啊存储的整形值时0x04030201，那么地址为a+3的字节内存储的值在PowerPC和Intel X86结构下的值分别是？（A）
A.1 4 B.1 3 C.4 1 D.3 1 E.4 4 F.1 1
解析：大端从大地址开始存储，小端相反，两者都是从数据低位开始存起； 假设从上至下地址递增，则
PowerPC（大）： Intel X86（小）：
04 01 低
03 02
02 03
01 04 高
a+3指向最大的地址，所以分别为1 4
例5:在TCP/IP建立连接过程中，客户端或服务器的状态转移说法错误的是？(D)
A.经历SYN_RECV状态
B.经历SYN_SEND状态
C.经历ESTABLISHED状态
D.经历TIME_WAIT状态
E.服务器在收到syn包时将加入半连接队列
F.服务器收到客户端的ack包后将从半连接队列删除
解析：TIME_WAIT是断开连接时的状态（属于第四次握手）
例6:已知一棵二叉树的先序和中序遍历序列如下：先序：A、B、C、D、E、F、G、H、I，J中序：C、B、A、E、F、D、I、H、J、G其后序遍历序列为：(E)
A.C、B、D、E、A、G、I、H、J、F
B.C、B、D、A、E、G、I、H、J、F
C.C、E、D、B、I、J、H、G、F、A
D.C、E、D、B、I、H、J、G、F、A
E.C、B、F、E、I、J、H、G、D、A
F.C、B、F、E、I、H、J、G、D、A
参考：
https://blog.csdn.net/Cassiel_Paris/article/details/80203633
https://www.cnblogs.com/chongerlishan/p/5971024.html