精华内容
下载资源
问答
  • 每组数据第行是两个整数N、M(N,M),N表示成都的大街上有几个路口,标号为1的路口是商店所在地,标号为N的路口是赛场所在地,M则表示在成都有几条路。N=M=0表示输入结束。接下来M行,每行包括3个整数A,B,C(1,...
  • 一个岛上有n个人,每个人的眼睛要么是蓝色的,要么是黑色的,并且至少有一个人眼睛是蓝色的。每个人都知道至少一个人眼睛是蓝色的事实,但是不知道具体个人眼睛是蓝色的。每天所有人互相见面,他们可以看到别人的...
  • 亿年后,战争终于结束了,三个国家又重归于好,bitland的臣民又过上了幸福的生活,没有人再提起那场战争,你是bitland的一个考古学家,当你从祖父口中偶然得知了这场辉煌的战争,你决定要去走访bitland的每一个...
  • 每组数据第行是两个整数N、M(N,M),N表示成都的大街上有几个路口,标号为1的路口是商店所在地,标号为N的路口是赛场所在地,M则表示在成都有几条路。N=M=0表示输入结束。接下来M行,每行包括3个整数A,B,C(1,...
  • 每组数据第行是两个整数N、M(N,M),N表示成都的大街上有几个路口,标号为1的路口是商店所在地,标号为N的路口是赛场所在地,M则表示在成都有几条路。N=M=0表示输入结束。接下来M行,每行包括3个整数A,B,C(1,...
  • 每组数据第行是两个整数N、M(N,M),N表示成都的大街上有几个路口,标号为1的路口是商店所在地,标号为N的路口是赛场所在地,M则表示在成都有几条路。N=M=0表示输入结束。接下来M行,每行包括3个整数A,B,C(1,...
  • 基于比较大排序算法至少需要O(n*lgn)的复杂度。对于一些特殊的输入我们一些特殊的算法,可能得到复杂度为O(n)的算法。本文简要描述其中的种:count排序,基数排序和桶排序。 count排序的假设是被排序的字段在...

    基于比较大排序算法至少需要O(n*lgn)的复杂度。对于一些特殊的输入我们有一些特殊的算法,有可能得到复杂度为O(n)的算法。本文简要描述其中的几种:count排序,基数排序和桶排序。

    count排序的假设是被排序的字段在一个有限的范围内,比如对1000人按照年龄排序。

    count排序需要两个额外的变量,一个用于存放排序结果,长度是n,另一个用于存放中间结果,长度是k。其中n为输入的长度,k-1为输入数据的最大值。

    设输入A[0..n-1],初始化变量 B[0..n-1], C[0..k-1],算法如下:

    for i = 0 .. k-1
        C[i] = 0
    for j = 0 .. n-1
        C[A[j]] ++
    for i = 1 .. k-1
        C[i] = C[i-1] + C[i]
    for j = n-1 .. 0
        B[C[A[j]]-1] = A[j]
        C[A[j]] --

    容易证明这个算法复杂度为O(n+k)。考虑到k一般为O(n),所以整体复杂度为O(n)。

     

    基数排序的起源是扑克牌的排序,先按照花色排序,再按照数字排序。如果要对一些10进制数排序,比如:123,456,321,789.可以按照从低位到高位的顺序,先第一位排序,再第二位排序,依次类推。需要注意两点:

    1. 必须先低位后高位,因为高位更有决定权,只有当高位一样的时候,才按照低位到顺序排序,这就是第二点:

    2. 按照某位排序时,排序算法必须是稳定的;

    算法很简单:

    for i = 1..b

       按照第i位排序,稳定排序

    很容易看到这个复杂度是O(b*(n+k)),其中n是输入元素个数,k是输入元素在某个位上元素个数。b是输入元素的位数。

    稍微变化一下,不是每位排序一次,而是分成若干组,每组有r位,那么复杂度为O(b/r * (n+2^r))。以r为变量,对这个表达式求最小值。分几种情况:

    1. b<lgn,由于r小于b,故2^r小于n,因此复杂度为O(n)

    2. b>=lgn,取r=lgn,复杂度也是O(n)

     

    桶排序

    桶排序更类似于count排序的连续版本。count排序需要输入是整数。桶排序假设输入在0~1区间均匀分布。假设输入A[1..n],满足A[i]小于1,大于等于0,后我们把该0~1等分成n份,每份是一个bucket。然后用B数组[1..n]分别存放对应区间的A的元素,并对这些元素使用插入排序。最后将B的各个元素对应的list串联起来。比较麻烦的是这个算法的复杂度证明。结论是如果输入的分布满足均匀分布,那么复杂度为O(n).

    转载于:https://www.cnblogs.com/alphablox/archive/2013/02/14/2912616.html

    展开全文
  • 种最短路径算法

    2019-10-12 16:15:34
    Dijisktra 不能处理负边,时间复杂度O(n^2),堆优化O(nlogE) 基本思路:首先它是求单源点到其他边的最短路。...在开始输入图的信息后,肯定至少有一条边已经是最短边了,如果说能通过其他点再到目标点距离更短...

    Dijisktra

    下面图片是从这个链接https://blog.csdn.net/qq_37796444/article/details/80663810找到,比较清楚
    在这里插入图片描述

    不能处理负边,时间复杂度O(n^2),堆优化O(nlogE)

    基本思路:首先它是求单源点到其他边的最短路。方法就是创建一个集合来存放一些点,一开始放源点进去。然后每次取到集合外哪个点的距离最短,将其加入集合。(这个时候要更新,即通过该点再到其他点会不会比现在到其他点的距离短,会就更新)
    在一开始输入图的信息后,肯定至少有一条边已经是最短边了,如果说能通过其他点再到目标点距离更短,那源点到这个其他点的距离不就更短了,不就是最短边了?

    测试时,邻接矩阵太大了,爆掉了。
    #include<iostream>
    #include<cstdio>
    #include<cstring>
    using namespace std;
    typedef long long ll;
    const int unreach=2147483647;
    ll node[10010][10010];//邻接矩阵存图
    ll dist[10010];//单源点到其他点的距离
    int exist[10010];//该点是否已列入集合中
    int n,m,s,F,G,W;
    /*
        给出一个有向图,请输出从某一点出发到所有点的最短路径长度
        N、M、S,分别表示点的个数、有向边的个数、出发点的编号
        Fi、Gi、Wi,分别表示第i条有向边的出发点、目标点和长度
    */
    void dijkstra(int s)
    {
        for(int i=1;i<=n;i++){
            dist[i]=node[s][i];
        }
        exist[s]=1;
        ll newnode,length;
        for(int k=1;k<=n-1;k++){
            for(int i=1;i<=n;i++){
                if(!exist[i]){
                    newnode=i;
                    length=dist[i];
                    break;
                }
            }
            for(int i=1;i<=n;i++){
                if(!exist[i]&&dist[i]<length){
                    newnode=i;
                    length=dist[i];
                }
            }
            exist[newnode]=1;
            for(int i=1;i<=n;i++){
                dist[i]=min(dist[i],dist[newnode]+node[newnode][i]);
            }
        }
    }
    int main()
    {
        cin>>n>>m>>s;
        //初始化
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                node[i][j]=unreach;
            }
            node[i][i]=0;
        }
        for(int i=1;i<=n;i++)
            exist[i]=0;
        //
        for(int i=0;i<m;i++){
            scanf("%d%d%d",&F,&G,&W);
            if(W<node[F][G])node[F][G]=W;
        }
        dijkstra(s);
        for(int i=1;i<=n;i++)
            printf("%lld ",dist[i]);
        return 0;
    }
    
    所以用邻接表,这里用vector模拟
    #include<iostream>
    #include<cstdio>
    #include<cstring>
    #include<vector>
    using namespace std;
    typedef long long ll;
    const int unreach=2147483647;
    struct dot
    {
        int pos;
        int length;
    };
    vector<dot> node[10010];
    ll dist[10010];//单源点到其他点的最短距离
    ll edge[10010];//点到其他点的距离
    int exist[10010];//该点是否已列入集合中
    int n,m,s,F,G,W;
    /*
        给出一个有向图,请输出从某一点出发到所有点的最短路径长度
        N、M、S,分别表示点的个数、有向边的个数、出发点的编号
        Fi、Gi、Wi,分别表示第i条有向边的出发点、目标点和长度
    */
    void dijkstra(int s)
    {
        for(int i=1;i<=n;i++){
            dist[i]=unreach;
        }
        for(int j=0;j<node[s].size();j++){
            dot t=node[s][j];
            if(t.length<dist[t.pos]){//两个点之间可能不止一条边
                dist[t.pos]=t.length;
            }
        }
        dist[s]=0;
    
        exist[s]=1;
        ll newnode,length;
        for(int k=1;k<=n-1;k++){
            for(int i=1;i<=n;i++){
                if(!exist[i]){
                    newnode=i;
                    length=dist[i];
                    break;
                }
            }
            for(int i=1;i<=n;i++){
                if(!exist[i]&&dist[i]<length){
                    newnode=i;
                    length=dist[i];
                }
            }
            exist[newnode]=1;
            for(int i=1;i<=n;i++)
                edge[i]=unreach;
            for(int i=0;i<node[newnode].size();i++){
                dot t=node[newnode][i];
                //两个点之间可能不止一条边
                if(t.length<edge[t.pos]){
                    edge[t.pos]=t.length;
                }
            }
            for(int i=1;i<=n;i++){
                dist[i]=min(dist[i],dist[newnode]+edge[i]);
            }
        }
    }
    int main()
    {
        cin>>n>>m>>s;
        //
        for(int i=0;i<m;i++){
            scanf("%d%d%d",&F,&G,&W);
            dot t;
            t.pos=G,t.length=W;
            node[F].push_back(t);
        }
        dijkstra(s);
        for(int i=1;i<=n;i++)
            printf("%lld ",dist[i]);
        return 0;
    }
    
    最后用堆优化
    #include<iostream>
    #include<cstdio>
    #include<vector>
    #include<queue>
    using namespace std;
    const int maxn = 100000 + 10;
    struct Node {
        int pos;
        int dis;
        Node() {}
        Node(int p, int d) {
            pos = p;
            dis = d;
        }
    };
    // 由于优先队列默认为大顶堆,所以重载小于号要用 a.dis > b.dis,来起到小顶堆的作用
    bool operator<(const Node &a, const Node &b) {
        return a.dis > b.dis;
    }
    int n,m,s,u,v,w;
    int dis[maxn];
    int vis[maxn];
    vector<Node> G[maxn];
    priority_queue<Node> que;
    
    void dij(int s) {
        // 初始化距离
        for(int i=1;i<=n;i++){
            dis[i]=1e9+10;
        }
        dis[s] = 0;
        que.push(Node(s, 0));
        while(!que.empty()) {
            Node tmp = que.top();
            que.pop();
            if(vis[tmp.pos])continue;
            vis[tmp.pos]=1;
            // 更新节点 tmp 的邻接节点,若邻接节点被更新,则将节点和 dis 加入小顶堆
            int len = G[tmp.pos].size();
            for(int i = 0; i < len; ++i) {
                int pos = G[tmp.pos][i].pos;
                int d = G[tmp.pos][i].dis;
                if(dis[pos] > tmp.dis + d) {
                    dis[pos] = tmp.dis + d;
                    que.push(Node(pos, dis[pos]));
                }
            }
        }
    }
    int main()
    {
        cin>>n>>m>>s;
        for(int i=0;i<m;i++){
            scanf("%d%d%d",&u,&v,&w);
            Node node;
            node.pos=v,node.dis=w;
            G[u].push_back(node);
        }
        dij(s);
        for(int i=1;i<=n;i++)
            printf("%d ",dis[i]);
        return 0;
    }
    
    

    Floyd

    /*
        |Floyd算法|
        |任意点对最短路算法|
        |求图中任意两点的最短距离的算法|
    */
    
    for (int i = 0; i < n; i++) {   //  初始化为0  
        for (int j = 0; j < n; j++)  
            scanf("%lf", &dis[i][j]);  
    }  
    for (int k = 0; k < n; k++) {  
        for (int i = 0; i < n; i++) {  
            for (int j = 0; j < n; j++) {  
                dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);  
            }  
        }
    }
    
    展开全文
  • python算法

    2020-07-20 20:48:43
    输出 : 算法至少有1个或多个输出 有穷性 : 算法在有限的步骤之后会自动结束而不会无限循环, 并且每一个步骤可以在可接受的时间内完成 确定性: 算法中的每一步都有确定的含义, 不会出现二义性 可行性 : 算法的每一步...

    算法的五大特性

    1. 输入 : 算法具有0个或多个输入
    2. 输出 : 算法至少有1个或多个输出
    3. 有穷性 : 算法在有限的步骤之后会自动结束而不会无限循环, 并且每一个步骤可以在可接受的时间内完成
    4. 确定性: 算法中的每一步都有确定的含义, 不会出现二义性
    5. 可行性 : 算法的每一步都是可行的, 也就是说每一步都能够执行有限的次数完成

    算法效率的描述
    基本运算总数*基本运算耗时 ~= 运行时间
    基本运算函数 —>渐进函数
    O(n) -------> n问题规模

    时间复杂度的几条基本计算规则

    1. 基本操作, 即只有常数项, 认为其时间复杂度为O(1)
    2. 顺序结构, 时间复杂度按加法进行计算
    3. 循环结构, 时间复杂度按乘法进行计算
    4. 分支结构, 时间复杂度取最大值
    5. 判断一个算法的效率时,往往只需要关注操作数量的最高次项,其他次要项和常数项可以忽略
    6. 在没有特殊说明时, 我们所分析的算法的事件复杂度都是指最坏时间复杂度

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    时间复杂度所消耗的时间
    O(1) <O(logn) < O(n) < O(nlogn) < O(n2) < O(n3) < O(2n) < O(n!) < O(nn)

    在这里插入图片描述

    timeit模块

    class timeit.Timer(stmt=‘pass’, setup=‘pass’, timer=)

    timer 是测量一小段代码执行速度的类.
    stmt 参数是要测试的代码语句(statment) ;
    setup 参数是运行代码时需要的设置;
    timer 参数是一个定时器函数, 与平台有关

    timer.Timer.timeit(number = 1000000) 默认为100w次

    在这里插入图片描述
    在这里插入图片描述

    图b这样的顺序表也被称为对实际数据的索引,这是最简单的索引结构

    顺序表的两种基本实现形式
    在这里插入图片描述

    一体式结构,存储表信息的单元与元素存储区以连续的方式安排在一块存储区里, 两部分数据的整体形成一个完整的顺序表对象.

    一体式结构整体性强, 易于管理. 但是由于数据元素存储区域是表对象的一部分, 顺序表创建后, 元素存储区就固定了.
    分离式结构,表对象里只保存与整个表有关的信息(即容量和元素个数), 实际数据元素存放在另一个独立的元素存储区里, 通过链接与基本表对象关联.

    链表
    链表定义
    链表是一种常见的基础数据结构, 是一种线性表, 但是不像顺序表一样连续存储数据, 而是在每一个节点 (数据存储单元) 里存放下一个节点的位置信息 (即地址) .

    单向链表
    单向链表也叫单链表, 是链表中最简单的一种形式, 它的每个节点包含两个域, 一个信息域(元素域)和 一个链接域. 这个链接指向链表中的下一个节点, 而最后一个节点的链接域则指向一个空值.
    在这里插入图片描述

    表元素域elem 用来存放具体的数据.
    链接域next 用来存放下一个节点的位置(python中的标识)
    变量p 指向链表的头节点(首节点)的位置, 从p出发能找到表中的任意节点.

    双向链表结构

    一种更复杂的链表是"双向链表" 或 “双面链表”. 每个节点有两个链接: 一个指向前一个节点, 当此节点为第一个节点时, 指向空值; 而另一个指向下一个节点, 当此节点为最后一个节点时, 指向空值.

    在这里插入图片描述

    在这里插入图片描述

    数据结构与算法

    在这里插入图片描述

    冒泡排序(背下来)

    比较相邻的元素. 如果第一个比第二个大(升序), 就交换他们两个。
    对每一对相邻元素作同样的工作, 从开始第一队到结尾的最后一对. 这步做完后, 最后的元素会是最大的数。
    针对所有的元素重复以上的步骤,,除了最后一个。
    持续每次对越来越少的元素重复上面的步骤, 直到没有任何一堆数字需要比较。

    时间复杂度
    最优时间复杂度 :O(n)
    平均时间复杂度 O(n^2)
    最坏时间复杂度 :O(n^2)
    稳定性 :不稳定
    备注 :n小时比较好

    选择排序
    首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,在从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。

    选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上,则它不会被移动。选择排序每次交换一对元素,他们当中至少有一个将被移到其最终位置上,因此对n个元素的表进行排序总共进行至多n-1此交换。在所有的完全依靠交换去移动元素的排序方法中,算则排序属于非常好的一种。

    时间复杂度
    最优时间复杂度 :O(n^2)
    平均时间复杂度 :O(n^2)
    最坏时间复杂度 :O(n^2)
    稳定性 :不稳定
    备注 :n小时比较好

    插入排序
    它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。插入排序在实现上,在从后向前扫描过程中,需要反复把已排序元素逐步向厚挪威,为最新元素提供插入空间。

    时间复杂度
    最优时间复杂度 :O(n)
    平均时间复杂度 :O(n^2)
    最坏时间复杂度 :O(n^2)
    稳定性 :稳定
    备注 :大部分已有序时好

    希尔排序
    希尔排序也是插入排序的一种。也称缩小增量排序,是直接插入算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL. Shell于1959年提出而得名。希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量主键减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被纷争一组,算法便终止。

    时间复杂度
    最优时间复杂度 :O(nlogn)
    平均时间复杂度 :O(nlogn)~O(n^2)
    最坏时间复杂度 :O(n^2)
    稳定性 :不稳定
    备注 :和步长有关

    快速排序(背下来)
    又称划分交换排序,通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,一次达到整个数据变成有序序列。

    步骤为:
    1.从数列中挑出一个元素,成为“基准”(pivot)
    2。重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任意一边)。在这个分区结束之后,该基准就处于数列的中间位置。这个称为分区(partition)操作。
    3.递归地(recursive) 把小于基准值元素的子数列和大于基准值元素的子数列排序。

    递归地最底部情形,是数列的大小是零或一,也就是永远都已经被排序好了。虽然一直递归下去,但是这个算法总会结束,因为在每次的迭代(iteration)中,它至少会把衣蛾元素摆到它最后的位置去。

    时间复杂度
    最优时间复杂度 :O(nlogn)
    平均时间复杂度 :O(nlogn)
    最坏时间复杂度 :O(n^2)
    稳定性 :不稳定
    备注 :n大时比较好

    归并排序
    归并排序是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分组数组,再合并数组。

    将数组分解最小之后,然后葛冰两个有序数组,基本思路是比较两个数组的最前面的书,谁小就先取谁,取了后相应的指针就往后移一位。然后再比较,直至一个数组为空,最后把另一个数组的剩余部分复制过来既可。

    时间复杂度
    最优时间复杂度 :O(nlogn)
    平均时间复杂度 :O(nlogn)
    最坏时间复杂度 :O(nlogn)
    稳定性 :稳定
    备注 :n大时比较好

    搜索

    常见的几种方法:顺序查找、二分法查找、二叉树查找、哈希查找

    二分法查找
    二分法查找又称折半查找,有点事比较次数少,平均性能好;其缺点是要求待查表为有序表,且插入删除困难。

    树与树算法

    树是一种抽象数据类型(ADT)或是实作这种抽象数据类型的数据结构,用来模拟具有树状结构性质的数据集合。它是由n(n>=1)个有限节点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一颗倒挂的树,也就是说它是根朝上,而叶朝下的。它具有一下的特点:

    每个节点有零个或多个子节点;
    没有父节点的节点称为根节点;
    每一个非根节点有且只有一个父节点;
    除了根节点外,每个字节点可以分为多个不想交的子树;

    在这里插入图片描述

    森林:有m(m》=0)颗互不相交的树的集合称为森林。

    树的存储与表示

    在这里插入图片描述

    在这里插入图片描述

    常见的一些树的应用场景

    二叉树

    二叉树的基本概念
    二叉树是每个节点最多有讲个子树的树结构。通常子树被称作“左子树”和“右子树”

    二叉树的性质(特性)

    性质1:在二叉树的第i层上至多有2^(i-1)个节点(i>0)
    性质2:胜读为k的二叉树至多有2^k-1个节点(k>0)
    性质3:对于任意一颗二叉树,如果其叶节点树为N0,而度数为2的节点总数为N2,则N0=N2+1;
    性质4:具有n个节点的完全二叉树的深度必为log2(n+1)
    性质5:对完全二叉树,若从上至下、从左至右编号,则编号为i的节点,其左孩子编号必为2i,其右孩子编号必为2i + 1;其双亲的编号必为i/2(i=1时为根,除外)

    在这里插入图片描述

    二叉树的遍历
    树的遍历是树的一种重要的运算。所谓遍历是指对树中所有结点的信息的访问,即依次对树中每个结点访问一次且仅访问一次,我们把这种对所有节点的访问称为遍历(traversal)。那么树的两种重要的遍历模式是深度优先遍历和广度优先遍历,深度优先一般用递归,广度优先一般用队列。一般情况下能用递归实现的算法大部分也能用堆栈来实现。

    那么深度遍历有重要的三种方法。这三种方式常被用于访问树的节点,它们之间的不同在于访问每个节点的次序不同。这三种遍历分别叫做先序遍历(preorder),中序遍历(inorder)和后序遍历(postorder)。

    先序遍历
    在先序遍历中,我们先访问根节点,然后递归使用先序遍历访问左子树,再递归使用先序遍历访问右子树

    中序遍历
    在中序遍历中,我们递归使用中序遍历访问左子树,然后访问根节点,最后再递归使用中序遍历访问右子树

    后序遍历
    在后序遍历中,我们先递归使用后序遍历访问左子树和右子树,最后访问根节点
    在这里插入图片描述

    广度优先遍历(层次遍历)
    从树的root开始,从上到下,从左到右遍历整个树的节点

    展开全文
  •  第一题 : 要求写出至少两种排序算法(代码精练,效率其次) 第二题 : M个猴子围成一圈,每个有一个编号,编号从1到M。打算从中选出一个大王。经过协商,决定选大王的规则如下:从第一个开始,每隔N个,数到的...

    今天去面试.做了12道面试题其中有4道是选做,有4道算法题,有4道概念题 .都为简答题!

     

     

    第一题 :

     

    要求写出至少两种排序算法(代码精练,效率其次) 

     

     

    第二题 :

     

    有M个猴子围成一圈,每个有一个编号,编号从1到M。打算从中选出一个大王。经过协商,决定选大王的规则如下:从第一个开始,每隔N个,数到的猴子出圈,最后剩下来的就是大王。要求:从键盘输入M,N,编程计算哪一个编号的猴子成为大王。

     

           用JAVA代码实现

     

     第三题 :

     

    八皇后问题是一个古老而著名的问题,是回溯算法的典型例题。该问题是十九世纪著名的数学家高斯1850年提出:在8X8格的国际象棋上摆放八个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列或同一斜线上,问有多少种摆法。

     

           用JAVA代码实现

     

     

    展开全文
  • 算法的特性

    千次阅读 2012-07-11 00:08:16
    首先,我们要了解什么是算法:算法就是解决特定问题的求解步骤的描述,在计算机中表现为指令的有效序列,并且每一条指令...算法至少有一个或者多个输出,不然我们设计算法来干嘛! 2.穷性 指算法都会在有限的
  • 算法——简介

    2018-10-02 17:27:17
    算法应具有0个或多个输入至少一个输出。 穷性: 算法应经过有限的步骤后自然结束,并且是在可接受的时间内。 确定性: 算法中的每一步都应具有确定的含义,不会出现歧义。 可行性: 算法的每一步都应该是可行的...
  • 算法笔记:贪心算法

    2020-02-23 11:32:43
    有一个数字游戏叫做2048,此游戏的规则为,两个相同的数字能进行想加。例如:两个2可以想加, 则相加后4的个数加一,2的个数会减二。 现在一串数字,为目前已知的数字的数量。问至少还需要次相加,才能获得2048...
  • 目录一、算法的概念1.1 算法是计算机处理信息的本质二、时间复杂度T(n)2.1 程序执行的基本操作与时间复杂度...输出: 算法至少有1个或多个输出 有穷性: 算法在有限的步骤之后会自动结束而不会无限循环,并且每一个步骤可
  • 上数学课时,老师给了LYH一些闭区间,让他取尽量少的点,使得每个闭区间内至少有一个点。但是这天LYH太忙了,你们帮帮他吗? 输入 多组测试数据。 每组数据先输入一个N,表示有N个闭区间(N≤100)。 接下来N行,...
  • 输出: 算法至少有1个或多个输出 有穷性: 算法在有限的步骤之后会自动结束而不会无限循环,并且每一个步骤可以在可接受的时间内完成 确定性: 算法中的每一步都有确定的含义,不会出现二义性 可行性: 算法的每一步都...
  • 课题二 算法与程序设计 教学内容 程序设计算法描述 教学目的 掌握...可以有一个或多个输入 至少有一个或多个输出 2算法的描述方法 语言描述流程图N-S图 3S=1+2+3++100累加和的算法描述 语言描述 第一步累加和S=0加数K=1
  • (2)大整数:因为涉及到百位的大整数运算,如这里规定p是512位,先封装一个大整数类BigNumber,BigNumber的成员变量sign, length, uint32_t number[MAXLENGTH], MAXLENGTH规定为128,也就是说这个BigNumber最多...
  • 算法的设计要求

    千次阅读 2012-07-11 22:21:01
    一个优秀的算法应该具备的设计要求主要以下点: 正确性 算法的正确性是指算法至少具有输入,输出和加工处理无歧义,并且可以正确反映问题的需求,以及正确得到问题的答案。 关于“正确”的理解一共四个...
  • 操作可通过已实现基本运算执行有限次而完成 输入:有多个或者0个输入 输出:至少有一个或者多个输出算法的特征: 正确性: 程序没有语法错误 程序对于组输入数据能够得出满足规格说明要求...
  • 算法复习1【未完...】

    2020-06-29 23:06:43
    (2)输出:算法产生至少一个量作为输出。这些输出是和输入有某种特定关系的量。 (3)确定性:组成算法的每条指令是清晰,无歧义的。 (4)有限性(穷性):算法中每条指令的执行次数是有限的,执行每条指令的时间也是...
  • 至少有一个或者多个输出 可行性 : 原则上精确进行,操作可以通过已实现基本运算执行有限次而完成 正确性 (四个层次) 1. 不含有语法错误 2. 对于组数据可以得出满意的结果 3. 程序对于精心挑选的典型。苛刻...
  • 1、输入输出:算法具有零个或多个输入至少有一个或多个输出,可以是打印输出,也可以是返回一个或多个值等。2、有穷性:算法在执行有限的步骤之后,自动结束而不会出现 死循环,并且每一个步骤在可接受的时间内...
  • 可以有0个输入,但至少有一个输出。 2)确实性。相同的输入,输出不会出现二义性。 3)有穷性。算法不会出现无限循环的,总有个时间能执行完。 4)可行性。这个不怎么好理解,粗略地认为每一步都必须是可行的。 ...
  • n 个建筑物,第 i 个建筑物在笛卡尔坐标系上的坐标为 (xi,yi),你需要在 x 轴上安装一些雷达,每个雷达的侦察半径均为d ,要求每个建筑物都至少一个雷达侦测到,求最少要安装几个雷达。 输入格式 第一行两个正...
  • 牛客算法-拆分序列

    2020-03-03 15:12:20
    牛牛有个长度为n的整数数组A,他现在 任务是把数组A分为若干段排序子序列,牛牛想知道他最少可以把这数组分为段排序子序列,如样例所示,牛牛可以把数组A划分为[1,2,3]和[2,2, 1两排序子序列,至少需要划 ...
  • 2.输出:至少有一个或多个输出 3.有穷性:在执行有限步骤后自动退出后不会出现死循环,而且每一个步骤在可接受的时间内完成 4.确定性:每一个步骤都有确定的含义,不会有二义性  在一定条件下只有一条执行路径,...
  • Java算法——并查集

    2021-01-26 15:15:28
    在中国古代,人们都比较重视血缘传承,几乎每家都至少有一个男孩,后人总会牢记自己的祖先,这样就了家谱 / 族谱。根据家谱 / 族谱,可以将后面代人通过祖先的祖先都联系起来,使大家千万年前都是一家人。 ...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 184
精华内容 73
关键字:

一个算法至少有几个输入