【数据结构】图算法和LRUCache

news2024/12/25 12:42:06

文章目录

  • 最小生成树
    • 1.最小生成树概念
    • 2.Kruskal算法
    • 3.Prim算法
  • 最短路径算法
    • 单源最短路径--Dijkstra算法
    • 单源最短路径--Bellman-Ford算法
    • 多源最短路径--Floyd-Warshall算法
  • LRUCache
    • LRUCache实现
  • 源码地址

最小生成树

1.最小生成树概念

连通图中的每一棵生成树，都是原图的一个极大无环子图，即：从其中删去任何一条边，生成树就不在连通；反之，在其中引入任何一条新边，都会形成一条回路。

若连通图由n个顶点组成，则其生成树必含n个顶点和n-1条边。因此构造最小生成树的准则有三条：

  1. 只能使用图中的边来构造最小生成树
  2. 只能使用恰好n-1条边来连接图中的n个顶点
  3. 选用的n-1条边不能构成回路

最小生成树，也就是图的生成树中权值最小的树。最小生成树的常用算法有Kruskal算法 和**Prim算法。**算法的思想都是贪心策略。

2.Kruskal算法

核心：贪心思想。

逐步选择当前图中的最小边，选择边构成生成树。要注意选择的边不能构成环。

image-20221207195837894

如何判断是否有环？ 并查集

被选择的边的点合并到一共集合中。如果被选中的边两端的点已经在一共集合中，说明构成了环。

下面用图的邻接矩阵实现克鲁斯卡尔算法。

 //克鲁斯卡尔算法
W Kruskal(self &minTree)
{
    //构建一共只有点，没有边的图。后续最小生成树的边往图里面添加
    size_t n = _vertexs.size();
    minTree._vertexs = _vertexs;
    minTree._indexmap = _indexmap; 
    minTree._matrix.resize(n);
    for (int i = 0; i < n; i++)
    {
        minTree._matrix[i].resize(n, MAX_W);
    }
    //将所有的边，放入到一个优先级队列中
    priority_queue<edge, vector<edge>, greater<edge>> minque;
    for (size_t i = 0; i < n; i++)
    {
        for (size_t j = 0; j < n; j++)
        {
            //无向的，保证不重复的选择边
            if (i < j && _matrix[i][j] != MAX_W)
            {
                //将边插入到优先级队列中
                minque.push(edge(i, j, _matrix[i][j]));
            }
        }
    }
    //依次选边
    W ret = W();      //总的权值
    int edge_num = 0; //一共要选择n-1条边
    //并查集判断是否有环
    UnionFindSet<V> points;
    //将图的点依次插入到并查集中
    for (int i = 0; i < _vertexs.size(); i++)
    {
        points.insert(_vertexs[i]);
    }
    while (!minque.empty())
    {
        edge min = minque.top();
        minque.pop();
        //判断是否成环
        if (!points.InSet_index(min._srci, min._dsti))
        {
            //添加边
            minTree._addedge(min._srci, min._dsti, min._w);
            points.Union(min._srci, min._dsti);
            edge_num++;
            ret += min._w;
        }
    }
    //判断边是否选完
    if (edge_num != n - 1)
    {
        return W();
    }

    return ret;
}

测试克鲁斯卡尔算法

void leaset_tree()
{
    const char* str = "abcdefghi";
    matrix::Graph<char, int> g(str, strlen(str));
    g.addedge('a', 'b', 4);
    g.addedge('a', 'h', 8);
    // g.AddEdge('a', 'h', 9);
    g.addedge('b', 'c', 8);
    g.addedge('b', 'h', 11);
    g.addedge('c', 'i', 2);
    g.addedge('c', 'f', 4);
    g.addedge('c', 'd', 7);
    g.addedge('d', 'f', 14);
    g.addedge('d', 'e', 9);
    g.addedge('e', 'f', 10);
    g.addedge('f', 'g', 2);
    g.addedge('g', 'h', 1);
    g.addedge('g', 'i', 6);
    g.addedge('h', 'i', 7);
    //构建一颗最小生成树
    matrix::Graph<char, int> mintree;
    g.Kruskal(mintree);
    mintree.Print();
}

image-20221207200729581

3.Prim算法

Prim算法是从给定的结点出发，依次从被选择集合出发的点选择最小的边，被选中边的点加入到被选择集合中。

image-20221207200921392

下面用图的邻接矩阵实现克鲁斯卡尔算法。

W Prim(self &minTree, const V &src)
{

    size_t n = _vertexs.size();
    int srci = GetVertexIndex(src);
    minTree._vertexs = _vertexs;
    minTree._indexmap = _indexmap;
    minTree._matrix.resize(n);
    for (size_t i = 0; i < n; ++i)
    {
        minTree._matrix[i].resize(n, MAX_W);
    }
    vector<bool> choice(n, false);
    vector<bool> nochoice(n, true);
    priority_queue<edge, vector<edge>, greater<edge>> minque;
    choice[srci] = true;
    nochoice[srci] = false;
    for (size_t i = 0; i < n; i++)
    {
        if (_matrix[srci][i] != MAX_W)
        {
            minque.push(edge(srci, i, _matrix[srci][i]));
        }
    }
    size_t edge_num = 0;
    W total = W(); //返回值
    while (!minque.empty())
    {
        edge min = minque.top();
        minque.pop();
        //判断当前的边是否合法
        if (choice[min._dsti])
        {
            // do nothing
        }
        else
        {
            //将当前边添加到图中
            minTree._addedge(min._srci, min._dsti, min._w);
            choice[min._dsti] = true;
            nochoice[min._dsti] = false;
            edge_num++;
            total += min._w;
            if (edge_num == n - 1)
            {
                break;
            }
            for (size_t i = 0; i < n; i++)
            {
                if (nochoice[i] && _matrix[min._dsti][i] != MAX_W)
                {
                    minque.push(edge(min._dsti, i, _matrix[min._dsti][i]));
                }
            }
        }
    }
    if (edge_num != n - 1)
    {
        return W();
    }
    return total;
}

测试Prim算法

void leaset_tree()
{
    const char* str = "abcdefghi";
    matrix::Graph<char, int> g(str, strlen(str));
    g.addedge('a', 'b', 4);
    g.addedge('a', 'h', 8);
    // g.AddEdge('a', 'h', 9);
    g.addedge('b', 'c', 8);
    g.addedge('b', 'h', 11);
    g.addedge('c', 'i', 2);
    g.addedge('c', 'f', 4);
    g.addedge('c', 'd', 7);
    g.addedge('d', 'f', 14);
    g.addedge('d', 'e', 9);
    g.addedge('e', 'f', 10);
    g.addedge('f', 'g', 2);
    g.addedge('g', 'h', 1);
    g.addedge('g', 'i', 6);
    g.addedge('h', 'i', 7);
    //构建一颗最小生成树
    matrix::Graph<char, int> mintree;
    g.Prim(mintree,'a');
    mintree.Print();
}

image-20221207203535048

最短路径算法

单源最短路径–Dijkstra算法

也叫做单源最短路径算法，解决一个点到其余个点顶点的最短路径

image-20220619003829502

首先需要写出邻接矩阵

image-20220619003901576

使用dis数组存储源顶点(1号顶点)到其余个顶点的距离

image-20220619003958233

具体思路

  • 从初始的dis数组中找到最小值为2，那么1->2顶点的最短路径就成为了确定值，值为1。

  • 从顶点2开始出发，可以到达的顶点为2->3,2->4;其中如果中顶点2进行"中转",那么1->2->3的路径为1(1->2的最短路径)+9(2->3的路径)为10，小于1->3的距离12，所以将dis数组中1->3的值变为10；对2->4进行同样的处理1->4的最短路径更新为4。

image-20220619005019121

在现在的dis数组中，确定的顶点有2；而第一次松弛后除去到顶点2的最短路径为1->4(路径长度为4)，顶点4为确定值。从4开始出发

  • 可以到达的顶点有3，5，6；将顶点4作为"中转"进行第二轮的松弛

image-20220619005311208

现在的确定的顶点为2，4；剩下顶点的最短路径为1->3,顶点3为最短路径，变为确定值；

进行下一轮的松弛

image-20220619005419967

最终的松弛结果为：

image-20220619005447294

dis数组中存放了到各顶点的最短路径

// Dijkstra是单源最短路算法，可以计算给定点到其他点的最短路
void Dijkstra(const V &src, vector<W> &dist, vector<int> &parentindex)
{
    // dist，记录到i点的当前最短路是多少
    int srci = GetVertexIndex(src);
    size_t n = _vertexs.size();
    dist.resize(n, MAX_W);
    parentindex.resize(n, -1);
    parentindex[srci] = srci;
    vector<bool> visited(n, false);
    //先对dist数组进行初始化
    /*
    for(size_t i=0;i<n;i++){
        if(_matrix[srci][i]!=MAX_W){
            dist[i]=_matrix[srci][i];
        }
    }
    visited[srci]=true;
    */
    dist[srci] = 0;
    //寻找最短的路径,每一轮对其中一个点进行松弛处理,一共要进行n轮
    for (size_t i = 0; i < n; i++)
    {

        //记录这一轮的最小路径和最小节点
        int min_index = 0;
        W min_num = MAX_W;
        //先找到当前一轮的最小值和最小节点
        for (size_t j = 0; j < n; j++)
        {
            if (!visited[j] && dist[j] < min_num)
            {
                min_num = dist[j];
                min_index = j;
            }
        }
        //当前的点为确定点
        visited[min_index] = true;
        //松弛处理
        for (size_t j = 0; j < n; j++)
        {
            if (!visited[j] && dist[min_index] + _matrix[min_index][j] < dist[j] && _matrix[min_index][j] != MAX_W)
            {
                dist[j] = dist[min_index] + _matrix[min_index][j];
                parentindex[j] = min_index;
            }
        }
    }
}

image-20221207204012948

测试接口

void TestGraphDijkstra()
{
    const char* str = "syztx";
    matrix::Graph<char, int,MAX, true> g(str, strlen(str));
    g.addedge('s', 't', 10);
    g.addedge('s', 'y', 5);
    g.addedge('y', 't', 3);
    g.addedge('y', 'x', 9);
    g.addedge('y', 'z', 2);
    g.addedge('z', 's', 7);
    g.addedge('z', 'x', 6);
    g.addedge('t', 'y', 2);
    g.addedge('t', 'x', 1);
    g.addedge('x', 'z', 4);
    vector<int> dist;
    vector<int> parentPath;
    g.Dijkstra('s', dist, parentPath);
    g.PrintShortPath('s', dist, parentPath);
    for (auto& d : dist) {
        cout << d << " ";
    }
    cout << endl;
}

image-20221207204057262

Dijkstra算法存在的问题是不支持图中带负权路径，如果带有负权路径，则可能会找不到一些路
径的最短路径。

单源最短路径–Bellman-Ford算法

bellman—ford算法可以解决负权图的单源最短路径问题。它的优点是可以解决有负权边的单源最短路径问题，而且可以用来判断是否有负权回路。它也有明显的缺点，它的时间复杂度 O(N*E) (N是点数，E是边数)普遍是要高于Dijkstra算法O(N²)的。像这里如果我们使用邻接矩阵实现，那么遍历所有边的数量的时间复杂度就是O(N^3)，这里也可以看出来Bellman-Ford就是一种暴力求解更新 。

image-20221207204454551

void Bellman_Ford(const V &src, vector<W> &dist, vector<int> &pPath)
{
    size_t n = dist.size();
    size_t srci = GetVertexIndex(src);
    dist.resize(n, MAX_W);
    pPath.resize(n, -1);
    dist[srci] = W();
    for (size_t k = 0; k < n - 1; ++k)
    {
        bool exchange = false;
        for (size_t i = 0; i < n; ++i)
        {
            for (size_t j = 0; j < n; ++j)
            {
                // srci->i + i->j < srci->j 则更新路径及权值
                if (_matrix[i][j] != MAX_W && dist[i] + _matrix[i][j] < dist[j])
                {
                    dist[j] = dist[i] + _matrix[i][j];
                    pPath[j] = i;
                    exchange = true;
                }
            }
        }
        if (exchange = false)
        {
            break;
        }
    }
    for (size_t i = 0; i < n; ++i)
    {
        for (size_t j = 0; j < n; ++j)
        {
            // 检查有没有负权回路
            if (_matrix[i][j] != MAX_W && dist[i] + _matrix[i][j] < dist[j])
            {
                return false;
            }
        }
    }
}

多源最短路径–Floyd-Warshall算法

弗洛伊德算法是一种纯暴力算法，每次以K为中转转，更新结点i到结点j的最大路径。

image-20221207204731818

//弗洛伊德算法是一种纯暴力算法
void FloydWarshall(vector<vector<W>> &vvDist, vector<vector<int>> &vvpPath)
{
    size_t n = _vertexs.size();
    vvDist.resize(n);
    vvpPath.resize(n);
    for (size_t i = 0; i < n; ++i)
    {
        vvDist[i].resize(n, MAX_W);
        vvpPath[i].resize(n, -1);
    }

    //初始化
    for (size_t i = 0; i < n; i++)
    {
        for (size_t j = 0; j < n; j++)
        {
            if (_matrix[i][j] != MAX_W)
            {
                vvDist[i][j] = _matrix[i][j];
                vvpPath[i][j] = i;
            }
            if (i == j)
            {
                vvDist[i][j] = W();
            }
        }
    }

    //弗洛伊德算法
    //依次以K结点为中转站更新最短路径
    for (size_t k = 0; k < n; k++)
    {
        for (size_t i = 0; i < n; i++)
        {
            for (size_t j = 0; j < n; j++)
            {
                if (vvDist[i][k] != MAX_W && vvDist[k][j] != MAX_W && vvDist[i][k] + vvDist[k][j] < vvDist[i][j])
                {
                    vvDist[i][j] = vvDist[i][k] + vvDist[k][j];
                    vvpPath[i][j] = vvpPath[k][j];
                }
            }
        }
    }

    //打印节点
    for (size_t i = 0; i < n; ++i)
    {
        for (size_t j = 0; j < n; ++j)
        {
            if (vvDist[i][j] == MAX_W)
            {
                // cout << "*" << " ";
                printf("%3c", '*');
            }
            else
            {
                // cout << vvDist[i][j] << " ";
                printf("%3d", vvDist[i][j]);
            }
        }
        cout << endl;
    }
    cout << endl;
    for (size_t i = 0; i < n; ++i)
    {
        for (size_t j = 0; j < n; ++j)
        {
            // cout << vvParentPath[i][j] << " ";
            printf("%3d", vvpPath[i][j]);
        }
        cout << endl;
    }
    cout << "=================================" << endl;
}

以下面的图进行测试

image-20221207204906198

void TestFloydWarShall()
{
    const char *str = "12345";
    matrix::Graph<char, int,MAX,true> g(str, strlen(str));
    g.addedge('1', '2', 3);
    g.addedge('1', '3', 8);
    g.addedge('1', '5', -4);
    g.addedge('2', '4', 1);
    g.addedge('2', '5', 7);
    g.addedge('3', '2', 4);
    g.addedge('4', '1', 2);
    g.addedge('4', '3', -5);
    g.addedge('5', '4', 6);
    vector<vector<int>> vvDist;
    vector<vector<int>> vvParentPath;
    g.FloydWarshall(vvDist, vvParentPath);
    // 打印任意两点之间的最短路径
    for (size_t i = 0; i < strlen(str); ++i)
    {
        g.PrintShortPath(str[i], vvDist[i], vvParentPath[i]);
        cout << endl;
    }
}

image-20221207205356042

LRUCache

LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。

什么是Cache(缓存)？

狭义的Cache指的是位于CPU和主存间的快速RAM， 通常它不像系统主存那样使用DRAM技术，而使用昂贵但较快速的SRAM技术。 广义上的Cache指的是位于速度相差较大的两种硬件之间， 用于协调两者数据传输速度差异的结构。除了CPU与主存之间有Cache， 内存与硬盘之间也有Cache，乃至在硬盘与网络之间也有某种意义上的Cache── 称为Internet临时文件夹或
网络内容缓存等。
Cache的容量有限，因此当Cache的容量用完后，而又有新的内容需要添加进来时， 就需要挑选并舍弃原有的部分内容，从而腾出空间来放新内容。LRU Cache 的替换原则就是将最近最少使用的内容替换掉。其实，LRU译成最久未使用会更形象， 因为该算法每次替换掉的就是一段时间内最久没有使用过的内容。

CPU三级缓存机制

image-20221207205745214

LRUCache实现

LRU Cache要保证获取和置换都是O(1)操作。常用方法是使用双向链表和哈希表的搭配 。双向链表存储Key-value键值对。Hash表中存放Key和链表结点的映射关系。

image-20221207205821680

class LRUCache{
public:
    LRUCache(int capacity)
        :capacity_(capacity)
    {}

    int get(int key){
        auto it=mp.find(key);
        //如果有该数据，就加入到头位置
        if(it!=mp.end()){
            //得到链表的迭代器
            auto list_iter=it->second;
            pair<int,int> listvalue=*list_iter;
            data.erase(list_iter);
            data.push_front(listvalue);
            mp[key]=data.begin();
            return listvalue.second;
        }
        //如果没有数据,返回-1
        else{
            return -1;
        }
    }


    void set(int key,int value){
        auto it=mp.find(key);
        if(it!=mp.end()){
            //如果已经有了key,更新数据,然后将其放在最前面
            auto list_iter=it->second;
            pair<int,int> list_value=*list_iter;
            list_value.second=value;
            data.erase(list_iter);
            data.push_front(list_value);    
            //更新Hash表
            mp[key]=data.begin();
        }
        //如果没有key,就需要判断容量
        //如果当前数量超过容量，就删除最后一个，负责之间在头添加即可
        else{
            if(data.size()>=capacity_){
               auto list_back=data.back();
               mp.erase(list_back.first);
               data.pop_back();
            }
            //向头部添加make_pair(key,value);
            data.push_front(make_pair(key,value));
            mp[key]=data.begin();
        }
    }
    //插入
private:
    unordered_map<int,list<pair<int,int>>::iterator> mp;
    //List存放一共K-Value类型的数据
    list<pair<int,int>> data;
    size_t capacity_;
};

146. LRU 缓存 - 力扣（LeetCode）

源码地址

Graph和LRUCache · 影中人/test - 码云 - 开源中国 (gitee.com)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/71729.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

软硬协同：基于倚天的视频云编码性能升级

软硬协同：基于倚天的视频云编码性能升级

算力时代&#xff0c;靠吃「硬件红利」便能搞定新应用场景的「甜蜜期」已经过去。人类社会的每一次科技跃迁&#xff0c;其本质都是计算力的突破与演进。 算盘拨出农耕文明的繁荣&#xff0c;机械计算机催生出第一次工业革命的袅袅蒸汽&#xff0c;而云计算的发展让万物互联成…
阅读更多...
Spark零基础入门实战（二）Scala基础之数据类型

Spark零基础入门实战（二）Scala基础之数据类型

在Scala中，所有的值都有一个类型，包括数值和函数。如图1-4所示，说明了Scala的类型层次结构。 Any是Scala类层次结构的根，也被称为超类或顶级类。Scala执行环境中的每个类都直接或间接地从该类继承。该类中定义了一些通用的方法，例如equals()、hashCode()和toString()。…
阅读更多...
【畅购商城】微信支付之支付模块

【畅购商城】微信支付之支付模块

目录 支付页面 接口 后端实现 ​​​​​​​前端实现​​​​​​​ ​​​​​​​支付页面 步骤一&#xff1a;创建 flow3.vue组件 步骤二&#xff1a;引入第三方资源&#xff08;js、css&#xff09; <script> import TopNav from ../components/TopNav impor…
阅读更多...
[附源码]Python计算机毕业设计Django疫情物资管理系统

[附源码]Python计算机毕业设计Django疫情物资管理系统

项目运行 环境配置&#xff1a; Pychram社区版 python3.7.7 Mysql5.7 HBuilderXlist pipNavicat11Djangonodejs。 项目技术&#xff1a; django python Vue 等等组成&#xff0c;B/S模式 pychram管理等等。 环境需要 1.运行环境&#xff1a;最好是python3.7.7&#xff0c;…
阅读更多...
电动汽车 （BEV） 优化调度（Matlab代码实现）

电动汽车 （BEV） 优化调度（Matlab代码实现）

&#x1f4a5;&#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️❤️&#x1f4a5;&#x1f4a5;&#x1f4a5; &#x1f389;作者研究&#xff1a;&#x1f3c5;&#x1f3c5;&#x1f3c5;本科计算机专业&#xff0c;研究生电气学硕…
阅读更多...
Vue3中的pinia使用（收藏版）

Vue3中的pinia使用（收藏版）

1.pinia介绍 pinia 是 Vue 的存储库&#xff0c;它允许您跨组件/页面共享状态。就是和vuex一样的实现数据共享。 依据Pinia官方文档&#xff0c;Pinia是2019年由vue.js官方成员重新设计的新一代状态管理器&#xff0c;更替Vuex4成为Vuex5。 Pinia 目前也已经是 vue 官方正式的状…
阅读更多...
原创 | 传统医药零售如何实现数字化转型

原创 | 传统医药零售如何实现数字化转型

一、数字化转型是零售药店未来实现增长的必由之路“十四五”规划将清洁能源、军事、消费、医药以及高端制造等行业定为未来需要重点关注的领域。围绕“医保、医疗、医药”三条主线&#xff0c;医药行业推出了一系列重要的改革措施&#xff0c;即将进入有史以来最大变革的黄金时…
阅读更多...
【Mysql 基础知识】

【Mysql 基础知识】

一、引言 #1.1 现有的数据存储方式有哪些&#xff1f; Java程序存储数据&#xff08;变量、对象、数组、集合&#xff09;&#xff0c;数据保存在内存中&#xff0c;属于瞬时状态存储。 文件&#xff08;File&#xff09;存储数据&#xff0c;保存在硬盘上&#xff0c;属于持久…
阅读更多...
Talk | 香港大学在读博士生马逴凡：重新思考分辨率对于高效视频理解的意义

Talk | 香港大学在读博士生马逴凡：重新思考分辨率对于高效视频理解的意义

本期为TechBeat人工智能社区第460期线上Talk&#xff01; 北京时间12月7日(周三)20:00&#xff0c;香港大电子电机在读博士生——马逴凡的Talk将准时在TechBeat人工智能社区开播&#xff01; 他与大家分享的主题是: “重新思考分辨率对于高效视频理解的意义 ”&#xff0c;届时…
阅读更多...
web课程设计：HTML非遗文化网页设计题材【京剧文化】HTML+CSS+JavaScript

web课程设计：HTML非遗文化网页设计题材【京剧文化】HTML+CSS+JavaScript

&#x1f389;精彩专栏推荐 &#x1f4ad;文末获取联系 ✍️ 作者简介: 一个热爱把逻辑思维转变为代码的技术博主 &#x1f482; 作者主页: 【主页——&#x1f680;获取更多优质源码】 &#x1f393; web前端期末大作业&#xff1a; 【&#x1f4da;毕设项目精品实战案例 (10…
阅读更多...
12.8 - 每日一题 - 408

12.8 - 每日一题 - 408

每日一句&#xff1a;成功与不成功之间有时距离很短只要后者再向前几步。 数据结构 1 若用冒泡排序方法对序列&#xff08;12&#xff0c;24&#xff0c;36&#xff0c;48&#xff0c;60&#xff0c;72&#xff09;从大到小排序&#xff0c;需要的比较次数是_____ A. 5 B. 1…
阅读更多...
Tableau制作三元相图/三角图（Ternary/Triangle Chart)

Tableau制作三元相图/三角图（Ternary/Triangle Chart)

三元相图 三角图就是有三个轴的坐标图&#xff0c;可以分别表示一个点在X、Y、Z三个维度上的不同比例情况。 与传统的XY坐标轴不同。XY坐标轴是有两个维度&#xff0c;而且每个维度没有上下限的限制。三角图中每个维度都在0-1的范围内&#xff0c;按百分比划分&#xff0c;即…
阅读更多...
图像处理算法实战应用案例精讲-【目标检测】YOLO

图像处理算法实战应用案例精讲-【目标检测】YOLO

前言 物体检测——顾名思义就是通过深度学习算法检测图像或视频中的物体。目标检测的目的是识别和定位场景中所有已知的目标。有了这种识别和定位，目标检测可以用来计数场景中的目标，确定和跟踪它们的精确位置，同时精确地标记它们。 目标检测通常与图像识别相混淆，所以在…
阅读更多...
easyExcel 数据导入

easyExcel 数据导入

前言 这段时间做了excel 数据导入&#xff0c;用的阿里巴巴的easyExcel 的代码。下面是官网和githab 代码地址。需要将github 上的代码拉下来&#xff0c;方便查看demo.关于Easyexcel | Easy ExcelEasyExcel是一个基于Java的简单、省内存的读写Excel的开源项目&#xff0c;在尽…
阅读更多...
[附源码]Python计算机毕业设计SSM基于与协同过滤算法的竞赛项目管理（程序+LW)

[附源码]Python计算机毕业设计SSM基于与协同过滤算法的竞赛项目管理（程序+LW)

项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; SSM mybatis Maven Vue 等等组成&#xff0c;B/S模式 M…
阅读更多...
可重复读实现原理

可重复读实现原理

浅解释 概念 1、InnoDB 在每行记录后面保存两个隐藏的列&#xff0c;分别保存了数据行的创建版本号和删除版本号。每开始一个新的事务&#xff0c;系统版本号都会递增。事务开始时刻的系统版本号会作为事务的版本号&#xff0c;用来和查询到的每行记录的创建版本号对比。 2、i…
阅读更多...
RKMEDIA--VP使用

RKMEDIA--VP使用

本章描述rkmedia vp模块 即视频一入四处功能的介绍。 使用场景&#xff1a;主要用在DVR/DMS产品上&#xff0c;需要多路视频节点的输入和获取。 可以rv1126/rv1109可以外接模拟高清RX芯片&#xff08;NVP6188,TP2815等&#xff09;&#xff0c;达到8路camera输入的能力。 在…
阅读更多...
PLSQL导出、导入数据 和 同步数据 以及 navicat 里同步数据 以及解决plsql导出数据乱码问题

PLSQL导出、导入数据 和 同步数据 以及 navicat 里同步数据 以及解决plsql导出数据乱码问题

PLSQL导出、导入数据 和 同步数据 以及 navicat 里同步数据 以及解决plsql导出数据乱码问题1. 导出数据1.1 导出.pde文件1.2 导出sql文件1.2.1 导出sql压缩文件1.2.1 导出问题——乱码 与 解决乱码问题1. 尝试解决方式12. 尝试解决方式23. 直接换PLSQ版本&#xff08;最终解决问…
阅读更多...
Traysoft AddTapi.NET 支持多条线路

Traysoft AddTapi.NET 支持多条线路

Traysoft AddTapi.NET 支持多条线路 使用Traysoft AddTapi。您可以轻松地将手机功能添加到C#、VB.NET和C应用程序中。添加Tapi。NET将为您提供开发移动应用程序所需的一切。包括&#xff1a;电话呼叫、接收者ID、语音邮件、警告系统、电话呼叫跟踪和监控。添加Tapi。NET继续联系…
阅读更多...
微服务框架 SpringCloud微服务架构 25 黑马旅游案例 25.3 我附近的酒店

微服务框架 SpringCloud微服务架构 25 黑马旅游案例 25.3 我附近的酒店

微服务框架 【SpringCloudRabbitMQDockerRedis搜索分布式&#xff0c;系统详解springcloud微服务技术栈课程|黑马程序员Java微服务】 SpringCloud微服务架构 文章目录微服务框架SpringCloud微服务架构25 黑马旅游案例25.3 我附近的酒店25.3.1 直接开干25 黑马旅游案例 25.3 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023