算法基础——知识点总结

算法基础课程的总结，方便以后快速查阅和复习

Week 2 枚举

---

基本方法

列举各元素，进行猜测。

1. 给出解空间，建立简洁的数学模型，列举出可能的情况
2. 减小搜索的空间，避免不必要的计算
3. 采用合适的搜索顺序

经验总结

• 输入：scanf("%d", &cases);

• 输出：printf("PUZZLE #%d \n", i+1);

• 对一行元素进行枚举的一种常见方法：模拟二进制加法，处理进位
  比如，对press第一行元素的取值（0/1）进行枚举：

    while(guess() == false){         //结束的条件
        press[1][1]++;             //每次循环从从最低位加1（不考虑press[1][0]）
        c = 1;                            //从最低位开始，准备进位
        while (press[1][c] > 1) {              //如果当前位超过1
            press[1][c] = 0;                        //当前位置0
            c++ ;                        //进位
            press[1][c]++;
        }
    }//这样将不断地往后增加，直到满足结束条件，普通循环嵌套不如这个方便

• 很多情况下，元素太多，难以直接枚举，这时冷静下来，先想好策略，再开始敲代码

• 每次取出两个元素，遍历所有取法：

    for (int i = 0; i < n - 1; i++)
        for (int j = i + 1; j < n; j++)
            ...

• 有时定义个结构体还是很方便的：

    struct PLANT{
        int x, y;
    }

Week 3 递归

---

基本方法

• 递归：某个函数直接或间接地调用自身。

• 求解过程：将问题划分为许多相同性质的子问题，这些子问题的递归求解就构成了原问题的解。

  原问题为f(x)，想尽办法寻找函数g(x)，使得f(x) = g(f(x-1))，其他形式也行，只要找出了这样的迭代的规律，就能就能将f(x)不断分解，直到“出口”，比如已知了f(0)的值。

• 递归的三个要点
  1. 递归式：如何将原问题划分为子问题
  2. 递归出口：递归终止的条件，允许多个出口
  3. 界函数：问题规模变化的函数，保证递归的规模向出口条件靠拢

• 注意事项：函数的局部变量存在栈上，递归很深的时候，各个子问题的函数的局部变量可能导致栈溢出

经验总结

• 迷宫求解问题，每一步的探测方式相同（自相似性），可以使用递归

• 主要考虑：判断是否符合要求，如何递归，需要记录那些数据

• 递归式可能是：\(f_{(n)}(·) = f_{(n-1)}(·) + f_{(n-2)}(·)\)等各式各样的，需要根据实际问题发散思考

• 使用记录表（在递归计算的过程中想办法多存下一些有用的东西），减少之后的计算量
  int res[15][9][9][9][9]

• 初始化记录表：memset(res, -1, sizeof(res))

• 那些重复的按照某些特定规律进行操作从而解决问题的方法，先用人脑想出操作过程，然后用递归来实现

Week 4，Week 5 动态规划

---

有时使用递归来求解问题时，子问题可能存在大量重复计算，从而严重影响效率，除了在递归计算的过程中使用记录表存一些数据，还可以使用递推的方式：从简单的状态开始递推到要解决的问题。

基本方法

1. 将原问题分解成子问题
2. 确定状态：一个或多个子问题各个变量的一组取值
3. 确定一些初始状态的值
4. 确定状态转移方程

• 适用的情况
  1. 最优化原理：最优解所包含的子问题的解也是最优的
  2. 无后效性：状态确定后不会受以后影响，这样才能正常递推
• 动归的三种形式：
  1. 记忆递归型
  2. ”我为人人“递推型
  3. ”人人为我“递推型

经验总结

• #include
sort(A, A+a);//从小到大

• 可以直接使用max(a, b)得到最大值。

• 当选取的状态，难以进行递推时，考虑将状态增加限制条件后分类细化，即增加维度，然后在新的状态上尝试递推

• 状态往往是很多的值（数组），使用合适的顺序不断更新状态。

• 关键还是在于找到问题的递推方式。

Week 6, Week 7 深度优先搜索

---

基本方法

深度优先搜索遍历整个图的框架为：

Dfs(v){
    if(v访问过)
        return;
    do something;
    将v标记为访问过;
    对和v相邻的每个点u: Dfs(u); 
    //程序运行的时候，将会深入某一个分支直到这个分支全部访问完，才会进入下一个分支。
}
int main(){
    while(还能找到未访问的点k)
        Dfs(k);
}

经验总结

• 图的每个结点常常有很多相关数据，可以定义个结构体来带代表每个结点
  struct Room {int r, c; Room(int rr, int cc): r(rr), c(cc) {} };

• 保存一系列的结点信息，这时可以使用vector:

    struct Road{
        int d, L, t;
    };
    vector> cityMap(100);

• 遍历整个图常常很费时，面对具体问题，应该想尽办法尽早判断该结点或分支是否值得继续搜索（剪枝）

Week 8 广度优先搜索

---

有时不需要遍历整个图，比如希望找到符合条件的步数最少的节点，可以给节点分层，一层一层地去判断，找到了合适的就停止。

基本方法

广度优先搜索算法（使用queue）

1. 把初始节点S0放入Open表中
2. 如果Open表为空，则问题无解，失败退出
3. 把Open表的第一个节点取出放入Closed表，并记该节点为n
4. 考察节点n是否为目标节点，若是，则得到问题的解，成功退出
5. 若节点n不可扩展，则转到第2步
6. 扩展节点n，将其不在Close表和Open表中的子节点（判重）放入Open表的尾部，并为每一个子节点设置指向父节点的指针或记录节点的层次，然后转到第2步

经验总结

• 使用队列
  • #include
  • queue q
  • q.push(Step(N, 0))
  • Step s = q.front()
  • q.pop

• 判重常常需要根据具体情况，建一个标志位序列。根据时间空间的权衡设计合适的标志位序列。

• 给定排列求序号

  数出有多少种排列比给定的排列小，比如3241:

  • 1, 2放在第一位，有2*3! = 12种
  • 3在第一位，1放在第2位，有 2! = 2种
  • 32放在前面，第三位可以放1，有 1种，然后就没有其他的了

• 给定序号n求排列

  • 第一位假定是1，共有3!种，没有到达9,所以第一位至少是2
  • 第一位是2,一共能数到 3!+3!号，>= 9,所以第一位是2 第二位是1，21??,一共能数到 3!+2! = 8 不到9，所以第二位至少 是 3
  • 第二位是3，23??,一共能数到 3!+2!+2! >= 9,因此第二位是3
  • 第三位是1，一共能数到3!+2!+1 = 9,所以第三位是1，第四位是 4
  • 答案：2314

• 八数码问题，从奇排列不能转化成偶排列或相反。很多问题如果可以人为的找到一些规律，利用这些规律常常能简化搜索过程。

• bitset的使用

  • #include
  • bitset<362880> Flags;
  • Flags.reset();
  • if(Flags[n]) continue;
  • Flags.set(n, true);

• 求和

  #include
int A[16] = {0}; int sum = accumulate(A, A + 16, 0);//最后那个0是指求和的初值

• 赋值，将内容拷贝到想要放置的内存位置

  #include
memcpy(A, AA, sizeof(A));

• 可以直接使用一个int型的整数来模拟二进制的序列，比如Int x = 0xffff;操作的时候使用为运算符

Week 9 二分与贪心算法

---

基本方法

• 二分查找

  对已经排序好的序列，首先检查序列的中间元素：

  • 如果大于这个元素，在当前序列的后半部分继续查找
  • 如果小于这个元素，在当前序列的前半部分继续查找
  • 知道找到相同的元素，或者所查找的序列范围为空为止

• 贪心算法

  问题求解时，总是做出在当前看来是最好的选择（不保证全局最优）
  很多看上去很复杂的问题可以设计成贪心算法能解决的形式，设计贪心策略判断是否满足“无后效性”

经验总结

• 对自定义的对象排序

    bool operator < (const Box &a, const Box &b){
        return a.density < b.density;
    }
    sort(boxes, boxes + n);
  
    bool comp(const int &a,const int &b){
        return a>b;
    }
    sort(v.begin(),v.end(),comp);

• 简化问题：最小值问题-->判定性问题

  • 求某个最小的情况，可以从i = 0开始，判断i = x是否能满足条件，但是这样效率太低，为了提高效率，考虑采用二分法来查找
  • 经典思想：二分+判定

• 设计贪心策略常常可以对序列先进行排序，然后再依次进行操作

作者：rubbninja
出处：http://www.cnblogs.com/rubbninja/
关于作者：目前主要研究领域为机器学习与无线定位技术，欢迎讨论与指正！

转载于:https://www.cnblogs.com/rubbninja/p/5107625.html