算法与分析设计期末重点复习

//@author 软工.林

算法 完蛋！
填空题把书里第一章，其他算法章节在写代码之前的字看完 20分
计算题三大道（估摸就能知道考什么 除非考重复知识点）30分
完善算法 估计下面出 20分
综合分析不知道 不会啊 估计数学归纳法证明贪心？ 30分

填空题能考的东西：
　　算法性质：输入 输出 有限 确定
　　时间复杂度大O表示法的使用
　　递归式的时间复杂度求解
　　　衡量算法的好坏：时间复杂度
　　（一）
　　分治法的基本思想：将规模较大的不容易解决的大问题分割为性质相同但规模较小的子问题，若子问题容易求解，分别求解子问题，由子问题的解构造出原问题的解
　　能用分治法问题的特征：易分解为规模小的子问题 规模小到一定程度容易求解 各个子问题相互独立 子问题的解可以合并成原问题的解
　　分治法求解问题步骤：分解Divide->递归求解子问题Conquer->Merge合并 反正就是分解求值合并
　　递归：在函数定义中调用函数自身的方法，使用自身定义的函数称为递归函数。
　　递归：需要有递归边界和递归表达式
　　二分搜索应用分治法 将规模为n的问题简化为规模为n/2的问题
　　二分搜索 T(n) = O(1) WHEN n = 1, T(n/2) + O(1) WHEN n > 1
　　Tn = O(logn)

　　合并排序
　　排序思想 将n个元素分成两个规模大致相同的子数组 继续分割直到单元素 后将相邻的元素合并   （合并期间就是排序）
　　
　　快速排序
　　通过交换达到排序 最好情况 （划分平衡）将规模为n的问题分解为两个规模为n/2 的子问题 O（nlogn） 最坏情况 有序数组，O(n^2)
　　可以知道 快速排序执行效率取决于基准元素的选择
　　常常用平衡快速排序法（取数组开头中间结尾三个数的中位数作为基准元素）和基于随机支点选择的快排（最坏情况下依然是O(n^2)） 平均都是 O(nlogn)
　　
　　线性时间选择：找第K小 借助快排中的分割步骤（以第一个元素为基准，把小于基准的放在左边，大于基准元素的放在右边）
　　然后找第K小，找不到再在这个数的两边找就完事了  记住75这个数字

（二）

　 动态规划解决的问题：有最优子结构和子问题重叠性质
　　最优子结构：问题的最优解包含其子问题的最优解（也就是说由子问题的最优解可以得出问题的最优解）
　　子问题重叠性质：问题求解过程中，大量子问题重复出现
　　步骤：分析最优解性质并找出其结构特征，建立最优值递归定义，自底向上计算，构造问题最优解
　　最长公共子序列：c[i][j]= 0 (i = 0 or j = 0) , c[i - 1][j - 1] + 1(i,j > 0 and xi = yj), max{c[i-1][j],c[i][j-1]},(i,j>0 and xi != yj)
　　
　　最优二叉搜索树也可以考证明题 p45（书本）
　　二叉搜索树:每个结点都不比它的左子节点任意元素小 而且不比它的右子树的任意元素大
　　其递归定义为：若左子树不空，左子树上所有结点的值均小于它的根节点的值；
　　　　　　　　　　若右子树不空，右子树上所有的结点的值均大于它的根节点的值；
　　　　　　　　　　左右子树分别为二叉搜索树
　　（三）
　　贪心算法总是做局部最优选择，即当前问题的最优选择。
　　能运用贪心算法的问题有贪心选择性质（所求问题的整体最优解可以通过一系列局部最优选择来达到）
　　　　　　　　　　　　　　和最优子结构特征（一个问题的最优解包括其子问题的最优解）
　　哈夫曼树算法：O(nlogn）
　　
　　单源最短路径：没什么好记的，就不短找第一个点到剩下的点的集合的距离的最小值，并在取出剩下的点中的一个后，将剩下的点与第一个点的距离更新，
　　　　　　　　直至把除了第一个点的所有的点从剩下的点中取出来。
    最小生成树：prim算法 O(n^2） 每次找出来最短的边加入就完事了 p76
　　
　　(四）
　　回溯法：在问题的解空间中以深度优先搜索（dfs）搜索问题的解
　　步骤：定义问题的解空间(由所有可能的解构成） ->为了方便搜索，建立合适的解空间结构（子集树 和 排列树 两种中选一种）->dfs解空间树
　　当我们求解的结果是集合SS的某一子集的时候，其对应的解空间是子集树。时间复杂度O(2^n)

 

 　　当我们求解的结果是集合SS的元素的某一种排列的时候，其对应的解空间就是排列树。时间复杂度O(n!) 典型问题为旅行商问题（TSP） 批处理作业调度（O(nn!)）

 

 

　　回溯法通常用约束函数剪去不满足约束条件的子树，限界函数剪去不能得到最优解的子树 这两种函数统称剪枝函数
　　回溯法讲了：装载问题 批处理作业调度 n皇后(O(n*n^n)) 最大团问题 图的m着色
　　
　　最大团问题：p105 太恶心了不想写了
　　

　　（四）
　　分支限界法（就是广度优先搜索。。。）
　　P117
　　



主定理法解递归表达式的时间复杂度 必考
Tn = O(1) n = 1
     aT(n/b) + f(n) n > 1

解得：Tn = O(n^k) a < b^k
         = O((n^k) * logb n) a = b^k
         = O(n^logba) a > b^k 


　　*********下面在上课有讲过计算或者填表的一定要去看当时的笔记！**********
0-1背包（估计考填表）
最优二叉搜索树

C为背包容量
w(weight) v(value) m[i][j]背包容量为j，可选择物品为i,i + 1, ... n时 0-1背包的最优值
//count the best answer
public static void knapsack(int[] v, int[] w, int c, int[][] m){
    int jMax = Math.min(w[n] - 1, c);
    for(int j = 0; j <= jMax; j ++){
        m[n][j] = 0;
    }
    
    for(int j = w[n]; j <= c; j ++){
        m[n][j] = v[n];
    }
    //**************key
    for(int i = n - 1; i > 1; i --){
        jMax = Math.min(w[i] - 1, c);
        for(int j = 0; j <= jMax; j ++){
            m[i][j] = m[i + 1][j];
            for(int j = w[i]; j <= c; j ++){
                m[i][j] = Math.max(m[i + 1][j], m[i + 1][j - w[i]] + v[i]);
            }
        }
    }
    //**************key
    m[1][c] = m[2][c];
    if(c >= w[1]) m[1][c] = Math.max(m[1][c], m[2][c - w[1]] + v[1]);
}

//get the best answer
public static void traceback(int[][] m, int[] w, int c, int[] x){
    for(int i = 1;i < n; i ++){
        if(m[i][c] == m[i + 1][c]) x[i] = 0;
            else{
                x[i] = 1;
                c-=w[i];
            }
        x[n] = (m[n][c] > 0)?1:0;
    }
}

//bst
public static void optimalBinarySearchTree(float[] a, float[] b, float[][] m, int[][] s,   float[][] w){
    for(int i = 0; i <= n; i ++){
        w[i + 1][i] = a[i];
        m[i + 1][i] = 0;
    }

    for(int r = 0; r < n; r ++){
        for(int i = 1; i <= n - r; i ++){
            int j = i + r;
            w[i][j] = w[i][j - 1] + a[j] + b[j];       //=>
            w[i][j] = m[i][i - 1] + m[i + 1][j];       //=>min{m[i][k - 1],m[k + 1][j]}
            s[i][j] = i;                               //=>
            for(int k = i + 1; k <= j; k ++){
                float t = m[i][k - 1] + m[k + 1][j];
                if(t < m[i][j]){
                    m[i][j] = t;
                    s[i][j] = k;
                }
                m[i][j] += w[i][j];
            }
        }

    }
}


贪心算法总是做局部最优选择 
当一个问题既具有贪心选择性质又具有最优子结构性质时，必能用贪心算法得到整体最优解。
Dij(可能考计算填表把我觉得 p71)
public static Bintree huffmanTree(float[] f){
    int n = f.length;
    Huffman[] w = new Huffman[n + 1];
    Bintree zero = new Bintree();
    for(int i = 0; i < n; i ++){
        Bintree x = new Bintree();
        x.makeTree(new MyInteger(i), zero, zero);
        w[i + 1] = new Huffman(x, f[i]);
    }
    MinHeap H = new MinHeap();
    H.initialize(w, n);
    for(int i = 1; i < n; i ++){
        Huffman x = (Huffman).H.removemin();
        Huffman y = (Huffman).H.removemin();
        Bintree z = new Bintree();
        z.makeTree(null,x.tree,y.tree);
        Huffman t = new Huffman(z,x.weight+y.weight);
        H.put(t);
    }
    
    return ((Huffman)H.removemin()).tree;
}
　　//dist[]从源点到顶点xxx的最短特殊路径长度，prev[]记录从源点到顶点xxx的最短路径的前一个顶点 p71
public static void dijkstra(int v,float[][] a, float[] dist, int[] prev){
    if(v < 1 || v > n) return;
    boolean[] s = new boolean[n + 1];
    for(int i = 1; i < n; i ++){
        dist[i] = a[v][i];
        s[i] = false;
        if(dist[i] = Float.MAX_VALUE) prev[i] = 0;
        else prev[i] = v;
    }
    dist[v] = 0; s[v] = true;
    for(int i = 1; i < n; i ++){
        float temp = Float.MAX_VALUE;
        int u = v;
        for(int j = 1; j <= n; j ++){
            if(!s[j] && (dist[j] < temp)){
                u = j;
                temp = dist[j];
            }
            s[u] = true;
            for(int j = 1; j <= n; j ++){
                if(!s[j] && (a[u][j] < Float.MAX_VALUE)){
                    float newdist = dist[u] + a[u][j];
                    if(newdist < dist[j]){
                        dist[j] = newdist;
                        prev[j] = u;
                    }
                }
            }
        }
    }
}

批处理作业调度
/*
    n个作业 J1...Jn
    注意：时间均为从机器x启动到该作业完成的时间
    f1,i表示Ji在第一台机器的处理时间 
    f2,i表示Ji在第二台机器的处理时间
    规定第一个任务必须在第一台机器处理完成之后才能在第二台机器处理

    找问题方案x->为作业的处理顺序 如x = [3,1,2]为作业3->作业2->作业1

    解决方法：搜索 搜索大法好！
*/
class FlowShop{
    //n 作业数 f 时间和 f1 机器1完成时间 f2 机器2完成时间 bestf当前最优值
    static int n, f1, f, bestf;
    static int[][] m;//各作业所需的处理时间
    static int[] x; //当前作业调度方案
    static int[] bestx; //当前最优作业调度
    static int[] f2; //机器2完成处理时间
    public static void backtrack(int i){
        if(i > n){
            for(int j = 1; j <= n; j ++){
                bestx[j] = x[j];
            }
            bestf = f;
        }
            else{
                for(int j = i; j <= n; j ++){
                    f1 += m[x[j]][1];
                    f2[i] = ((f2[i - 1] > f1)? f2[i - 1]: f1) + m[x[j]][2];
                    f+=f2[i];

                    if(f < bestf){
                        swap(i, j);
                        backtrack(i + 1);
                        swap(i, j);
                    }
                    f1 -= m[x[j]][1];
                    f -= f2[i];
                }
            }
    }
}

图的着色问题 就一个结点一个结点搜索下去就完事了 不行就回溯就这样

class Coloring{
    //图的点数
    static int n;
    
    //可用颜色数
    static int m;
    
    //图的邻接矩阵
    static boolean [][]a;
    
    //当前解
    static int[] x;
    
    //当前已找到的m可着色方案数
    static long num;
    
    public static long mColoring(int mm){
        m = mm;
        sum = 0;
        backtrack(1);
        return sum;
    }
    
    private static void backtrack(int t){
        if(t > n){
            sum ++;
            for(int i = 1; i <= n; i ++){
                System.out.print(x[i] + ' ');
                System.out.println();
            }
        }
            else{
                for(int i = 1; i <= m; i ++){
                    x[t] = i;
                    //ok函数保证相邻两点的颜色不一样
                    if(ok(t)) backtrack(t + 1);
                    x[t] = 0;
                }
            }
    }

    private static boolean ok(int k){
        for(int j = 1; j <= n; j ++){
            //估计考这个条件填空
            if(a[k][j] && (x[j] == x[k])){
                return false;
            }
            return true;
        }
    }
}