算法设计与分析试题+实验java代码

danny__258__

已于 2024-07-03 18:35:13 修改

阅读量1k

点赞数 27

文章标签：算法

于 2024-07-02 16:59:39 首次发布

本文链接：https://blog.csdn.net/danny__258__/article/details/140130340

版权

一、选择题（每题1分共10分）

分支限界法解旅行售货员问题时，活结点表的组织形式是()

A.最小堆B.最大堆C.栈D.数组

一个问题可用动态规划或贪心算法求解的关键特征是问题的()
A.重叠子问题 B.最优子结构性质C.贪心选择性质D.定义最优解

回溯法的效率不依赖于下列哪些因素()。

A.满足显约束的值的个数？

B.计算约束函数的时间

C.计算限界函数的时间

D.确定解空间的时间

贪心算法与动态规划算法的主要区别是()。

A.最优子结构B.贪心选择性质C.构造最优解D.定义最优解

算法分析中，记号Ω表示()

A. 渐进下界B.渐进上界C.渐进精确界记号D.以上都不是

FIFO是()的搜索方式。

A.分支界限法B.动态规划法C.贪心法D.回溯法

二、判断题（每题1分共10分）

优先队列式分支限界法按照优先队列中规定的优先级，选取优先级最高的结点，成为当前扩展结点。√

使用限界函数作优先级, 第一个扩展的叶子就是最优解。√

解决旅行商问题，采用的是优先队列式分支限界法。√

优先队列式分支限界为了加速搜索的进程，按照优先队列中规定的优先级，选取优先级最高的结点，成为当前扩展结点。√

分支界限法采用深度优先策略搜索。× 广度
……

三、算法（每题10分共20分）

考察基本算法，补充代码

按照书里的顺序来复习

绪论
……
2.9线性时间选择
3 动态规划过程画图
……
3.3最长公共子序列LCS
递归结构最优子结构性质穷举（搜索）法反证法
……
3.9 0-1背包问题
最优子结构性质递归关系
knapsack最优值 traceback最优解
①初始化 p[n+1]=(0,0) 向量（变量，价值）
②求向量和 q[n+1]=p[n+1] 条件：q中所有向量的重量<=c +(wn,vn) 跳跃点
③合并 p[n]=p[n+1]∪q[n+1]
④重复②③ 知道求p[1]

3.10 最优二叉搜索树obst
最优子结构性质递归计算最优值
0-1背包dp动态规划求最优解自底向上
背包-贪心
分治-归并

分解：将原问题分解成若干个规模较小、相互独立且与原问题形式相同的子问题。
解决：递归地解决各个子问题。当子问题的规模足够小时，可以直接求解。
合并：将各个子问题的解合并成原问题的解。

……
4.4哈夫曼编码
n个字符用O(nlogn) 贪心选择性质最优子结构
4.5单源最短路径
Dijkstra领接矩阵 dist[i]表示当前从源到顶点i的最短特殊路径长度迭代最优子结构性质
……

5.2装载问题
回溯法 backtrack O(2^n)
上界函数剪枝
5.3批处理作业调度
回溯FlowShop 搜索排列树
backtrack 递归
……
5.7 最大团问题MaxClique
无向图 G=(V,E) 邻接矩阵
初始化回溯搜索backtrack O(n2^n)
……
概念最大的全连接图子树
分支限界法剪枝

2.7合并/归并排序

public class MergeSort {//merge合并 sort排序
    public static void merge(int[] arr, int left, int mid, int right) {
        int n1 = mid - left + 1;
        int n2 = right - mid;
        int[] L = new int[n1];
        int[] R = new int[n2];
        for (int i = 0; i < n1; ++i)
            L[i] = arr[left + i];
        for (int j = 0; j < n2; ++j)
            R[j] = arr[mid + 1 + j];
        int i = 0, j = 0;
        int k = left;
        while (i < n1 && j < n2) {
            if (L[i] <= R[j]) {
                arr[k] = L[i];
                i++;
            } else {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        while (i < n1) {
            arr[k] = L[i];
            i++;
            k++;
        }

        while (j < n2) {
            arr[k] = R[j];
            j++;
            k++;
        }
    }
    public static void sort(int[] arr, int left, int right) {
        if (left < right) {
            int mid = (left + right) / 2;
            sort(arr, left, mid);
            sort(arr, mid + 1, right);
            merge(arr, left, mid, right);
        }
    }
}

2.8快速排序（快排）

public class QuickSort {//partition分解
    public static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = (low - 1);
        for (int j = low; j < high; j++) {
            if (arr[j] <= pivot) {
                i++;

                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;
        return i + 1;
    }
    public static void sort(int[] arr, int low, int high) {
        if (low < high) {
            int pi = partition(arr, low, high);
            sort(arr, low, pi - 1);
            sort(arr, pi + 1, high);
        }
    }
}