《算法》作业

已于 2022-03-23 19:00:39 修改
阅读量497 收藏 1
点赞数 1
文章标签： 算法
于 2022-02-23 20:50:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/input_print/article/details/123098978
版权

《算法》第一次作业：

Q1: Show the contents of the id[] array and the number of times the array is accessed for each input pair when you use quick-find for the sequence 9-0 3-4 5-8 7-2 2-1 5-7 0-3 4-2.

显示id[]数组的内容，以及对序列9-0 3-4 5-8 7-2 2-1 5-7 0-3 4-2使用快速查找时，每个输入对访问数组的次数；

  1. QuickFindUF(10)：

    []0123456789
    id[]0123456789

  2. union(9, 0)：

    访问次数：13次；

    []0123456789
    id[]0123456780

  3. union(3, 4)：

    访问次数：13次；

    []0123456789
    id[]0124456780

  4. union(5, 8)：

    访问次数：13次；

    []0123456789
    id[]0124486780

  5. union(7, 2)：

    访问次数：13次；

    []0123456789
    id[]0124486280

  6. union(2, 1)：

    访问次数：14次；

    []0123456789
    id[]0114486180

  7. union(5, 7)：

    访问次数：14次；

    []0123456789
    id[]0114416110

  8. union(0, 3)：

    访问次数：14次；

    []0123456789
    id[]4114416114

  9. union(4, 2)：

    访问次数：16次；

    []0123456789
    id[]1111116111
代码实现：

  • vim quickfind.cc:

    #include <iostream>
#include <vector>
  
using std::vector;
using std::cout;
using std::endl;
using std::cin;
  
int main()
{
        int n = 0;
        cin >> n;
        vector<int> id(n);
        int i = 0;
        for ( vector<int>::iterator iter = id.begin(); iter != id.end(); ++iter )
        {
                *iter = i;
                i++;
        }
        int p = 0;
        int q = 0;
        while( cin >> p >> q ) {
          			int c = 0; // 记录访问数组次数；
                int pid = id[p];
          			c++;
                int qid = id[q];
          			c++;
                cout << "id[] is ";
                for ( vector<int>::iterator iter = id.begin(); iter != id.end(); ++iter )
                {
                        if ( *iter == pid ){ *iter = qid; c++; }
                  	    c++;
                        cout << *iter;
                }
         				cout << " and c is" << c << endl;
        }
        return 0;
}

  • vim quickfind_input.txt：

    10
9 0
3 4
5 8
7 2
2 1
5 7
0 3
4 2

  • vim quickfind_output.txt；

  • gcc -l c++ -o quickfind quickfind.cc;

  • ./quickfind <quickfind_input.txt >quickfind_output.txt；

  • 输出结果：

   	id[] is 0123456780 and c is 13
   	id[] is 0124456780 and c is 13
   	id[] is 0124486780 and c is 13
   	id[] is 0124486280 and c is 13
   	id[] is 0114486180 and c is 14
   	id[] is 0114416110 and c is 14
   	id[] is 4114416114 and c is 14
   	id[] is 1111116111 and c is 16
Q2: Do Exercise 1.5.1, but use quick-union (英文教材224页，中文教材141页). In addition, draw the forest of trees represented by the id[] array after each input pair is processed.use quick-union for the sequence 9-0 3-4 5-8 7-2 2-1 5-7 0-3 4-2.

依附根节点，左根连右根；

访问次数 = p查找根的次数 + q查找根的次数 + 1（将根连到一起）；

  1. QuickUnionUF(10)：

    []0123456789
    id[]0123456789
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9

  2. union(9, 0)：

    访问次数：1 + 1 + 1 = 3次；

    []0123456789
    id[]0123456780
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9

  3. union(3, 4)：

    访问次数：1 + 1 + 1 = 3次；

    []0123456789
    id[]0124456780
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9

  4. union(5, 8)：

    访问次数：1 + 1 + 1 = 3次；

    []0123456789
    id[]0124486780
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9

  5. union(7, 2)：

    访问次数：1 + 1 + 1 = 3次；

    []0123456789
    id[]0124486280
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9

  6. union(2, 1)：

    访问次数：1 + 1 + 1 = 3次；

    []0123456789
    id[]0114486280
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9

  7. union(5, 7)：

    访问次数：2 + 3 + 1 = 6次；

    []0123456789
    id[]0114486210
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9

  8. union(0, 3)：

    访问次数：1 + 2 + 1 = 4次；

    []0123456789
    id[]4114486210
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9

  9. union(4, 2)：

    访问次数：1 + 2 + 1 = 4次；

    []0123456789
    id[]4114186210
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9
代码实现：
#include <iostream>
#include <vector>
  
using std::vector;
using std::cout;
using std::endl;
using std::cin;
  
int main()
{
        int n = 0;
        cin >> n;
        vector<int> id(n);
        int i = 0;
        for ( vector<int>::iterator iter = id.begin(); iter != id.end(); ++iter )
        {
                *iter = i;
                i++;
        }
        int p = 0;
        int q = 0;
        while( cin >> p >> q ) {
          			int c = 0; // 记录数组访问次数；
          			//如果p或q位置存的不是自己的标号，说明自己不是父节点，向上追溯；
          			int k = 0;
          			while ( ( k = id[p] ) != p ){
                  p = k;
                  c++;
                }
          			c++; // 虽然判断相等，没有进入循环，但是还是对数组进行了一次访问；
          			while ( ( k = id[q] ) != q ){
                  q = k;
                  c++;
                }
          			c++;
          			id[p] = q; // p的根连到q的根上；
          			c++;
                cout << "id[] is ";
                for ( vector<int>::iterator iter = id.begin(); iter != id.end(); ++iter )
                {
                        cout << *iter;
                }
                cout << " and c is " << c << endl;
        }
        return 0;
}

输出：

id[] is 0123456780 and c is 3
id[] is 0124456780 and c is 3
id[] is 0124486780 and c is 3
id[] is 0124486280 and c is 3
id[] is 0114486280 and c is 3
id[] is 0114486210 and c is 6
id[] is 4114486210 and c is 4
id[] is 4114186210 and c is 4
Q3：Do Exercise 1.5.1, but use weighted quick-union，use weighted quick-union for the sequence 9-0 3-4 5-8 7-2 2-1 5-7 0-3 4-2.

  1. QuickWeightUnionUF(10)：

    []0123456789
    id[]0123456789
    sz[]1111111111

  2. union(9, 0)：

    访问id[]次数：3次；

    []0123456789
    id[]9123456789
    sz[]1111111112

  3. union(3, 4)：

    访问id[]次数：3次；

    []0123456789
    id[]9123356789
    sz[]1112111112

  4. union(5, 8)：

    访问id[]次数：3次；

    []0123456789
    id[]9123356759
    sz[]1112121112

  5. union(7, 2)：

    访问id[]次数：3次；

    []0123456789
    id[]9173356759
    sz[]1112121212

  6. union(2, 1)：

    访问id[]次数：4次；

    []0123456789
    id[]9773356759
    sz[]1112121312

  7. union(5, 7)：

    访问id[]次数：3次；

    []0123456789
    id[]9773376759
    sz[]1112121512

  8. union(0, 3)：

    访问id[]次数：4次；

    []0123456789
    id[]9779376759
    sz[]1112121514

  9. union(4, 2)：

    访问id[]次数：6次；

    []0123456789
    id[]9779376757
    sz[]1112121914
代码实现：
#include <iostream>
#include <vector>
  
using std::vector;
using std::cout;
using std::endl;
using std::cin;
  
int main()
{
        int n = 0;
        cin >> n;
        vector<int> id(n);
  			vector<int> sz(n, 1); // 初始权重数组的初始权重为1；
        int i = 0;
        for ( vector<int>::iterator iter = id.begin(); iter != id.end(); ++iter )
        {
                *iter = i;
                i++;
        }
        int p = 0;
        int q = 0;
        while( cin >> p >> q ) {
          		int idc = 0; //对id数组的访问次数；
          		int szc = 0; //对sz数组的访问次数;
          		while ( id[p] != p ){
                	p = id[p];
                	idc++;
                }
          		idc++;
          		while ( id[q] != q ){
                q = id[q];
                idc++;
        }
          			idc++;
          			// 前面的查找根和quickunion相同，但是合并根要根据sz数组的值；
          			// if ( sz[p] <= sz[q] ){ id[p] = q; sz[q] += sz[p]; }
          			int szp, szq;
          			if ( (szp = sz[p]) < (szq = sz[q]) ){ 
                  		id[p] = q; 
                  		sz[q] += szp; 
                  		idc++; 
                  		szc += 3;
                }
          			else { 
                  		id[q] = p; 
                  		sz[p] += szq; 
                  		idc++;
                  		szc += 3; //访问sz数组两次，赋值sz数组一次，一共三次；
                }
                cout << "id[] is ";
                for ( vector<int>::iterator iter = id.begin(); iter != id.end(); ++iter )
                {
                        cout << *iter;
                }
          		cout << "; sz[] is ";
                for ( int i = 0; i != n; ++i)
                {
                        cout << sz[i];
                }
                cout << "; idc is " << idc << "; szc is " << szc << endl;	
        }
        return 0;
}

结果：

id[] is 9123456789; sz[] is 1111111112; idc is 3; szc is 3
id[] is 9123356789; sz[] is 1112111112; idc is 3; szc is 3
id[] is 9123356759; sz[] is 1112121112; idc is 3; szc is 3
id[] is 9173356759; sz[] is 1112121212; idc is 3; szc is 3
id[] is 9773356759; sz[] is 1112121312; idc is 4; szc is 3
id[] is 9773376759; sz[] is 1112121512; idc is 3; szc is 3
id[] is 9779376759; sz[] is 1112121514; idc is 4; szc is 3
id[] is 9779376757; sz[] is 1112121914; idc is 6; szc is 3
OutlierLi
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算法作业
天青如水的博客
06-03 3084
设CiC_iCi​为第i步实际的代价，则 ∑i=1nCi≤n+∑j=0log n2j=n+(2n−1)<3n \sum_{i=1}^nC_i \leq n+ \sum_{j=0}^{log \ n}2^j = n+(2n-1) <3n i=1∑n​Ci​≤n+j=0∑log n​2j=n+(2n−1)<3n 所以每次分摊费用为O(1)O(1)O(1) 定义Ci...
作业调度算法模拟
懒羊羊的梦想
06-12 2776
作业调度算法模拟 1）先来先服务（First-Come First-Served，FCFS）调度算法 先来先服务调度算法遵循按照进入后备队列的顺序进行调度的原则。该算法是一种非抢占式的算法，是到目前为止最简单的调度算法，其编码实现非常容易。该算法仅考虑了作业到达的先后顺序，而没有考虑作业的执行时间长短、作业的运行特性和作业对资源的要求。 2）短作业优先（Shortest-Job-First，SJF）调度算法 短作业优先调度算法根据作业控制块中指出的执行时间，选取执行时间最短的作业优先调度。本实验中规定，该
常见的作业调度算法
热门推荐
码的世界
09-26 1万+
PS：该博文所有的图片均来自课堂授课的 PPT 截图。感谢老师提供的 PPT 。 写在前面 评价作业调度算法的优劣，通常看平均周转时间和带权周转时间 周转时间 = 作业完成时间 - 作业到达时间 平均周转时间 = （作业完成时间 - 作业到达时间）/ 作业数量 带权周转时间 = 作业周转时间 / 作业服务时间 先来先服务算法 顾名思义，先来先服务算法就是先来的作业先调度运行，后来的后运行。和队...
c语言贪心算法作业调度问题,实验三 贪心算法 多机调度问题
weixin_36232899的博客
05-16 2332
基本题一：多机调度问题一、实验目的与要求1、熟悉多机调度问题的算法；2、初步掌握贪心算法；二、实验题要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。约定，每个作业均可在任何一台机器上加工处理，但未完工前不允许中断处理。作业不能拆分成更小的子作业。三、实验提示1、把作业按加工所用的时间从大到小排序2、如果作业数目比机器的数目少或相等，则直接把作业分配下去3、如果作...
算法设计与分析 第四章 贪心算法 作业
Jessieeeeeee的博客
12-28 3660
判断题 1-1 只有当局部最优跟全局最优解一致的时候，贪心法才能给出正确的解。 T F 1-2 令S为活动选择问题（Activity Selection Problem）中所有活动的集合。则一定存在S的某个最大相容活动子集是包含了最早结束的活动 am​​ 的。 T F 1-3 令S为活动选择问题（Activity Selection Problem）中所有活动的集合。则最早结束的活动a​m一定被包含在S的所有最大相容活动子集中。 T F 1-4 在活动选择问题（Activity Selection Pr
作业调度算法
SmallSweets的博客
03-11 7558
单道批处理系统中，有四个作业，到达时间和所需运行时间如下表所示，按照先来先服务（FCFS），短作业优先（SJF），最高响应比优先(HRN）算法计算各个进程的开始运行时间，完成时间，周转时间，带权周转时间和所有作业的平均周转时间，平均带权周转时间。 作业 到达时间/h 运行时间/h 开始时间 完成时间 周转时间 带权周转时间 平均周转时间 平均带权周转时间 1 8.0 2.0 2 8.6 0.6 3 8.8 0.2 4 9.0 0.5
多种作业调度算法
oYiDiDeSiNian的博客
03-22 2116
操作系统作业调度算法原理探索和计算
作业分配问题之回溯算法
连正的博客
12-01 3024
1 问题描述 有n份作业分配给n个人去完成，每人完成一份作业。假定第i个人完成第j份作业需要花费cij时间， cij&gt;0,1≦i,j≦n。试设计一个回溯算法，将n份作业分配给n个人完成，使得总花费时间最短。 2 算法实现 import java.io.*; import java.util.*; public class Demo { public int n; /...
贪心算法——作业调度
yangqiang1997的博客
10-05 3043
算法思想：长作业优先，先把作业分配给每台处理机，剩下的优先分配给先空闲的处理机。 #include<iostream> #include<algorithm> #include<vector> using namespace std; struct job { int id; int costtime; }; bool cmp(job a, job b) { return a.costtime > b.costtime; } int Greedy(vector
操作系统适应算法作业
qq_43813697的博客
04-28 4577
3.8 假设某系统内存共256kb，其中操作系统占用低址20 kb ，有这样一个作业序列：作业1（80kb），作业2（16kb），作业3（140kb），连续进入系统，经过一段时间运行，作业1、3先后完成。此时，作业4（120kb），作业5（80kb）要求进入系统，分别采用首次适应算法和最佳适应算法，处理上述作业序列，完成下列要求： ...
页面置换算法作业.pdf
06-25
在本篇“页面置换算法作业”中，主要讨论了四种常见的页面置换算法：最佳置换算法（OPT）、先进先出算法（FIFO）、最近最久未使用算法（LRU）和最不经常使用算法（LFU），并阐述了虚拟存储器的相关概念和实现方式。...
智能优化算法作业.docx
05-11
智能优化算法作业 智能优化算法是指在解决复杂优化问题时，使用智能搜索策略来寻找最优解的算法。该算法通过模拟自然界中的智能搜索过程，来解决复杂的优化问题。 MA 算法是一种框架算法，它可以采取不同的搜索...
陈玉福 算法 作业
01-11
【陈玉福 算法 作业】是针对2018年度的算法学习课程所设计的一系列作业题目，这通常意味着我们将深入探讨计算机科学中的基础且至关重要的部分——算法设计与分析。在这个课程中，学生会被要求解决一系列的算法问题，...
《算法作业部分答案》
09-30
作者Robert Sedgewick 斯坦福大学博士，本书作为算法领域经典的参考书，全面介绍了关于算法和数据结构的知识，并特别针对排序、搜索、图处理和字符串处理进行了论述。第4 版具体给出了每位程序员应知应会的50 个算法...
西南交通大学 算法作业7
06-11
西南交通大学 算法作业7
算法-KMP字符串匹配
xx_xb的博客
07-23 230
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
算法题目整合5
qq_62571233的博客
07-23 878
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 277
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
【常微分方程】
最新发布
qq_74285286的博客
07-24 300
常微分方程笔记
贪心算法作业调度问题
12-19
贪心算法作业调度问题是一个经典的优化问题，目标是在给定一组作业和一组空闲的处理机器的情况下，找到一种调度方案，使得完成所有作业所需的总时间最小。 一种常见的贪心算法作业调度问题的解决方法是按照作业的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值