数据结构与算法笔记-CSDN博客

算法数据结构问题程序的关系

问题由模型作为内核，用替换方式将抽象概念具体化，形成描述来包装内核
模型由数据和解决方法构成，每个问题不同情况的表现组成成数据，通过统一的解决方法得到解决
算法是解决问题的一般化方法
数据结构是数据的组织形式
程序是用计算机语言，在数据结构上操作算法，利用计算机解决问题

数据结构
数据结构是独立于数据而存在，具有一定逻辑结构，支持在上面进行被允许的操作，如插入、删除、查找等

主要有单元节点、散列、线性表、树、图

单元节点/元素
最基本元素，储存数据的直接单位

散列
元素相互独立，没有直接关系的结构集合
唯一关系元素在集合内

操作插入删除查找某元素
集合的实现数组 BST

Hash表
    考虑集合的数组表示a[x]为x是否在集合中，这是一一对应的关系
    Hash表将x用特征值t来表示对于不同的x可能对应同一个t（即冲突），根据t来查找x
    f(x) = t 的函数是hash函数， t为x的hash值
    因为可能存在冲突有不同的处理方法通常用链表来存储不同的x
    操作插入删除查找
    先计算f(x) 在对应的链表中操作，好的hash函数可以让链表尽可能短，达到理想效果

典型应用：记录庞大数字、字符串等，字典的实现

线性表
线性表中，元素线性排列，相邻元素有前驱后继的关系

操作插入删除查找某元素遍历查找第k小
线性表实现数组链表

有序表
元素顺序排列，可以用二分查找某个元素，可以直接获取第k小，插入删除困难，适用于排序之后的静态操作

栈
先进后出，用于人工模拟递归操作，表达式处理，递归过程中获取解答和模拟类题目

队列
先进先出，用于宽度优先搜索

映射
在线性表上加以集合构造 a[]是一个数组,已经具备某种逻辑关系A。
b[i]表示b[]第i个元素在a中的位置，初始b[i]=i，通过对a[b[i]]的排序得到对应数组a’[]具有逻辑关系B，a[]中元素位置未改变过

指针操作
对于一个序列，在上面进行简单的指针移动，获得完全遍历求最优解

字符串
匹配
    RK 将模式串用数字表示(hash)，然后通过移动将当前匹配单位的hash值计算出来，相等的时候，逐个判断

    KMP P为模式串 S为正文，用R[p]表示最大的k 使得P[1..k] = P[m-k+1..m]，这样如果在p+1处匹配失败，可以直接移动k个单位，匹配的过程实际为O(n+m)
        获得R[]的过程，对于R[p]，k = R[p-1]+1 如果P[k]不等于P[p]，k移动到R[k-1]上，继续匹配，否则R[p]=k，k右移

文章来源: http://thunderfyc.wordpress.com.cn

==================================================================================

1 对0..65535范围内的数字进行O(N)复杂度的排序

用t[i]表示等于i的元素有多少个从0开始往后数即可

2 有一串数，找到两个的商最接近t的

将数排序之后用两个指针l, r 如果a[l]/a[r] < t，那么a[l+1]/a[r]可能更接近t，至少比a[l]/a[r+1]接近；
反之亦然。最后l和r从1遍历到n之后，中途遇到的最优解即可

3 表达式处理

表达式 = 表达式符号表达式。只有当表达式为优先级最高的时候，才能把它转化为数字，替换，这个就是典型递归过程，
但是串的处理是顺序的，所以用栈操作，每次判断新压入栈的符号是否更高级，如果更高级将前面的基础表达式计算。

==================================================================================

Hash
f_hash(x: dataType): int;

find(x: dataType): node;
{
    t = f_hash(x);
    s = hash[t];
    while (s.data <> x)
    {
      s = s.next;
      if (s = nil)
        return nil;
    }
    return s;
}

ins(x: dataType);
{
    t = f_hash(x);
    s = hash[t];
    if (s = nil)
    {
      new(hash[t]);
      hash[t].data = x;
      hash[t].next = nil;
      return;
    }
    while (s.next <> nil)
      s = s.next;
    new(s.next);
    s = s.next;
    s.next = nil;
    s.data = x;
}

del(x: dataType);
{
    if (find(x) = nil)
      return;
    t = f_hash(x);
    s = hash[t];
    if (s.data = x)
    {
      hash[t] = s.next;
      return;
    }
    p = s;
    s = s.next;
    while (s.data <> x)
    {
      p = s;
      s = s.next;
    }
    p.next = s.next;
    delete(s);
}

RK
RK(p:string, s:string): int;
{
    pt = 0;
    m[0] = 1;
    for i <- 1 to p.len do
    {
      pt = (pt*26+p[i]) mod 29999;
      m[i] = m[i-1]*26;
    }
    st = 0;
    for i <- 1 to p.len do
    {
      st = (st*26+s[i]) mod 29999;
    }
    for i <- p.len+1 to s.len do
    {
      st = ((st - m[p.len]*s[i-p.len])*26+s[i]) mod 29999;
      if (st = pt)
      {
        check one by one;
        if ok
          return i;
      }
    }
    return -1;
}

KMP
pre(p: string);
{
    j = 1;    k = 0;    next[1] = 0;
    while (j < p.len)
    {
      if (k = 0 or p[j] = p[k])
      {
         j+1; k+1;
         if (p[j] <> p[k])
           next[j] = k
         else
           next[j] = next[k];
      }
      else
        k = next[k];
    }
}

KMP(p: string, s: string);
{
    i = 1; j = 1;
    while (j <= p.len and i <= s.len)
    {
      if (j = 0 or s[i] = p[j])
      {
        i+1; j+1;
      }
      else
        j = next[j];
    }
    if (j > t.len)
      return i;
    else
      return -1;
}

文章来源: http://thunderfyc.wordpress.com.cn

By thunderfyc in 数据结构与算法

Jul 24

文章来源: http://thunderfyc.wordpress.com.cn

树
一个结点对多个结点的结构，具有清晰的偏序关系

多叉树好多孩子
二叉树最多俩孩子

无根树没有固定的根的树形态不固定边无向
有根树有固定根的树节点之间有确定的父子关系

互相转化
多叉树->二叉树左儿子右兄弟
无根树->有根树确定根之后遍历

遍历
前序中序后序宽度优先

BST
    左孩子比根小根比右孩子小
    易退化为深度很深的树
    解决办法
      打乱顺序将输入的数据随机排列之后建树
      线段树   输入数据排序之后把看作长度为0的线段插入或者已知数据范围进行操作
      Treap 随机一个rank 使rank满足堆的性质元素满足BST性质
      红黑树节点为红或黑总有两孩子红节点的孩子为黑每条路径上黑节点个数相同
      AVL   用d表示左子树和右子树深度差维持在-1 0 1之间

并查集
将一些元素归类选出一个代表元素指向这个代表元素
典型树结构但是用数组实现只记录节点父亲

堆
根比儿子小的二叉树用数组实现，dad*2 = leftson, dad*2+1 = rightson
能够迅速获取最小或者最大

Huffman树
编码树对于给定的文章对字符重新编码使得总长度最小
到左儿子标记为0 到右儿子标记为1 访问次数越少的字符深度越大

================================================================================

1 在0..65535范围内的数插入删除可询问小于某个数的个数
BST或者线段树

2 不停的插入删除数求第k小的数
BST或者线段树或者堆
维护一个容量为K的堆大根堆每次讯问的时候返回堆顶；
读入一个数如果比堆顶小就把堆顶弹出插入新数
如果比堆顶大就无视

文章来源: http://thunderfyc.wordpress.com.cn

================================================================================

线段树
BuildTree(l, r, t: int);
{
    L[t] = l; R[t] = r; C[t] = 0;
    if (l == r)
      return;
    BuildTree(l, (l+r) div 2, t*2);
    BuildTree((l+r)div2 +1, r, t*2+1);
}

Ins(x, t: int);
{
    if (L[t] = R[t])
    {
      C[t]+1;
      return;
    }
    if (x <= L[t*2])
      Insert(x, t*2);
    else
      Insert(x, t*2+1);
}

Del(x, t: int);
{
    if (L[t] = R[t])
    {
      C[t]-1;
      return;
    }
    if (x <= L[t*2])
      Del(x, t*2);
    else
      Del(x, t*2+1);
}

Find(k, l, r, t: int): int;
{
    if (r <= R[t*2])
      return Find(k, l, R[t*2], t*2);
    if (l >= L[t*2+1])
      return Find(k, L[t*2+1], r, t*2+1);
    if (k <= C[t*2])
      return Find(k, l, R[t*2], t*2);
    if (k > C[t*2])
      return Find(k-C[t*2], L[t*2+1], r, t*2+1);
}

并查集
Find(x: int): int;
{
    if (sets[x] = x)
      return x;
    tmp = Find(sets[x]);
    return Find(sets[x]);
}

Union(x: int, y: int);
{
    t = Find(x);
    s = Find(y);
    if (Rank[t] < Rank[s])
      sets[t] = s
    else
      sets[s] = t;
}

堆
Del()
{
    data[1] = data[n];
    n-1;
    dad = 1; son = 2;
    while (true)
    {
      if (son+1 <= n and data[son] > data[son+1])
        son+1;
      if (data[dad] > data[son])
        swp(data[dad], data[son]);
      dad = son;
      son = son*2;
      if (son > n)
        break;
    }
}

Ins(x: int)
{
    n+1; data[n] = x;
    son = n; dad = n div 2;
    while (data[dad] <= data[son])
    {
      if (data[dad] > data[son])
        swp;
    }
}

文章来源: http://thunderfyc.wordpress.com.cn

图
多个节点和多个节点之间的关系

无向图边可以双向行走
有向图边只能单向行走

边集数组存储边的数组
邻接矩阵 g[i][j]表示i和j之间连边
邻接表 g[i][j]表示i的第j个邻居

DFS
从一个节点开始沿着一条路径走走不通退回然后走另外一条

BFS
从一个节点开始访问每一个后继然后再每个后继继续访问用队列

Euler
所有点的出度等于入度才存在任意一个点找后继插入走一条边删一条边
直到回到这个点这条路径记录下来继续重复直到没有边为止

拓扑排序
有向图中到达某个点先要到达所有前驱求访问顺序
DFS的时候从某个点的递归层中记录离开递归层的顺序将顺序逆向输出

强连同分量
有向图中任意两个点都能连通的子图
先DFS 记录下离开递归层的顺序然后边全部反向从最后一个开始依次DFS 所得到的每一棵DFS树都是一个强连同分量

关节点/割顶
    去掉之后图就不连同的节点
    DFS之后如果根有2个以上的孩子那么根是关节点
    记录和当前节点相连的被访问到的节点中非自己父亲的深度最小的记录下来如果和当前节点相连的一个节点没有被访问过进行访问访问完后
    如果和孩子相连的祖先深度不比他小这个节点就是关节点

桥
    去掉后图就不连同的边
    同求关节点如果相连的祖先深度比父亲要大这条边为桥

最小生成树将所有点连接起来的无根树边为图的边边权和最小
Kruskal 每次找不在同一个集合的两个节点连边最小用并查集实现
Prim 在没有被连接到的节点里找到一个和已经被连接的节点边权最小的加入用堆实现

次小生成树
Prim同时记录max[u][v]表示从u到v路径中最大的边权枚举不在MST中的g[u][v]必然大于max[u][v]替换之找到g[u][v]-max[u][v]最小的即可
Kruskal后枚举MST中的边去掉后重新求MST 找其中最小的一个

最短路
    单源最短路径
      Bellman-ford
        不停的选择d[i]+g[i][j]<d[j]是否可行作n次迭代可判断是否存在负环

Dijkstra
每次找到某个点最近的点d[i] 然后做修改d[i]+g[i][j]<d[j]

    任意点对最短路径
      Floyd
        本质是矩阵乘法 Mi是经过长度为i的最短路径 Mi*M0 = M(i+1) 其中的操作i j k为Mi[i][k]+M0[k][j] < Mi+1[i][j]就更改

    差分约束系统
      满足若干大小关系xi-xj<=bk
      建图 T到所有点射出权为0的边如果xi-xj<=bk则j到i射出bk 最后0到其他节点的最短距离为一组解
      0到i的距离要小于等于到j的距离加上边的权值显然是最短路

文章来源: http://thunderfyc.wordpress.com.cn

==============================================================================

DFS
p = 1;
DFS(k, dad, dep:int)
{
Ck = Grey; Dk = dep;
//Ak = dep; tot = 0;

    for i <- 1 to n
    {
      // if (g[i][k] and i <> dad and Ci = Grey)
      //   Ak = min{Ak, Di}

      if (g[i][k] and Ci = White)
      {
        DFS(i, k, dep+1);

        //tot+1; Ak = min{Ak, Ai};
        //if ((k=root and tot>1) or (k<>root and Ai >= Dk))
        // Cut_k = true
        //if (Ai > Dk)
        // Bridge[k][i] = true
      }
      post[i] = p;
      p1;
      Ck = Black;
}

Topsort
for i <- n downto 1
which post[j] = i;

Kruskal
{
    sort all edges;
    for i <- 1 to m
    {
      if (find(a[i]) <> find(b[i]))
      {
         tree[i] = true;
         union(a[i], b[i]);
      }
    }
}

Prim
{
    for i <- 1 to n
    {
      for j <- 1 to n
      {
        if (ok[j] = false)
          heap_ins(g[i][j]);
      }
      ok[heap[1]] = true;
      tree[pre[1]][heap[1]] = true;
    }
}

Bellman-Ford
for i <- 1 to n+1
{
    ok = false;
    for j <- 1 to n
      for k <- 1 to n
        if (d[j] + g[j][k] < d[k])
        {
          d[k] = d[j]+g[j][k];
          ok = true;
        }
    if (ok = false)
      break;
    if (i = n+1 and ok = true)
      return neg-cycle;
}

Dijkstra
for i <- 1 to n
{
    min = inf; oper = -1;
    for j <- 1 to n
      if (d[j] < min)
      {
        min = d[j]; oper = j;
      }
    if (oper = -1)
      return;

    for j <- 1 to n
      if (d[j] > d[oper] + g[oper][j])
      {
        d[j] = d[oper] + g[oper][j];
        pre[j] = oper;
      }
}

Floyd

Floyd
{
    for k <- 1 to n
      for i <- 1 to n
        for j <- 1 to n
          if (d[i][j] > d[i][k]+d[k][j])
          {
            d[i][j] = d[i][k] + d[k][j];
            p[i][j] = k;
          }
}

GetPath(i, j): string
{
    if (p[i][j] = 0)
      return ij;
    s = GetPath(i, p[i][j]);
    s - p[i][j];
    s + GetPath(p[i][j], j);
    return s;
}

Matrix Floyd
{
    M[1] = G;
    for x <- 2 to n
    {
      for i <- 1 to n
        for j <- 1 to n
          for k <- 1 to n
          if (M[x][i][j] > M[x-1][i][k] + G[k][j])
            M[x][i][j] = M[x-1][i][k] + G[k][j];
    }
}

文章来源: http://thunderfyc.wordpress.com.cn

枚举
状态的简单枚举
可以简单表示的单参数状态，对每个状态计算得到结果判断是否相等

状态压缩表示
将状态压缩表示如一组数选择与不选用0和1表示然后枚举

对已知答案集的枚举
知道答案的范围然后对答案进行枚举判断是否符合条件

步长叠进枚举
知道答案并且答案对情况的影响连续变化通过大步寻找小范围然后小步寻找答案的方法解通常为几何问题

贪心
和DP类似满足最优子结构同时满足最优选择即能导出最优子结构的选择唯一可判定

分治二分
将问题分解为子问题子问题共同对问题产生贡献
答案二分单调决策序列二分

归并排序
将序列拆为一个元素长的若干序列然后合并的时候将相邻的序列合并最后合并为一个大的

快速排序
选定一个轴将小的放在左边大的放在右边然后分别继续处理两边

二分解方程
确定一个范围满足f(l) f(r)异号然后计算mid=(l+r)/2 找到f(l) f(r)中和f(mid)异号的缩小范围继续

LIS的二分优化
    找到一个序列中的最长不下降序列
    记录t[x]为长度为x的LIS的最后一个元素大小要尽可能的小可见t[]是有序的数组
    每插入一个a[i] 如果a[i]比某个t[k]小比t[k-1]大那么a[i]替换这个t[k] 满足条件如果比t[x]要大 t[x+1]为a[i] 整个序列的LIS拉长一位

文章来源: http://thunderfyc.wordpress.com.cn

=============================================================================

8×8棋盘上八皇后摆放棋盘每格有分数最后八皇后占据格子分数最大
求出所有摆放方案枚举方案计算

三个食物有不同的营养成分选取每个食物的份数最后让营养成分成要求的比例
枚举每个食物的份数计算

已知若干线段找一点连接到这线段上某一点使得距离和最小
连续变化用大步长确定范围小步长确定位置

若干活动知道起始时间求不冲突活动的最大个数
按结束时间排序然后如果m在i之后开始 j前结束的结束时间最小的那么m必选 i m之间没有其他活动

若干活动知道起始时间求安排所有活动的最少礼堂数
将开始和结束时间并在一个表里排序开始的时候找到一个空闲的礼堂插入如果未使用过礼堂数+1 结束的时候把该礼堂设置为空闲放入空闲礼堂对首

序列AB 要求Pi(ai^bi)最大的排序方案
降序排列 bi>=bj ai>=aj ai^(bi-bj) >= aj^(bi-bj) ai^bi*aj^bj >= ai^bj*aj^bi

文章来源: http://thunderfyc.wordpress.com.cn

递归
将问题转为子问题解决降低编程复杂度使用

搜索
DFS
每层递归枚举一个选择然后继续递归得到所有解

BFS
将队首的节点扩展之后放入队尾然后继续扩展直到没有节点为止

    Floodfill
      要判断一个格点盘上连通的格点标记
      从一个格点开始将其放入队首扩展周围邻居格点如果没访问过放入队尾然后继续扩展直到不可扩展为止

搜索优化
Hash判重
判重的时候利用Hash可以O(1)判定是否访问过

搜索顺序
有的时候从小到大有的时候从大到小有的时候根据选择评估得到解得可能性

双向BFS
将初始状态扩展目标状态扩展两者重合时结束得到一条路径

分支定界
扩展节点对于超过可行范围的砍掉
随机化
利用随机打乱输入限制尽可能得到平均效率

生成随机序列
对于P[i] 将P[i+1]到P[n]中随机找一个和P[i]交换

搜索过程中随机选择

QuickSort随机选择中枢点

文章来源: http://thunderfyc.wordpress.com.cn

DP
把问题分化为子问题之后取之最优解从底向上或用递归从上往下再往上

最优子结构
能从最优的子问题解答中解答主问题
最优子结构的解需要独立一个问题的解不会影响到另外一个问题

重叠子问题
两个大问题的若干子问题中有相同的
注意存储子问题的解以提高效率

重建最优解
在解决子问题的时候记录取得最优解的选择可以从根回溯到解

记忆化
从主问题递归子问题子问题返回的解记忆下来以后再子问题的时候可以直接调用
既延续从底开始的不需重复计算的优点也避免了从底开始会进行很多不必要计算的缺点

记忆化搜索
在搜索过程中记录下子问题的解然后如果搜索到这一步骤就直接取得解
DP的一种表现形式

=====================================================================
8皇后
记录覆盖线的编号斜边按中间为0 两边为正负的方法记录
利用对称性

Castle
已知图上城堡用颜色染色然后判断有多少城堡最大城堡多大
Floodfill

8数码
一个9宫格上8个数字有一个空格每次可以把一个数字移到空格上要把它排成预定样子
A* 或者双向BFS
矩阵连乘的计算代价可以用结合律的方法来减小求最少计算代价计算代价为乘法的次数
      结合的种类数为 Pn = Σ(Pk*P_n-k) P1 = 1
      用opt[i][j]表示从i到j的计算代价 opt[i][j] = min{opt[i][k] + opt[k+1][j] + pi-1*pk*pj} p表示列
      另外可用s[i][j]表示取得最优解的k
      用从底向上的方法计算的话就是 for l = 2 to n; for i = 1 to n-l+1; j=i+l-1; for k = i to j-1;
      l是枚举当前处理的区间长度 i是左端点 j是右端点 k是最优解选择很显然 opt[i][k] opt[k+1][j]因为区间长度小于opt[i][j] 所以必然已经解出

已知两序列求最长的公共子序列(不一定连续)
      如果xm = yn zk=xm=yn 而且z(1..k-1)是xm-1 ym-1的LCS
      如果xm<>yn 如果zk=xm 那么Z是X和Yn-1的LCS 如果zk=yn 那么Z是Xm-1和Yn的LCS

      以c[i][j]表示X到第i Y到第j的最长长度 c[i][j] = c[i-1][j-1]+1 [xi=yj] c[i][j] = max{c[i][j-1], c[i-1][j]} [xi <> yj]
      可以用b[i][j]表示是从哪个串过来的回溯的时候就可以判断是返回b[i][j-1]还是b[i-1][j]还是b[i-1][j-1]

也可以不用b[][]数组因为c[][]数组的计算规则能够帮助我们决定b 而c可以利用滚动数组只记录相邻两行即可

Optimal Binary Search Tree
      BST中从根到关键字的路径长度为代价又知每个关键字的访问概率求使得期望访问代价最小的BST
      每一棵最优BST的子树都是最优BST 然后可以知道左子树一定都小于根一定都小于右子树那么在一个有序序列中确定根的位置就可确定左右子树范围通过递归到叶子就可解决问题
      opt[i][j]表示有序表i~j形成的树的最小访问代价 w[i][j]表示访问概率之和 opt[i][j] = min{opt[i][k-1]+opt[k+1][j]+w[i][j]}
      可用mid[i][j]表示取最优值时的根

mid[i][j]的取值区间为mid[i][j-1]到mid[i+1][j] 利用这个条件(四边形不等式) 可以将复杂度降为O(n^2)

Planning a Company Party
      公司的人事结构形成树派对中直接上下级关系不能同时参加每个人有个高兴值要求列出合法名单使高兴值最大
      以opt[i][0/1]表示以i为根的树的最大高兴值 0为i参加 1为i不参加
      opt[i][0] = Σ(max{opt[k][0],opt[k][1]}) k为i的孩子
      opt[i][1] = Σ(opt[k][0])
      结果为max{opt[1][0], opt[1][1]}
      方案不用存只要从最优值出发如果为1 则下属均不参加如果为0 判断下属的0和1哪个大即可

Edit Distance
已知一个字符串X 要变成字符串Y 操作过程将X从左至右扫描合法操作有 1继续 2更改当前字符 3删除当前字符 4插入新字符 5交换下两个字符 6结束每个操作的代价已知求最少代价方法
用opt[i][j]表示字符串X[1..i]转换到Y[1..j]的最小代价从opt[i-1][j] opt[i-1][j-1] opt[i][j-1]向后推得利用oper[i][j]表示用了何种操作

文章来源: http://thunderfyc.wordpress.com.cn

递推
f(x) = f(x-1)+f(x-2)
M = ((0,1),(1,1))
((f(x)), (f(x+1))) * M = ((f(x+1)), (f(x+2)))

((f(x)), (f(x+1))) = ((f(1)), (f(2)))*M^(x-1)

集合划分
    n个元素划分到k个集合里
    f(n,k) = f(n-1, k-1) + k*f(n-1, k)
    n-1个元素放在k-1个集合里剩下一个单独成集合
    或者n-1个元素在k个集合里剩下一个放置在其中任何一个

错装信封
    第i封信不在第i个信封里
    假设i在n上 n在i上剩下n-2个错排所以有f(n-2)*(n-1)个 i枚举从1到n
    假设i不在n上 n在i上那么去掉n后 n-1个位置对应n-1个数的错排(i考虑为n) 那么有f(n-1)*(n-1)个
    f(n) = (f(n-1)+f(n-2))*(n-1)

数论
gcd(a, b) = gcd(b, a mod b)

互素的数的个数
Phi(n) = n(1-1/p1)(1-1/p2)…(1-1/pi)

a^b mod n
b的二进制表示<bk,bk-1,…,b0>
从左到右 d = (d*d) mod n 如果bi=1 d = (d*a) mod n

高精度
排列组合
求排列为第几位
    从第一个位置到最后一个求比当前位置的数更小的数且不和前面相同的可能数累加
    例如 13245 0*4! + 1*3! + 0*2! + 0*1! + 0 = 6 (12345 12354 12435 12453 12534 12543 13245)
         41352 3*4! + 0*3! + 1*2! + 1*1! = 75

求某位排列
从第一位开始确定用x!的倍数来确定是在前面未出现的数中排列第几的数

求后继
找到一个一直延伸到末尾的递减序列然后将前一个值和递减数列中恰大于它的值互换后将递减序列排序为递增
解方程
Newton迭代
求导之后作切线得到和x轴交点作为新的x 求导作切线不断逼近

计算函数解析式
Lagrange插值公式
已知n个点坐标求过这些点的方程
f(x) = sigma(f(ai) Pi(x-aj[j<>i])/Pi(ai-aj[j<>i]))

不定方程
Euclid
gcd(a, b) = ax + by 有解
(d’,x’,y’) = ext_gcd(b, a mod b) (d,x,y) = (d’, y’, x’-[a/b]y’)

Pythagoras
a^2+b^2=c^2
假设 x = a/c; y = b/c;
     x^2+y^2=1
     y^2=(1-x)(1+x)=> y/(1+x) = (1-x)/y
设 t = y/(1+x)
   tx-y=-t; x+ty=1;
另 t = u/v   [t为有理数]
   a/c = (v^2 - u^2)/(u^2+v^2)
   b/c = (2uv)/(u^2+v^2)
   u,v互素且有一个奇数 v>u, a = v^2 - u^2; b = 2uv c = u^2 + v^2

Pell
x^2-ay^2 = 1
xn = ((x1+d^0.5*y1)^n+(x1-d^0.5*y1)^n)/2
yn = ((x1+d^0.5*y1)^n-(x1-d^0.5*y1)^n)/2d^0.5
xn = x1xn-1 + dy1yn-1
yn = y1xn-1 + x1yn-1

文章来源: http://thunderfyc.wordpress.com.cn

=================================================================================

猫的帽子里总有n个小猫，小猫又有小小猫，小猫的高度是猫的1/(n+1)，
最小的猫高为1，已知最大的猫高度和最小的猫数，求除了最小猫的数量和所有猫的高度和

H0 = (N+1)^dep;
workNum = N^dep;
ln(H0) = dep*ln(N+1); ln(workNum) = dep*lnN;
ln(H0)/ln(workNum) = ln(N+1)/ln(N); [此方程y -> 1 精度会有问题]

ln(H0)/ln(H0/workNum) = ln(N+1)/ln((N+1)/N) = ln(N+1) / ln(1 + 1/N)
y = ln(N+1) / ln(1+ 1/N) [增函数]
用Newton-Raphson 牛顿迭代法解（随便一个初始值，从函数上此点作切线，和x轴交点为新的值）
x = x0 - f(x0)/f’(x0) 迭代几次就可以了

notWorkNum = 1 + N + N^2 + … + N^(dep-1) = (N^dep - 1)/(N-1) = (workNum - 1)/(N-1);
HSum = 1 + (N+1)+(N+1)^2 + … + (N+1)^dep = ((N+1)^(dep+1) - 1)/N = (H0*(N+1) - 1)/N;

求数a b 满足1+2+..+a-1 = a+1+…+b

做方程a*(a-1) = (a+t+1+a+1)*(t+1) x^2-2y^2 = 1
x = 2t+2a+3 y = 2a
用Pell方程求解
xn = x0*xn-1 + 2*y0*yn-1
yn = x0*yn-1 + y0*xn-1

=============================================================================

Bignum Plus(a,b:Bignum)
{
for i <- 0 to maxn
{
    c[i] = a[i]+b[i];
    c[i+1] += c[i] div 1000;
    c[i] = c[i] mod 1000;
}
return c;
}

Bignum Minus(a,b:Bignum)
{
if (less(a,b))
    return Minus(b, a);
for i <- 0 to maxn
{
    if (b[i] < a[i])
    {
      b[i+1]-1;
      b[i]+1000;
    }
    c[i] = b[i]-a[i];
    c[i+1] += c[i] div 1000;
    c[i] = c[i] mod 1000;
}
return c;
}

Bignum Multi(a,b:Bignum)
{
for i <- 0 to maxn
{
    c = 0;
    for j <- 0 to maxn
    {
      c[i+j] = a[i]*b[j];
      c[i+j+1] += c[i+j] div 1000;
      c[i+j] = c[i+j] mod 1000;
    }
    d = Plus(d, c);
}
return d;
}