花开花落，花落花开

BSC,MSC,HLR分别的作用:MSC交换设备，程控交换机；BSC是基站控制器，用来控制BTS；HLR是本地位置寄存器，可以理解成一个数据库，存放本地移动用户的一些数据。BSC：基站控制器，它与BTS基站收发机构成基站子 系统。MSC：移动交换中心，它是网络的核心，提供交换功能并且面对下列功能实体：BSS、HLR、VLR、AUC、EIR、OMC和固定网，把移动用户与固定网用户

//Dijkstra 算法的时间复杂度为O(n^2) 　　空间复杂度取决于存储方式，邻接矩阵为O(n^2)//非负权, 有向#include #include using namespace std;const int max_vex = 100;const in

当有一个字符串str1,另一个字符串str2,要判断str2中的字符是否在str1中存在，可以使用hash表判断,O(m+n)。也可以将每一个字符一次赋予一个素数， 从2开始，然后将这些素数相乘。然后遍历第二个字符串，用素数去除前一次的乘积，若无余数，就存在，反之则不存在。

// right = F(n-2) , return value = F(n-1)int fibonacci_R(int n, int& right){ if(2 == n) { right = 1; return 1; } int t = 0; righ

设有三角形abc和点p，需要判断p是否在三角形abc内部只需要用叉乘进行判断，abXap， apXac，pbXpc是否都与abXac平行。另外面积法也能判断，判断三角形abp,acp,bcp的面积和是否等于三角形abc的面积。其中，求面积可以用叉乘来实现。

正整数a，删掉k位数，使剩下的数字按原序组合形成的新的数最小。贪心算法，最近下降点先删除。13789 --> 13 k = 3void delete_k(string &int_str, int k){ if (int_str.length() <=

#include using namespace std;// a 排序数组右移后的数组// for example: 4,5,6,7,8,9,0,1,2,3// 二分，返回索引int select( int a[], int left, int righ

设计一个数据结构，包括两个函数，插入数据和获得中位数。利用大根堆和小根堆，其中大根堆维护较小的一半数据，小根堆维护较大的一半数据。然后根据相应的情况，对两个堆做相应的堆化操作，以满足两个堆中元素数目一致。时间复杂度O(lgn)extension:设计一个堆

// 字符串中的字符彼此不相同// buffer for resultchar ret[100];// str: orginal string// i: index for str// n: index for ret// sz: size of the su

#include #include using namespace std;void show(int a){ cout << a <<" ";}template void my_swap(T &a, T &b){ T t = a; a = b; b

void swap(int* a, int* b){ int t = *a; *a = *b; *b = t;}void my_sort(int a[], int left, int right){ if (a == 0 || right <=

采用基数排序，用10个桶(vector)，每一个桶用队列表示(queue)，分别代表0-9，然后依次从低位到高位开始将要排序的数倒入桶中，然后再顺序取出来，直到排序完成。若有5个数，12,4,5,130,28第一次(个位):0: 13012: 12

一、RSA算法 :首先: 找出三个数, p, q, r, 其中 p, q 是两个相异的质数,r 是与 (p-1)(q-1) 互质的数...... p, q, r 这三个数便是 private key .接著: 找出 m, 使得 rm == 1 mod (p-1)(q-1).....这个 m 一定存在, 因为 r 与 (p-1)(q-1) 互质, 用辗转相除法就可以得到了.....

#include using namespace std;// x^16+x^12+x^5+1unsigned short crc16(unsigned char *ptr, int len){ unsigned short CRC = 0xFFFF; // vc++ sizeof(unsigned short) == 2 unsigned char j, tmp =

/*hanno tower -1- | | --2-- | | ---3--- | | ... | |

// 从字符串s1中寻找s2第一次出现的位置（不比较结束符NULL)// if 0 == s2, then return s1char* my_strstr(const char* s1, const char* s2)// look for the first s2 in s1{ int k = 0;// compact with c if (0 == s2 || '\0'

#include using namespace std;// look up the first character in the string.// using hash table to reduce the time used.char look_up(con

题目：输入一个数组和一个数字，在数组中查找两个数，使得它们的和正好是输入的那个数字。要求时间复杂度是O(n)。如果有多对数字的和等于输入的数字，输出任意一对即可。例如输入数组1、2、4、7、11、15和数字15。由于4+11=15，因此输出4和11。ans:用位图

从倒水问题中，深刻理解了状态机设计的重要性，包括状态机抽象和状态机转化关系的设计。倒水问题，定义好状态和状态转化关系，剪枝去掉不可能的状态和重复的状态，用一片内存空间来保存状态。

// 26进制，不过有缺点，需要大数处理#include using namespace std;long pow(long x, long y){ long ret = 1; while(y>0) { ret = ret*x; --y; } re

#include using namespace std;int max_num_str(char* pstr, char* output){ if ( *pstr == '\0') { *output = '\0'; return 0; } char

求对称子字符串的最大长度，如abcbae，那么最大长度为5。动态规划，O(n*n)bool a[100][100] = {false};int get_longest(char *b){ int len = 0; int slen = strlen(b);

struct node{ int val; node* p_left; node* p_right; node(int t) { val = t; p_left = p_right = 0; }};typedef struct node* link;

struct node{ int val; struct node* next; node(int t, node* n=0) { val = t; next = n; }};typedef struct node* link;void insert

设有链表a，表长为m，链表b，表长为n，若分别遍历a和b，其时间复杂度为o(mn)，这是最直观的方法。但是，细想一下，若两个链表相交，则从它们交叉的第一个公共结点到链表尾部的长度是相等的。因此，我们若能同步两个链表，就能在线性时间内找出第一个公共结点。       分别遍历a

link merge_sort(link t){ queue que; if (0 == t || 0 == t->p_next) return t; for (link u = 0; t!=0; t=u) { u = t->p_next; t->p_next

#include #include using namespace std;struct node{ int val; node* p_next; node(int t, node* pnode=NULL) { val = t; p_next = pn

#include #include using namespace std;struct node{ int _val; node* _next; node(int t=0, node* p=0) { _val = t; _next = p; }}

可以使用归并排序int counter = 0;// statisticstruct list_node{ int val; struct list_node* next; list_node(int t, struct list_node* pn = 0)

// 此方法能减少乘法次数， O（1）#include #include using namespace std;// do not consider doulbe overflowdouble pow(double base, int exponent)

#define MAX 200void print_prime(int m){ assert(m <= MAX); bitset flag; flag.reset(); flag.set(0); flag.set(1); for (int i = 4; i <=

// 空间复杂度O(1),时间复杂度O(n)void str_unique(char* str, int fs, int fd, int ed){ if (fs> (int)strlen(str)) return; // skip extra whitespace

char dst[100];void parentheses_match(char dst[], int k, int left_remain, int left_used, int right_used, int M){ if (right_used >= M) {

void my_swap(int &a, int &b){ int t = a; a = b; b = t;}int partion(int a[], int left, int right){ int t = a[right]; int i = left-1

void swap_char(char &a, char &b){    char t = a;    a = b;    b = t;}// 重复字符处理bool foo(char* str, char p, int begins, int ends

#include #include using namespace std;struct node{ int val; struct node *left; struct node *right; node(int t) { val = t; lef

#include using namespace std;// 树节点struct node{ int val; struct node* left; struct node* right; node(int t) { val = t; left

特殊情况，空树为任何树（包括空树）的子树struct node{ int val; struct node *left; struct node *right; node(int t) { val = t; left = 0; right = 0; }

不用加减乘除，求两数和，无符号数.unsigned int add(unsigned int a, unsigned int b){ if (0 == b) return a; unsigned int c = a ^ b; // carray unsigned i

求二叉树中两个子节点的最近公共节点// 树节点struct node{ struct node* left; struct node* right; int val; node(int t=0) { val = t; left = 0; right