精华内容
下载资源
问答
  • 数据流聚类算法clustream C. C. Aggarwal等人在2003年提出了该著名的经典数据流聚类框架。它引入了簇和时间帧结构两个主要的概念,将数据流聚类过程分为在线部分(微聚类)和离线部分(宏聚类)。在线部分实时处理新...
  • 数据流聚类算法D-stream的代码,太难了,想参考求教!!!

    求数据流聚类算法D-stream的代码,太难了,想参考求教!!!

    展开全文
  • 排序和数据结构算法 此存储库是一个C#库,具有已实现的排序算法,结构及其算法。 排序算法: 稳定,通用: 不稳定,通用: 非比较算法: -为整数实现 -为整数实现 -为整数实现 -为整数实现 为字符串实现 数据...
  • 该文件记载目前各种流行降噪算法代码下载地址及对应的文档地址,可进行自由下载;算法包括NLM、BM3D、KSVD等传统常规算法,也包括DnCNN、WaveletCNN等新的深度学习算法,并且记录相应测试数据集的下载地址可供自由...
  • 最大流算法完整代码

    2014-04-06 14:57:00
    看过的最大流算法中,薛超英教授的《数据结构》第5章应该是讲的比较易懂的,里面没有一开始就上来一堆符号。在线阅读地址: http://max.book118.com/html/2012/0630/2313684.shtm ... 书中提供的算法属于未经优化的...

    看过的最大流算法中,薛超英教授的《数据结构》第5章应该是讲的比较易懂的,里面没有一开始就上来一堆符号。在线阅读地址:

    http://max.book118.com/html/2012/0630/2313684.shtm

    http://www.doc88.com/p-407189007451.html

    书中提供的算法属于未经优化的Ford-Fulkerson算法,可以学会此方法后再学习其他方法。算法原理是:

    Ford-Fulkerson 方法 (G,s,t)
    1 将各边上流量 f 初始化为 0
    2 while 存在一条增广路径 p
    3     do 沿路径 p 增广流量 f
    4 return f

    上面提到的书写的很通俗,但是个人感觉有个问题是第5章图算法安排的位置有点靠前。另外作者是学院派写代码有2点不好的地方:一是经常用单个字母命名变量,这样带来的最大问题是当用Ctrl+F查找变量时,难以查找;二是比较喜欢用do-while循环,可读性没有for好。另外我写算法喜欢把输入数据直接写在初始化代码中,便于检查算法效果和调试。

    下面是根据书中算法写的代码:

    #include<iostream>
    #include<cmath>
    using namespace std;
    
    const int SCALE=6;
    int matrix[SCALE][SCALE]={0};
    int flow[SCALE][SCALE]={0};
    int stk[SCALE]={0};
    
    void init()
    {
        matrix[0][1]=4;
        matrix[1][2]=4;
        matrix[2][3]=2;
        matrix[4][3]=6;
        matrix[4][5]=9;
        matrix[0][2]=8;
        matrix[2][4]=2;
        matrix[3][5]=7;
        matrix[1][3]=4;
        matrix[1][4]=1;
    }
    
    int findPath()
    {
        int mark[SCALE];
        for(int i=0;i<SCALE;i++)mark[i]=0;
    
        int top=0;
        stk[top]=0;
        mark[top]=1;
    
        while(top>=0)
        {
            int current=abs(stk[top]);
            int i=0;
            for(i=0;i<SCALE;i++)
            {
                if(mark[i]==0)
                {
                    if(matrix[current][i]>flow[current][i])
                    {
                        top+=1;
                        stk[top]=i;
                        mark[i]=1;
    
                        if(i==(SCALE-1))
                        {
                            return top;
                        }
                        break;
                    }
                    else if(flow[i][current]>0)
                    {
                        top+=1;
                        stk[top]=(-i);
                        mark[i]=1;
                        break;
                    }
                }
            }
            if(i==SCALE)
            {
                top=top-1;
            }
        }
        return 0;
    }
    
    void update(int top)
    {
        int addValue=65535;
        for(int i=1;i<=top;i++)
        {
            int temp=0;
            int first=abs(stk[i-1]);
            int second=abs(stk[i]);
    
            if(stk[i]>0)
            {
                temp=matrix[first][second] - flow[first][second];
            }
            else
            {
                temp=flow[second][first];
            }
    
            if(addValue>temp)
            {
                addValue=temp;
            }
        }
    
    
        for(int i=1;i<=top;i++)
        {
            int first=abs(stk[i-1]);
            int second=abs(stk[i]);
    
            if(stk[i]>0)
            {
                flow[first][second] = flow[first][second]+addValue;
            }
            else
            {
                flow[second][first] = flow[second][first]-addValue;
            }
        }
    
    }
    
    int maxFlow()
    {
        int val=0;
        while((val=findPath())>0)update(val);
    
        int maxVolumn=0;
        for(int i=1;i<SCALE;i++)
        {
            maxVolumn += flow[0][i];
        }
    
        return maxVolumn;
    }
    
    int main()
    {
        init();
    
        cout<<maxFlow();
    
        return 0;
    }
    

      

    转载于:https://www.cnblogs.com/eternalwt/p/3648518.html

    展开全文
  • 数据流的中位数 基本思想:使用一个最小堆minHeap(Java PriorityQueue默认为最小堆)和一个最大堆maxHeap,在输入数字的过程中,保证 maxHeap.peek() <= minHeap.peek() maxHeap.size()与minHeap.size()相差不...

    题目链接:面试题41. 数据流的中位数

    基本思想:使用一个最小堆minHeap(Java PriorityQueue默认为最小堆)和一个最大堆maxHeap,在输入数字的过程中,保证

    1. maxHeap.peek() <= minHeap.peek()
    2. maxHeap.size()与minHeap.size()相差不超过1

    维护上面两个属性很简单,且看代码:

    class MedianFinder {
        private PriorityQueue<Integer> minHeap, maxHeap;
    
        public MedianFinder() {
            minHeap = new PriorityQueue<>();
            maxHeap = new PriorityQueue<>((a, b) -> b - a);
        }
        
        public void addNum(int num) {
            if (maxHeap.size() <= minHeap.size()) {
                minHeap.add(num);
                maxHeap.add(minHeap.remove());
            } else {
                maxHeap.add(num);
                minHeap.add(maxHeap.remove());
            }
        }
        
        public double findMedian() {
            if (minHeap.size() == maxHeap.size()) {
                if (minHeap.isEmpty()) return Double.NaN;
                else return (minHeap.peek() + maxHeap.peek()) / 2.0;
            } else if (maxHeap.size() > minHeap.size()) {
                return maxHeap.peek();
            } else {
                return minHeap.peek();
            }
        }
    }
    
    展开全文
  • 常用源代码 包括很多经典算法 数学问题: 1.精度计算——大数阶乘 2.精度计算——乘法(大数乘小数) 3.精度计算——乘法(大数乘大数) 4.精度计算——加法 5.精度计算——减法 6.任意进制转换 7.最大公约数、...
  • 1.单指令多数据流首先来看一段简单的if-else语句:if(A) { B = 1;//Instruction S1 C = 2;//Instruction S2 } else { B = 3;//Instruction S3 C = 4;//Instruction S4 } 假设代码中每条语句转换成指令后分别是S1...

    1.单指令多数据流

    首先来看一段简单的if-else语句:

    if(A)
    {
        B = 1;//Instruction S1
        C = 2;//Instruction S2
    }
    else
    {
        B = 3;//Instruction S3
        C = 4;//Instruction S4
    }
    

    假设代码中每条语句转换成指令后分别是S1、S2、S3、S4.

    如果在CPU的单指令单数据流中,A=true时会取指令S1和S2执行,A=false时会取指令S3和S4执行,不存在A=true和A=false同时存在的这种情况。

    但是在GPU的单指令多数据流(SIMD)中却存在A=true和A=false同时存在的情况。

    如下图所示是GPU单指令多数据流的执行情况:

    8dc0314371204423c3c2925bef510d36.png

    从图中可以看到,GPU共有4个通道lane1、lane2、lane3、lane4,分别对应4笔不同的数据。这四个通道共享同一组指令S1、S2、S3、S4(如图中左边所示)。但是在4个不同的lane中,A的值在不同的lane中有时是true,有时是false。红色表示执行该指令,橙色表示不执行该指令。

    如果按照CPU单指令单数据流的方式去编译,生成的汇编指令是大概这样的:

    goto     !A , Labe1;//如果A为false,跳转
    mov      B , 1;//指令S1
    mov      C , 2;//指令S2
    Lable1:
    mov      B , 3;//指令S3
    mov      C , 4;//指令S4
    

    可以看到goto指令会根据A的值进行跳转,GPU中A的值在不同的lane中取值不同,不同的lane根据自己的A值进行跳转是行不通的。因为所有的lane共享同一组指令,不可能有的lane在执行S1、S2语句,有的lane在执行S3、S4语句。

    所以GPU的指令应该转换成顺序执行,类似与下面这种。

    (p0) mov      B , 1;//指令S1
    (p0) mov      C , 2;//指令S2
    (p1) mov      B , 3;//指令S3
    (p1) mov      C , 4;//指令S4
    

    此时不同的lane都会按照顺序取值S1,S2,S3,S4,但是具体的lane中会根据前面的p寄存器的取值确定是否执行该指令。例如对于同一条指令S1,根据A的输入,有的lane是执行的(红色),有的lane是不执行的(橙色)。

    一句话总结就是:GPU是单指令多数据流(SIMD)架构,当多笔数据过来时,不一定同时跳转,本文介绍的if-conversion算法能够消除所有的跳转指令,可以将控制依赖转换为数据依赖。

    2.if-conversion算法

    总共分四步:

    1. 计算直接后继支配节点
    2. 计算控制依赖CD
    3. 计算R&K函数
    4. Augment K

    首先要计算直接后继支配节点,因为在控制依赖CD的计算中需要用到。

    什么是控制依赖CD,一个简单的例子就是if语句中的block y是受if语句所在的block x所控制的。此时CD(y) = x, 称为y控制依赖于x。

    R&K分别对应寄存器p的use与def,即寄存器p的使用与定义。

    R(x):表示分配给block x的谓词寄存器。block x的执行与否受R(x)中的寄存器控制。也可以说是p的use,即寄存器p用于block x。

    K(p):表示谓词寄存器p需要在K(p)中的block中定义。也就是寄存器的def,即寄存器p在那个block定义。

    2.1 直接后继支配节点

    首先要弄清楚两个概念:后继支配节点、直接后继支配节点。

    后继支配节点:如果从节点y到出口节点的每一条路径都经过节点x,则x为y的后继支配节点。

    记作:x pdom y

    直接后继支配节点:x pdom y,不存在节点z,使得x pdom z 且 z pdom y。 则x为y的直接后继支配节点。

    记作:x ipdom y

    计算后继支配节点的迭代算法:

    change = true;
    //init pdom set
    pdom(exit_block) = {exit_block}
    pdom(0:eeit_block-1) = {all blocks}
    //iterate flow graph
    while(change)
    {
      change = false;
      for( each block n) with post order
      {
        tmp = {all blocks}; 
        //求节点n所有直接后继节点的共同后继支配节点
        for(each n's successor block p)
        {
          tmp = tmp & pdom(p);//求交集
        }
        //n的后继支配节点包括他本身
        tmp = tmp | {n};
        if(tmp!=pdom(n))
        {
          pdom(n) = tmp;
          change = true;
        }
      }
    }
    

    求后继支配节点的算法一句话概括:节点n的后继支配节点包括他本身,以及他所有直接后继节点的共同后继支配节点。

    计算直接后继支配节点的算法:

    //remove itself from it's pdom set
    for each node n
    {
      pdom(n)-={n};
    }
    
    for each node n with post order
    {
      for each s in pdom(n){
      //移除直接后继支配节点的后继支配节点 
        for each t in set( pdom(n)-s ){
          if( t is in pdom(s) )
            pdom(n)-={t}
        }
      }
    }
    

    后继支配节点 = 直接后继支配节点 + (直接后继支配节点)的后继支配节点

    前面已经求出了后继支配节点,因此在后继支配节点中移除(直接后继支配节点)的后继支配节点,即可得到直接后继支配节点。

    下图是一个计算直接后继支配节点的例子:

    b708e64fb32cadf5930be130ac29c3b4.png

    2.2. CD

    CD是Control Dependent的缩写。直接上英文定义可能更准确一些,详细证明可参考文章末尾给出的论文,公众号后台回复SIMD关键字即可下载。

    Y is control dependent on X iff

    (1) there exists a directed path P from X to Y with any Z in P (excluding X and Y) post-dominated by Y

    (2) X is not post-dominated by Y.

    计算CD的算法:

    pdom(x) = {y in N: y pdom x}
    ipdom(x) = {y in N: y ipdom x}
    
    for [x,y,label] in E such that y not in pdom(x)
    {
        Lub = ipdom(x);
        if !label 
          x = -x
        t = y;
        while(t!=Lub)
        {
          CD(t) = CD(t) U {x}//U表示求并集
          t = ipdom(t);
        }
    }
    

    上述伪代码中的!label表示由block x到block y的执行条件为false。

    计算CD的算法用一句话概括: 对于[x,y,label],在支配节点树中,从ipdom(x)到y的路径上的所有节点都控制依赖于x,不包括ipdom(x)。

    以[1,2,true]为例,ipdom(x) = 7,从下面的后继支配节点树可知,7到2经过的节点有6,2(不包括7),因此节点6和2都控制依赖于节点1.

    96fcc0f62f4388f3e04403bf4d209c9d.png

    下图是CD计算的结果:整篇文章都使用同一个控制流图作为实例

    bac9dfca84b0d2dfe0f8934466268a7d.png

    2.3. 计算R&K

    p = 1;
    for x in N
        t = CD(x);
        if t in K
        {
            //性质2
            R(x) = q such that K(q) = t;
        }
        else
        {
            K(p) = t;
            R(x) = p++;
        }
    

    性质1:每一个block x有且仅有一个对应的p = R(x)

    性质2:对与两个不同的block,如果它们的控制依赖都为k(p),则这两个block对应的寄存器都为p(对应上述算法中的if语句)

    d3ce5e5534dbd18b4b40e5078c8947be.png

    2.4. Augment K

    k(p)表明p需要在哪些block初始化,但是存在一条路径,刚好没有经过k(p),这个时候p没有被初始化。因此需要在start节点对p进行初始化。

    主要是针对类似的if语句嵌套:

    //原始的控制流
    if(condition1)
    {
        block1
        if(codition2)
        {
            block2
        }
        else
        {
            block3
        }   
    }
    

    上面的控制流最终会转化成如下的顺序执行,只是每个block会有一个p寄存器去guard。

    最终会转化为这样:

    //转换后的顺序执行,是否执行受p寄存器控制
    (p1) block1;//p2与p3都会在block1中初始化
     (p2) block2;
     (p3) block3;
    

    原始的控制流中p2与p3都会在block1中初始化,如果block1没有执行,那么p2与p3就没有被初始化。因此需要在开始节点处将p2与p3初始化为false。

    为什么初始化为false而不是true?因为block1没有执行,说明block2与block3也不应该执行,所以初始化为false。

    上述过程是为什么要做Augment K,实际上Augment K要做的只有一件事:找到未初始化的寄存器p,在start节点处将p初始化为false。

    在程序中找到为初始化的变量很简单,从后向前做活跃变量分析,如果变量在入口处还是活跃的,则该变量每有被初始化。

    因为从后向前做活跃变量分析的时候,变量的每次定义都会被Kill掉(公式1),如果在程序的入口处都没有被Kill掉说明该变量是没有被初始化过的。

    (公式1)

    (公式2)

    本算法中只需要对p寄存器进行活跃变量分析,use和def分别对应已经求出的R与K。

    894eec6357faf47fd3f5ceb49bd983b2.png

    四个步骤做完后最终的结果如下:

    6b2fcadf75331827c29bb048f5e1cf78.png

    图中B2(t2)p2表示寄存器p2控制B2,条件t2与B2相关联。

    3.后记

    接下来准备写的文章:

    1.静态单赋值(SSA)

    目前GCC与LLVM都是基于SSA进行后端编译器优化的。

    2.基于SSA的稀有条件常数传播(SCCP)

    SCCP是后端编译优化中的经典算法。

    3.基于图着色的寄存器分配算法

    寄存器分配算法是编译器后端算法中比较复杂的算法,基于图着色的寄存器分配算法的中文资料非常少。

    1. 关于支配概念的总结

    4.往期阅读

    GPU探秘:从计算机图形学到人工智能mp.weixin.qq.com
    6cb63e66479105757ec2a0ee75db2e39.png

    欢迎关注我的个人公众号(程序芯世界),主要通过写作加深理解,也希望认识更多对这方面感兴趣的朋友,欢迎交流。

    展开全文
  • 常用算法代码

    2017-09-11 11:26:53
    Structure 数据结构 17 | 求某天是星期几 17 | 左偏树 合并复杂度 O(LOG N) 17 | 树状数组 17 | 二维树状数组 17 | TRIE 树(K 叉) 17 | TRIE 树(左儿子又兄弟) 18 | 后缀数组 O(N * LOG N) 18 | 后缀数组 O...
  • 如何得到一个数据流中的中位数?如果从数据流中读出奇数个数值,那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值,那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert...
  • 本程序演示利用KMP算法在文件中搜索快速搜索数据,有时要搜索的数据量过大时,或者在一个低速的(如...此类情况应当使用的方式进行搜索,这份代码使用KMP算法和状态机的原理,演示如何在一个中高效的搜索数据
  • 如何得到一个数据流中的中位数? 如果从数据流中读出奇数个数值,那么中位数就是所有数值排序之后位于中间的数值。 如果从数据流中读出偶数个数值,那么中位数就是所有数值排序之后中间两个数的平均值。 我们使用...
  • 算法练习篇之:数据流中的中位数 题目描述解题思路代码实现总结 题目描述 如何得到一个数据流中的中位数?如果从数据流中读出奇数个数值,那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个...
  • 数据流中的算法 思路:  线段树模拟;  时间刚刚卡在边界上,有时超时一个点,有时能过; 来,上代码: #include <cstdio> #include <cstring> #include <iostream> #include <...
  • 数据结构与算法之字符凭拼接最低字典序和数据流中取中位数 目录 字符凭拼接最低字典序 数据流中取中位数 1. 字符凭拼接最低字典序 题目描述 思路: 创建一个比较器,比较的内容是(o1+o2)...
  • WorkflowSim中HEFT调度算法代码解读

    千次阅读 2019-05-30 19:36:16
    WorkflowSIm中的HEFT算法代码解读 HEFT(异构计算环境下最早完成时间算法) WorkflowSim是一个用于模拟工作调度的集成仿真平台,内置了部分基础的工作调度算法,今天就为大家介绍最为基础的HEFT算法。 1.算法...
  • 1.单指令多数据流 首先来看一段简单的if-else语句: if(A) { B = 1;//Instruction S1 C = 2;//Instruction S2 } else { B = 3;//Instruction S3 C = 4;//Instruction S4 } 假设代码中每条语句转换成指令后...
  • 常用算法代码(vc++)

    2010-04-05 13:21:22
    包含图论,网络数据结构,数论,递归,线段几何等基础算法代码,比较全。
  • 收集C ++和Java中的算法数据结构 数据结构 段树 没有递归的段树 2D树 Fenwick树 带有扩展操作的Fenwick树 持久树 重心分解 重/轻分解 链接/剪切树 连接查询链接/剪切树 LCA查询链接/剪切树 二...
  • 数据结构算法

    2019-12-26 19:40:35
    1. 最大流算法的教程 概念: 有白话,有图示,有代码 https://www.cnblogs.com/ZJUT-jiangnan/p/3632525.html 2. 最小生成树算法: 概念:对于一个图G,它有一个制图g。如果g包含所有的顶点,同时边...
  • 数据结构与算法分析:C语言描述(原书第2版)》内容简介:书中详细介绍了当前流行的论题和新的变化,讨论了算法设计技巧,并在研究算法的性能、效率以及对运行时间分析的基础上考查了一些高级数据结构,从历史的角度...
  • 数据流挖掘增量模糊决策树分类算法,代码完善,仅供学习
  • 通过JavaScript学习数据结构和算法 您需要对JavaScript编程语言有基本的了解,才能继续进行此存储库中的代码。 目录 堆 哈希表 ...流算法 最大流量 最小切割 最小成本最大流量 最大二分匹配 顶点覆盖
  • 处理限的过程中发现gateway提供了一种基于令牌桶的分布式限实现,非常感兴趣,于是在经过一番处理,从gateway的源码中提取出一个轻量的基于令牌桶算法的分布式限工具,供参考选用。SpringCloudGateway将限的...
  • 数据流中最频繁的元素,下面用MG算法近似解决求解这个问题。 代码 Java import java.util.*; public class FrequentElement { public static void main(String[] args) { int k = 3;//计数器的个数 Random ...
  • 直接暴力解就可以 AC,不过需要进行一些优化,也不能太暴力了,需要一些技巧,具体看代码吧!对了,如果暴力搞,还需要输入外挂,否则会 TLE。当然,也有其他办法,求中位数的部分可以使用线段树搞搞事情。一开始...
  • 在深入研究代码之前,让我们先了解一下K-Means算法的背景知识。K均值聚类算法K-Means算法是最流行但最简单的无监督算法。对于散布在n维空间中的所有数据点,它会将具有某些相似性的数据点归为一个群集。在随机初始化...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,926
精华内容 770
关键字:

数据流算法代码