从算法到实现

A. 算法工程师要学什么

所谓算法工程师，首先需要是一名工程师，那么就要掌握所有开发工程师都需要掌握的一些能力。有些新手对于这一点存在一些误解，认为所谓算法工程师就只需要思考和设计算法，不用在乎这些算法如何实现，而且会有人帮你来实现你想出来的算法方案。这种思想是错误的，在大多数企业的大多数职位中，算法工程师需要负责从算法设计到算法实现再到算法上线这一个全流程的工作。所以作为一个算法工程师，首先要会编程，你的编程语言一定要熟练掌握。当你熟练掌握编程语言以后，还要认真研究机器学习理论以及概率与数理统计方面的知识。慢慢进阶到架构设计以后，你才向算法工程师迈出了坚实的一步。

B. CRC算法，从原理到实现

CRC，一种基于有限域GF(2)的多项式环的Hash算法。在GF(2)中，多项式系数只有0、1，加减运算等同于异或(XOR)运算，乘除运算与一般多项式运算一致（合并同类项时需要注意为XOR运算）

在GF(2)中，多项式系数只有0、1，加减运算等同于异或(XOR)运算，乘除运算与一般多项式运算一致（合并同类项时需要注意为XOR运算）。在CRC-n算法中，有M(x)·x ⁿ =Q(x)·G(x)+R(x)，M(x)为m位的数据，G(x)为一个GF(2)的n+1项的生成多项式(Poly)，M(x)·x ⁿ 则是通过在数据M(x)后添加n个0形成的对应的m+n位多项式，而R(x)即为M(x)·x ⁿ 除以G(x)的n位余数——即CRC校验码，Q(x)为商，直接丢弃。通过比较两次计算产生的Signature是否一致判断故障的发生

假定M(x)=11100110，G(x)=x ³ + x + 1，其中n=3，则M(x)·x ⁿ =11100110000，将G(x)多项式中的各项系数取出，按降幂排列所对应的数据Poly=1011，然后对其进行除法运算：

所得n位余数即为CRC——100

根据定义可以建立一个简单的CRC实现算法，模型如下图所示：
1)建立一个长度为r的CRC Register，并初始化为0
2)在M(x)后添加r个0形成M(x)·x ⁿ
3)将CRC Register左移一位，将M(x)·x ⁿ 的MSB移入CRC Register的Bit 0
4)第3步中的从CRC Register移出的数，如果是1，则计算，CRC Register=Poly XOR CRC Register
5)重复第3步，直到M(x)·x ⁿ 全部移入CRC Register
6)CRC Register即为CRC校验值

根据定义所建立的算法模型存在明显缺陷，按位移动处理效率低下，为此我们探索如何实现更大处理单元的算法。这次我们以CRC-32为例，按照前面的算法思路构建的模型如下图所示：

设CRC Register中的Byte 3依次为：t7 t6 t5 t4 t3 t2 t1 t0，Poly中的Bit31-Bit24依次为：g7 g6 g5 g4 g3 g2 g1 g0，根据1.3.2可知，在第1次迭代中，CRC Register的MSB:t7将会决定Poly与CRC Register的异或，如果t7=1，这就会发生，反之就不会发生;在第2次迭代中，CRC Register的MSB:t6 XOR (t7*g7) 将会决定本次Poly与CRC Register的异或是否发生，即t7、t6控制第2XOR操作；同理，在第3次迭代中，CRC Register的MSB也是通过t7、t6、t5决定，即t7、t6、t5控制第3次XOR操作。故我们可以得出下述结论：k次以后的迭代的最高位的值，可以由寄存器的前k位计算得到。根据这个结论，我们可以一次性取出CRC Register的Byte 3，提前计算出8次迭代后的寄存器余式，因为高位终将会在迭代中被移出，我们只需要关心余式即可。同时XOR运算满足结合律：A XOR B XOR C = A XOR (B XOR C)

上图即为Byte 3全部迭代移出的示意图，根据结合律可以看出，我们可以依据Byte 3直接确定8次异或的与否及Poly的偏移量，从而提前计算出不同偏移量的Poly间XOR的值，令其为A，易知A的高8位和Byte 3一定相等，Reg向左移出btye3，从M(x)·x ⁿ 读取一个byte放在byte 0，最后将A的低32位与Reg完成XOR操作。为避免与字节边界发生冲突，我们采用字节的整数倍——字节（1 byte）、字（2 byte）、双字（4 byte），故一般不采用4bit作为处理单元。由于一个字节的取值是有限的——256种，我们只要提前计算一个字节全部的A值保存到表中。运行时以byte值为索引，直接从表里取出即可

至此我们完成基于1 byte为处理单元的Table Driven，算法模型如下图所示：
1)建立一个长度为r的CRC Register，并初始化为0
2)在M(x)后添加r个0形成M(x)·x ⁿ
3)将CRC Register左移一个byte，从M(x)·x ⁿ 读入一个byte至CRC Register的byte 0中
4)以第3步中的从CRC Register移出的byte为index，从表中取出对应的n位宽的值，将该值与CRC Register进行XOR
5)重复第3步，直到M(x)·x ⁿ 全部移入CRC Register6) CRC Register即为CRC校验值

在上述的两种算法中，我们每次都需要在M(x)后添加n个0，其并不参与运算，目的只是为了将M(x)的全部推入CRC Register而已，并且在有些情境下在M(x)后添0操作并不总是能够实现的，故通过改进计算步骤有了直接表法，避免了对原始数据的添0操作
算法流程，算法模型如下图所示：
1)建立一个长度为r的CRC Register，按照Init值对其初始化
2)将CRC Register左移一个byte，从M(x)左移一个byte，两者进行XOR
3)第2步中XOR后的值作为index，从表中取出对应的n位宽的值，将该值与CRC Register进行XOR
4)重复第2步，直到M(x)全部取出
5)CRC Register即为CRC校验值

在Direct Table算法中，当RefIn、RefOut为True，每次都需要对数据做颠倒操作，很麻烦。为此产生了Reflected Direct Table算法，该算法改变了CRC Register的移动方向，而不需要对M(x)做任何处理，按字节顺序读取即可，算法模型如下图所示

算法流程如下：
1)建立一个长度为r的CRC Register，按照Init值对其初始化
2)将CRC Register右移一个byte，从M(x)左移一个byte，两者进行XOR
3)第2步中XOR后的值作为index，从表中取出对应的n位宽的值，将该值与CRC Register进行XOR
4)重复第2步，直到M(x)全部取出
5)CRC Register即为CRC校验值

Name: CRC标准

Width: 生成的CRC的位宽

Poly: 生成多项式，一般采用十六进制简记，长度为width+1，由于其最高位恒为1，故记法中不体现出来（例如：x ¹⁶ +x ¹² +x ⁵ +1记为0x1021）

Init: 初始值，如果数据前添加了若干个前导零，在前述算法中，一般是检测不到的，故通过改变CRC Register中的预设值，以实现对该类型错误的检测。在Direct Table算法中用Init初始化CRC Register即可，在Table Driven算法中，不可以直接用Init初始化CRC Register，因为其等同于在原始数据前插入了Init，必须要先把CRC Register设为0，等M(x)·x ⁿ 移动n/8次后，即CRC Register的预设值0全部移出时，再将Init值异或进CRC Register。完成Init操作

Xorout: 结果异或值，所有计算完成后将CRC Register与Xorout进行异或作，作为最后的校验值

RefIn: 输入反转，这是一个布尔值，如果为False，则每个字节内的位顺序保持不变，即Bit 7为MSB，Bit0为LSB。如果为True，则将需要每个字节内的位顺序颠倒，即Bit 7为LSB，Bit0为MSB。这个约定在硬件CRC中是合理的，因为在串口通讯中硬件一般默认先发送字节的Bit 0，最后发送Bit 7

RefOut: 输出反转，这是一个布尔值，如果为False，则在计算结束后，直接进入Xorout环节，如果为True，则在计算结束后，将CRC Register进行颠倒后，再进入Xorout环节。注意，和RefIn颠倒字节内的位顺序不同的是，这个是将CRC Register的值作为一个整体颠倒，即Bit n到Bit0进行颠倒

针对常见常用的下述CRC给出了实现方法，以供参考

C. 哲学家进餐问题的算法与实现

1．哲学家进餐问题：
(1) 在什么情况下5 个哲学家全部吃不上饭考虑两种实现的方式，如下：
A. 算法描述： void philosopher(int i) /*i：哲学家编号，从0 到4*/ {while (TRUE) { think( ); /*哲学家正在思考*/ take_fork(i); /*取左侧的筷子*/ take_fork((i+1) % N); /*取左侧筷子；％为取模运算*/eat( ); /*吃饭*/put_fork(i); /*把左侧筷子放回桌子*/ put_fork((i+1) % N); /*把右侧筷子放回桌子*/ } } 分析：假如所有的哲学家都同时拿起左侧筷子，看到右侧筷子不可用，又都放下左侧筷子，等一会儿，又同时拿起左侧筷子，如此这般，永远重复。对于这种情况，即所有的程序都在无限期地运行，但是都无法取得任何进展，即出现饥饿，所有哲学家都吃不上饭。
B．算法描述：规定在拿到左侧的筷子后，先检查右面的筷子是否可用。如果不可用，则先放下左侧筷子，等一段时间再重复整个过程。分析：当出现以下情形，在某一个瞬间，所有的哲学家都同时启动这个算法，拿起左侧的筷子，而看到右侧筷子不可用，又都放下左侧筷子，等一会儿，又同时拿起左侧筷子……如此这样永远重复下去。对于这种情况，所有的程序都在运行，但却无法取得进展，即出现饥饿，所有的哲学家都吃不上饭。
(2) 描述一种没有人饿死（永远拿不到筷子）算法。考虑了四种实现的方式（A、B、C、D）：
A．原理：至多只允许四个哲学家同时进餐,以保证至少有一个哲学家能够进餐,最终总会释放出他所使用过的两支筷子,从而可使更多的哲学家进餐。以下将room 作为信号量，只允许4 个哲学家同时进入餐厅就餐，这样就能保证至少有一个哲学家可以就餐，而申请进入餐厅的哲学家进入room 的等待队列，根据FIFO 的原则，总会进入到餐厅就餐，因此不会出现饿死和死锁的现象。
伪码： semaphore chopstick[5]={1，1，1，1，1}; semaphore room=4; void philosopher(int i) { while(true) {think(); wait(room); //请求进入房间进餐 wait(chopstick[i]); //请求左手边的筷子 wait(chopstick[(i+1)%5]); //请求右手边的筷子 eat(); signal(chopstick[(i+1)%5]); //释放右手边的筷子 signal(chopstick[i]); //释放左手边的筷子 signal(room); //退出房间释放信号量room } }
B．原理：仅当哲学家的左右两支筷子都可用时,才允许他拿起筷子进餐。
方法1：利用AND 型信号量机制实现：根据课程讲述，在一个原语中，将一段代码同时需要的多个临界资源，要么全部分配给它，要么一个都不分配，因此不会出现死锁的情形。当某些资源不够时阻塞调用进程;由于等待队列的存在，使得对资源的请求满足FIFO 的要求，因此不会出现饥饿的情形。
伪码： semaphore chopstick[5]={1，1，1，1，1}; void philosopher(int I) { while(true) { think();Swait(chopstick[(I+1)]%5,chopstick[I]); eat(); Ssignal(chopstick[(I+1)]%5,chopstick[I]);} } 方法2：利用信号量的保护机制实现。通过信号量mutex对eat（）之前的取左侧和右侧筷子的操作进行保护，使之成为一个原子操作，这样可以防止死锁的出现。伪码： semaphore mutex = 1 ; semaphorechopstick[5]={1，1，1，1，1};void philosopher(int I) { while(true) { think(); wait(mutex);wait(chopstick[(I+1)]%5); wait(chopstick[I]); signal(mutex); eat();signal(chopstick[(I+1)]%5); signal(chopstick[I]); } }
C．原理：规定奇数号的哲学家先拿起他左边的筷子,然后再去拿他右边的筷子;而偶数号的哲学家则相反.按此规定,将是1,2号哲学家竞争1号筷子,3,4号哲学家竞争3号筷子.即五个哲学家都竞争奇数号筷子,获得后,再去竞争偶数号筷子,最后总会有一个哲学家能获得两支筷子而进餐。而申请不到的哲学家进入阻塞等待队列，根FIFO原则，则先申请的哲学家会较先可以吃饭，因此不会出现饿死的哲学家。
伪码： semaphore chopstick[5]={1，1，1，1，1}; void philosopher(int i) { while(true) { think(); if(i%2== 0) //偶数哲学家，先右后左。 { wait (chopstick[ i + 1 ] mod 5) ; wait (chopstick[ i]) ;eat(); signal (chopstick[ i + 1 ] mod 5) ; signal (chopstick[ i]) ; } Else //奇数哲学家，先左后右。 { wait (chopstick[ i]) ; wait (chopstick[ i +1 ] mod 5) ; eat(); signal (chopstick[ i]) ; signal (chopstick[ i + 1 ] mod 5); } }
D．利用管程机制实现（最终该实现是失败的，见以下分析）：原理：不是对每只筷子设置信号量，而是对每个哲学家设置信号量。test()函数有以下作用：
a. 如果当前处理的哲学家处于饥饿状态且两侧哲学家不在吃饭状态，则当前哲学家通过 test()函数试图进入吃饭状态。
b. 如果通过test()进入吃饭状态不成功，那么当前哲学家就在该信号量阻塞等待，直到其他的哲学家进程通过test()将该哲学家的状态设置为EATING。
c. 当一个哲学家进程调用put_forks()放下筷子的时候，会通过test()测试它的邻居，如果邻居处于饥饿状态，且该邻居的邻居不在吃饭状态，则该邻居进入吃饭状态。由上所述,该算法不会出现死锁，因为一个哲学家只有在两个邻座都不在进餐时，才允许转换到进餐状态。该算法会出现某个哲学家适终无法吃饭的情况，即当该哲学家的左右两个哲学家交替处在吃饭的状态的时候，则该哲学家始终无法进入吃饭的状态，因此不满足题目的要求。但是该算法能够实现对于任意多位哲学家的情况都能获得最大的并行度，因此具有重要的意义。
伪码：#define N 5 /* 哲学家人数*/#define LEFT (i-1+N)%N /* i的左邻号码 */ #define RIGHT (i+1)%N /* i的右邻号码 */ typedef enum { THINKING, HUNGRY, EATING } phil_state; /*哲学家状态*/ monitor dp /*管程*/ { phil_state state[N]; semaphore mutex =1; semaphore s[N];/*每个哲学家一个信号量，初始值为0*/void test(int i) { if ( state[i] == HUNGRY &&state[LEFT(i)] != EATING&& state[RIGHT(i)] != EATING ) { state[i] = EATING; V(s[i]); } } void get_forks(inti) { P(mutex); state[i] = HUNGRY; test(i); /*试图得到两支筷子*/ V(mutex); P(s[i]); /*得不到筷子则阻塞*/ } void put_forks(int i) { P(mutex); state[i]= THINKING;test(LEFT(i)); /*看左邻是否进餐*/ test(RIGHT(i)); /*看右邻是否进餐*/ V(mutex); } } 哲学家进程如下： void philosopher(int process) { while(true) { think();get_forks(process); eat(); put_forks(process); } }
2.理发师问题：一个理发店有一个入口和一个出口。理发店内有一个可站5 位顾客的站席区、4 个单人沙发、3 个理发师及其专用理发工具、一个收银台。新来的顾客坐在沙发上等待；没有空沙发时，可在站席区等待；站席区满时，只能在入口外等待。理发师可从事理发、收银和休息三种活动。
理发店的活动满足下列条件：
1）休息的理发师是坐地自己专用的理发椅上，不会占用顾客的沙发；
2）处理休息状态的理发师可为在沙发上等待时间最长的顾客理发；
3）理发时间长短由理发师决定；
4）在站席区等待时间最长的顾客可坐到空闲的理发上；
5）任何时刻最多只能有一个理发师在收银。试用信号量机制或管程机制实现理发师进程和顾客进程。
原理：
(1) customer 进程：首先检查站席区是否已满（stand_capacity）,若满选择离开，否则进入站席区，即进入理发店。在站席区等待沙发的空位（信号量sofa），如果沙发已满，则进入阻塞等待队列，直到出现空位，在站席区中等待时间最长的顾客离开站席区（stand_capacity）。坐到沙发上，等待理发椅(barber_chair)，如果理发椅已满，则进入阻塞等待队列，直到出现空位，在沙发上等待时间最长的顾客离开沙发（释放信号量sofa）。坐到理发椅上，释放准备好的信号（customer_ready），获得该理发师的编号（0~1 的数字）。等待理发师理发结束（finished[barber_number]）。在离开理发椅之前付款（payment），等待收据 (receipt)，离开理发椅（leave_barberchair）。最后离开理发店。
这里需要注意几点：
a) 首先是几个需要进行互斥处理的地方，主要包括:进入站席区、进入沙发、进入理发椅和付款几个地方。
b) 通过barber_chair保证一个理发椅上最多只有一名顾客。但这也不够，因为单凭 baber_chair 无法保证一名顾客离开理发椅之前，另一位顾客不会坐到该理发椅上，因此增加信号量leave_barberchair，让顾客离开理发椅后，释放该信号，而理发师接收到该信号后才释放barber_chair 等待下一位顾客。
c) 在理发的过程中，需要保证是自己理发完毕，才能够进行下面的付款、离开理发椅的活动。这个机制是通过customer 进程获得给他理发的理发师编号来实现的，这样，当该编号的理发师释放对应的finished[i]信号的时候，该顾客才理发完毕。
d) 理发师是通过mutex 信号量保证他们每个人同时只进行一项操作（理发或者收款）。
e) 为了保证该顾客理发完毕后马上可以付款离开，就应该保证给该顾客理发的理发师在理发完毕后马上到收银台进入收款操作而不是给下一位顾客服务。在伪码中由以下机制实现：即顾客在释放离开理发椅的信号前，发出付款的信号。这样该理发师得不到顾客的离开理发椅的信号，不能进入下一个循环为下一名顾客服务，而只能进入收款台的收款操作。直到顾客接到收据后，才释放离开理发椅的信号，离开理发椅，让理发师释放该理发椅的信号，让下一位等待的顾客坐到理发椅上。
(2)barber 进程首先将该理发师的编号压入队列，供顾客提取。等待顾客坐到理发椅坐好(信号量 customer_ready)，开始理发，理发结束后释放结束信号（finished[i]）。等待顾客离开理发椅（leave_barberchair）（期间去收银台进行收款活动），释放理发椅空闲信号(barber_chair)，等待下一位顾客坐上来。
(3)cash（收银台）进程等待顾客付款(payment),执行收款操作，收款操作结束，给付收据（receipt）。信号量总表：信号量 waitsignal stand_capacity 顾客等待进入理发店顾客离开站席区 sofa 顾客等待坐到沙发顾客离开沙发 barber_chair 顾客等待空理发椅理发师释放空理发椅 customer_ready 理发师等待，直到一个顾客坐到理发椅顾客坐到理发椅上，给理发师发出信号 mutex 等待理发师空闲，执行理发或收款操作理发师执行理发或收款结束，进入空闲状态 mutex1执行入队或出队等待入队或出队结束，释放信号 finished[i] 顾客等待对应编号理发师理发结束理发师理发结束，释放信号 leave_barberchair 理发师等待顾客离开理发椅顾客付款完毕得到收据，离开理发椅释放信号 payment 收银员等待顾客付款顾客付款，发出信号 receipt 顾客等待收银员收、开具收据收银员收款结束、开具收据，释放信号
伪码： semaphore stand_capacity=5; semaphore sofa=4; semaphorebarber_chair=3; semaphore customer_ready=0; semaphore mutex=3; semaphoremutex1=1; semaphore finished[3]={0,0,0}; semaphore leave_barberchair=0;semaphore payment=0; semaphore receipt=0; void customer() { int barber_number;wait(stand_capacity); //等待进入理发店 enter_room(); //进入理发店 wait(sofa); //等待沙发 leave_stand_section(); //离开站席区 signal(stand_capacity); sit_on_sofa(); //坐在沙发上 wait(barber_chair); //等待理发椅 get_up_sofa(); //离开沙发 signal(sofa); wait(mutex1);sit_on_barberchair(); //坐到理发椅上 signal(customer_ready); barber_number=dequeue(); //得到理发师编号 signal(mutex1); wait(finished[barber_number]);//等待理发结束 pay(); //付款 signal(payment); //付款 wait(receipt); //等待收据 get_up_barberchair(); //离开理发椅 signal(leave_barberchair); //发出离开理发椅信号 exit_shop(); //了离开理发店 } void barber(int i) { while(true) { wait(mutex1);enqueue(i); //将该理发师的编号加入队列 signal(mutex1); wait(customer_ready); //等待顾客准备好 wait(mutex); cut_hair(); //理发 signal(mutex); signal(finished[i]); //理发结束 wait(leave_barberchair); //等待顾客离开理发椅信号 signal(barber_chair); //释放barber_chair 信号 } } void cash() //收银 { while(true) { wait(payment); //等待顾客付款 wait(mutex); //原子操作 get_pay(); //接受付款 give_receipt(); //给顾客收据 signal(mutex); signal(receipt); //收银完毕，释放信号 } }
分析：在分析该问题过程中，出现若干问题，是参阅相关资料后才认识到这些问题的隐蔽性和严重性的,主要包括：
（1）在顾客进程，如果是在释放leave_barberchair 信号之后进行付款动作的话，很容易造成没有收银员为其收款的情形，原因是：为该顾客理发的理发师收到 leave_barberchair 信号后，释放barber_chair 信号，另外一名顾客坐到理发椅上，该理发师有可能为这另外一名顾客理发，而没有为刚理完发的顾客收款。为解决这个问题，就是采取在释放leave_barberchair 信号之前，完成付款操作。这样该理发师无法进入下一轮循环为另外顾客服务，只能到收银台收款。
（2）本算法是通过给理发师编号的方式，当顾客坐到某理发椅上也同时获得理发师的编号，如此，当该理发师理发结束，释放信号，顾客只有接收到为其理发的理发师的理发结束信号才会进行付款等操作。这样实现，是为避免这样的错误，即：如果仅用一个finished 信号量的话，很容易出现别的理发师理发完毕释放了finished 信号，把正在理发的这位顾客赶去付款,而已经理完发的顾客却被阻塞在理发椅上的情形。当然也可以为顾客进行编号，让理发师获取他理发的顾客的编号，但这样就会限制顾客的数量，因为finished[] 数组不能是无限的。而为理发师编号，则只需要三个元素即可。

D. 算法设计与程序实现:java,100元的具体划分方案,可选面值有1元,10元,20元,50元,100元.

for( int a=0,loopCountA=100/100; a<=loopCountA; a++ )
for( int b=0,loopCountB=(100-a*100)/50; b<=loopCountB; b++ )
for( int c=0,loopCountC=(100-a*100-b*50)/20; c<=loopCountC; c++ )
for( int d=0,loopCountD=(100-a*100-b*50-c*20)/10; d<=loopCountD; d++ )
for( int e=0,loopCountE=(100-a*100-b*50-c*20-d*10)/1; e<=loopCountE; e+=10 )
if( (a*100+b*50+c*20+d*10+e)==100 )
System.out.println("1元："+e+"张；10元："+d+"张；20元："+c+"张；50元："+b+"张；100元："+a+"张。");

改进了下，速度快了一些。

E. 普里姆算法的普里姆算法的实现

为了便于在两个顶点集U和V-U之间选择权最小的边，建立了两个辅助数组closest和lowcost，它们记录从U到V-U具有最小权值的边，对于某个j∈V-U，closest[j]存储该边依附的在U中的顶点编号，lowcost[j]存储该边的权值。
为了方便，假设图G采用邻接矩阵g存储，对应的Prim(g,v)算法如下：
void Prim(MatGraph g,int v) //输出求得的最小生树的所有边
{ int lowcost[MAXVEX]; //建立数组lowcost
int closest[MAXVEX]; //建立数组closest
int min,i,j,k;
for (i=0;i<g.n;i++) //给lowcost[]和closest[]置初值
{ lowcost[i]=g.edges[v][i];
closest[i]=v;
}
for (i=1;i<g.n;i++) //构造n-1条边
{ min=INF; k=-1;
for (j=0;j<g.n;j++) //在(V-U)中找出离U最近的顶点k
if (lowcost[j]!=0 && lowcost[j]<min)
{ min=lowcost[j];
k=j; //k为最近顶点的编号
}
printf( 边(%d,%d),权值为%d ,closest[k],k,min);
lowcost[k]=0; //标记k已经加入U
for (j=0;j<g.n;j++) //修正数组lowcost和closest
if (g.edges[k][j]!=0 && g.edges[k][j]<lowcost[j])
{ lowcost[j]=g.edges[k][j];
closest[j]=k;
}
}
}
普里姆算法中有两重for循环，所以时间复杂度为O(n2)，其中n为图的顶点个数。由于与e无关，所以普里姆算法特别适合于稠密图求最小生成树。

F. 最优化原理的算法实现

动态规划的主要难点在于理论上的设计，也就是上面4个步骤的确定，一旦设计完成，实现部分就会非常简单。使用动态规划求解问题，最重要的就是确定动态规划三要素：问题的阶段,每个阶段的状态以及从前一个阶段转化到后一个阶段之间的递推关系。递推关系必须是从次小的问题开始到较大的问题之间的转化，从这个角度来说，动态规划往往可以用递归程序来实现，不过因为递推可以充分利用前面保存的子问题的解来减少重复计算，所以对于大规模问题来说，有递归不可比拟的优势，这也是动态规划算法的核心之处。确定了动态规划的这三要素，整个求解过程就可以用一个最优决策表来描述，最优决策表示一个二维表，其中行表示决策的阶段，列表示问题状态，表格需要填写的数据一般对应此问题的在某个阶段某个状态下的最优值（如最短路径，最长公共子序列，最大价值等），填表的过程就是根据递推关系，从1行1列开始，以行或者列优先的顺序，依次填写表格，最后根据整个表格的数据通过简单的取舍或者运算求得问题的最优解。下面分别以求解最大化投资回报问题和最长公共子序列问题为例阐述用动态规划算法求解问题的一般思路。
实例：
最大化投资回报问题
某人有一定的资金用来购买不同面额的债卷，不同面额债卷的年收益是不同的，求给定资金，年限以及债卷面额、收益的情况下怎样购买才能使此人获得最大投资回报。
程序输入约定：第一行第一列表示资金（1000的倍数）总量，第二列表示投资年限；第二行表示债卷面额总数；从第三行开始每行表示一种债卷，占用两列，前一列表示债卷面额，后一列表示其年收益，如下输入实例，
10000 1
2
4000 400
3000 250
程序实现如下，注释几乎说明了一切，所以不再另外分析。
/// 此数组是算法的关键存储结构，用来存储不同阶段各种债卷
/// 组合下对应可获取的最大利息。
int saifa[80005];
/// 此函数用于计算当前债卷在不同购买额下的最优利息情况，
/// 注意此时的利息情况是基于上一次债卷的情况下计算得到的，
/// 也就是说当前利息最优是基于上一次利息最优的基础上计算出来的，
/// 这也正好体现了动态规划中“最优化原则”：不管前面的策略如何，
/// 此后的决策必须是基于当前状态（由上一次决策产生）的最优决策。
/*
动态规划的求解过程一般都可以用一个最优决策表来描述，
对于本程序，以示例输入为例，对于第一年，其最优决策表如下：
0 1 2 3 4 5 6 7 8 9 10(*1000) -- (1)
0 0 0 0 400 400 400 400 800 800 800 -- (2)
0 0 0 250 400 400 500 650 800 900900 -- (3)
(1) -- 表示首先选利息为400的债卷在对应资金下的最优利息。
(2) -- 表示可用来购买债卷的资金。
(3) -- 表示在已有状态下再选择利息为300的债卷在对应资金下的最优利息。
注意上面表格，在求购买利息为300的债卷获得的最优收益的时候，
参考了以前的最优状态，以3行8列的650为例，7(*1000)可以
在以前购买了0张4000的债卷的基础上再2张3000的，也可以在以前购
买了1张4000的基础上再买1张3000，经比较取其收益大的，这就是典
型的动态规划中的当前最优状态计算。
本程序中把上面的最优决策二维表用一个一维数组表示，值得借鉴。
*/
void add(int a,int b)
{
cout << a << << b << endl; // for debug
for(int i=0;i<=80000;i++)
{
if(i+a > 80000)
{
break;
}
if(saifa[i]+b > saifa[i+a]) // 累计同时购买多种债卷时的利息
{
saifa[i+a] = saifa[i] + b;
}
if(i<200) // for debug
cout << i << -<< saifa[i] << ;
}
cout << endl; // for debug
}
int main(void)
{
int n,d,money,year,pay,bond;
int ii,i;
scanf(%d,&n);
for(ii=0;ii<n;ii++)
{
memset(saifa,0,sizeof(saifa));
scanf(%d%d,&money,&year);
scanf(%d,&d);
for(i=0;i<d;i++)
{
scanf(%d%d,&pay,&bond);
add(pay/1000,bond);
}
// 计算指定年限内最优组合的本金利息总额
for(i=0;i<year;i++)
{
cout << saifa[money/1000]<< ; // for debug
money += saifa[money/1000];
}
cout << endl; // for debug
printf(%d ,money);
}
return 0;
}
上述程序实现方法同样适合于背包问题，最优库存问题等，只是针对具体情况，最优决策表的表示和生成会有所不同。

G. “算法时代”到来，为何算法服务人类并未被实现

一开始算法只是服务于人类的，但随着网络的发达以及智能地推广，人们惊讶的发现自己正在慢慢依赖算法乃至无法失去它。

好像在上世纪90年代当计算机深蓝赢了大师之后，当时就有人提出智能电脑也许终究有一天将主导人类。而它的初衷只是发明出来，帮助人们生活在一个更加便利的环境下，人是主导它，或者说控制它的，它被发明出来也只是服务于人类的，但是随着时间的推移会逐渐发现当它被赋予了的各种算法以及不断更新之后，开始会学习了，它产生的某种意义上的主导性，而这一点可能会将人类摆在一个尴尬的位置，因为人类将无法完全操控它。

久而久之的这种算法让人们变得越来越懒惰了，人们不愿去自主思考，因为智能设备会推送给人类精准的信息，这些信息就是人类所需要的，它们已经自动排除了人类所不感兴趣的无用信息了。

H. crc算法在单片机上的实现

CRC算法原理及C语言实现

摘 要 本文从理论上推导出CRC算法实现原理,给出三种分别适应不同计算机或微控制器硬件环境的C语言程序。读者更能根据本算法原理,用不同的语言编写出独特风格更加实用的CRC计算程序。
关键词 CRC 算法 C语言
1 引言
循环冗余码CRC检验技术广泛应用于测控及通信领域。CRC计算可以靠专用的硬件来实现,但是对于低成本的微控制器系统,在没有硬件支持下实现CRC检验,关键的问题就是如何通过软件来完成CRC计算,也就是CRC算法的问题。
这里将提供三种算法,它们稍有不同,一种适用于程序空间十分苛刻但CRC计算速度要求不高的微控制器系统,另一种适用于程序空间较大且CRC计算速度要求较高的计算机或微控制器系统,最后一种是适用于程序空间不太大,且CRC计算速度又不可以太慢的微控制器系统。
2 CRC简介
CRC校验的基本思想是利用线性编码理论,在发送端根据要传送的k位二进制码序列,以一定的规则产生一个校验用的监督码（既CRC码）r位,并附在信息后边,构成一个新的二进制码序列数共(k+r)位,最后发送出去。在接收端,则根据信息码和CRC码之间所遵循的规则进行检验,以确定传送中是否出错。
16位的CRC码产生的规则是先将要发送的二进制序列数左移16位（既乘以 ）后,再除以一个多项式,最后所得到的余数既是CRC码,如式（2-1）式所示,其中B(X)表示n位的二进制序列数,G(X)为多项式,Q(X)为整数,R(X)是余数（既CRC码）。
（2-1）
求CRC码所采用模2加减运算法则,既是不带进位和借位的按位加减,这种加减运算实际上就是逻辑上的异或运算,加法和减法等价,乘法和除法运算与普通代数式的乘除法运算是一样,符合同样的规律。生成CRC码的多项式如下,其中CRC-16和CRC-CCITT产生16位的CRC码,而CRC-32则产生的是32位的CRC码。本文不讨论32位的CRC算法,有兴趣的朋友可以根据本文的思路自己去推导计算方法。
CRC-16：（美国二进制同步系统中采用）
CRC-CCITT：（由欧洲CCITT推荐）
CRC-32：

接收方将接收到的二进制序列数（包括信息码和CRC码）除以多项式,如果余数为0,则说明传输中无错误发生,否则说明传输有误,关于其原理这里不再多述。用软件计算CRC码时,接收方可以将接收到的信息码求CRC码,比较结果和接收到的CRC码是否相同。

3 按位计算CRC
对于一个二进制序列数可以表示为式(3-1):
(3-1)
求此二进制序列数的CRC码时,先乘以 后（既左移16位）,再除以多项式G(X),所得的余数既是所要求的CRC码。如式(3-2)所示：
(3-2)
可以设： (3-3)
其中 为整数, 为16位二进制余数。将式(3-3)代入式(3-2)得：

(3-4)
再设： (3-5)
其中 为整数, 为16位二进制余数,将式(3-5)代入式(3-4),如上类推,最后得到：
(3-6)
根据CRC的定义,很显然,十六位二进制数 既是我们要求的CRC码。
式(3-5)是编程计算CRC的关键,它说明计算本位后的CRC码等于上一位CRC码乘以2后除以多项式,所得的余数再加上本位值除以多项式所得的余数。由此不难理解下面求CRC码的C语言程序。*ptr指向发送缓冲区的首字节,len是要发送的总字节数,0x1021与多项式有关。
unsigned int cal_crc(unsigned char *ptr, unsigned char len) {
unsigned char i;
unsigned int crc=0;
while(len--!=0) {
for(i=0x80; i!=0; i/=2) {
if((crc&;0x8000)!=0) {crc*=2; crc^=0x1021;} /* 余式CRC乘以2再求CRC */
else crc*=2;
if((*ptr&;i)!=0) crc^=0x1021; /* 再加上本位的CRC */
}
ptr++;
}
return(crc);
}
按位计算CRC虽然代码简单,所占用的内存比较少,但其最大的缺点就是一位一位地计算会占用很多的处理器处理时间,尤其在高速通讯的场合,这个缺点更是不可容忍。因此下面再介绍一种按字节查表快速计算CRC的方法。
4 按字节计算CRC
不难理解,对于一个二进制序列数可以按字节表示为式(4-1),其中 为一个字节(共8位)。
(4-1)
求此二进制序列数的CRC码时,先乘以 后（既左移16位）,再除以多项式G(X),所得的余数既是所要求的CRC码。如式(4-2)所示：
（4-2）
可以设： (4-3)
其中 为整数, 为16位二进制余数。将式(4-3)代入式(4-2)得：
（4-4）
因为：
（4-5）
其中 是 的高八位, 是 的低八位。将式（4-5）代入式（4-4）,经整理后得：
（4-6）
再设： (4-7)
其中 为整数, 为16位二进制余数。将式(4-7)代入式(4-6),如上类推,最后得：
(4-8)
很显然,十六位二进制数 既是我们要求的CRC码。
式(4-7)是编写按字节计算CRC程序的关键,它说明计算本字节后的CRC码等于上一字节余式CRC码的低8位左移8位后,再加上上一字节CRC右移8位（也既取高8位）和本字节之和后所求得的CRC码,如果我们把8位二进制序列数的CRC全部计算出来,放如一个表里,采用查表法,可以大大提高计算速度。由此不难理解下面按字节求CRC码的C语言程序。*ptr指向发送缓冲区的首字节,len是要发送的总字节数,CRC余式表是按0x11021多项式求出的。
unsigned int cal_crc(unsigned char *ptr, unsigned char len) {
unsigned int crc;
unsigned char da;
unsigned int crc_ta[256]={ /* CRC余式表 */
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
0x 1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
};

crc=0;
while(len--!=0) {
da=(uchar) (crc/256); /* 以8位二进制数的形式暂存CRC的高8位 */
crc<<=8; /* 左移8位,相当于CRC的低8位乘以 */
crc^=crc_ta[da^*ptr]; /* 高8位和当前字节相加后再查表求CRC ,再加上以前的CRC */
ptr++;
}
return(crc);
}
很显然,按字节求CRC时,由于采用了查表法,大大提高了计算速度。但对于广泛运用的8位微处理器,代码空间有限,对于要求256个CRC余式表（共512字节的内存）已经显得捉襟见肘了,但CRC的计算速度又不可以太慢,因此再介绍下面一种按半字节求CRC的算法。
5 按半字节计算CRC
同样道理,对于一个二进制序列数可以按字节表示为式(5-1),其中 为半个字节(共4位)。
(5-1)
求此二进制序列数的CRC码时,先乘以 后（既左移16位）,再除以多项式G(X),所得的余数既是所要求的CRC码。如式(4-2)所示：
（5-2）
可以设： (5-3)
其中 为整数, 为16位二进制余数。将式(5-3)代入式(5-2)得：
（5-4）
因为：
（5-5）
其中 是 的高4位, 是 的低12位。将式（5-5）代入式（5-4）,经整理后得：
（5-6）
再设： (5-7)
其中 为整数, 为16位二进制余数。将式(5-7)代入式(5-6),如上类推,最后得：
(5-8)
很显然,十六位二进制数 既是我们要求的CRC码。
式(5-7)是编写按字节计算CRC程序的关键,它说明计算本字节后的CRC码等于上一字节CRC码的低12位左移4位后,再加上上一字节余式CRC右移4位（也既取高4位）和本字节之和后所求得的CRC码,如果我们把4位二进制序列数的CRC全部计算出来,放在一个表里,采用查表法,每个字节算两次（半字节算一次）,可以在速度和内存空间取得均衡。由此不难理解下面按半字节求CRC码的C语言程序。*ptr指向发送缓冲区的首字节,len是要发送的总字节数,CRC余式表是按0x11021多项式求出的。
unsigned cal_crc(unsigned char *ptr, unsigned char len) {
unsigned int crc;
unsigned char da;
unsigned int crc_ta[16]={ /* CRC余式表 */
0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,
0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef,
}

crc=0;
while(len--!=0) {
da=((uchar)(crc/256))/16; /* 暂存CRC的高四位 */
crc<<=4; /* CRC右移4位,相当于取CRC的低12位）*/
crc^=crc_ta[da^(*ptr/16)]; /* CRC的高4位和本字节的前半字节相加后查表计算CRC,
然后加上上一次CRC的余数 */
da=((uchar)(crc/256))/16; /* 暂存CRC的高4位 */
crc<<=4; /* CRC右移4位, 相当于CRC的低12位） */
crc^=crc_ta[da^(*ptr&;0x0f)]; /* CRC的高4位和本字节的后半字节相加后查表计算CRC,
然后再加上上一次CRC的余数 */
ptr++;
}
return(crc);
}

I. 1+1=2在计算机中是怎么实现的额，从算法一直追溯到硬件，整个运算过程是如何实现的

貌似我记得是 0001+0001=0010这是电路板的信号模拟。1是有电子0是没电子。然后模拟出来的结果就是0010也就是2.因为计算机用的是2进制。大概就这样了。

J. 如何成为一名合格的算法工程师

BAT企业的算法工程师是这样工作的：问题抽象、数据采集和处理、特征工程、建模训练调优、模型评估、上线部署。（具体操作可以看阿里算法专家chris老师的算法工作流视频算法工作流是怎样的？）而一个算法工程师真正值钱的地方在于问题抽象和上线部署这两个。