蓝桥杯C语言组：图论问题

news2025/2/10 23:59:41

蓝桥杯C语言组图论问题研究

摘要

图论是计算机科学中的一个重要分支，在蓝桥杯C语言组竞赛中，图论问题频繁出现，对参赛选手的算法设计和编程能力提出了较高要求。本文系统地介绍了图论的基本概念、常见算法及其在蓝桥杯C语言组中的应用，通过具体实例和表格，详细解释了图论问题的解题思路和实现方法，旨在为参赛选手提供参考和指导。

一、引言

蓝桥杯全国软件和信息技术专业人才大赛是国内知名的IT类竞赛，其中C语言组竞赛备受高校学生的关注和参与。图论作为计算机科学中的经典理论，广泛应用于网络设计、路径规划、资源分配等领域。在蓝桥杯C语言组竞赛中，图论问题的考察不仅测试选手对图论知识的掌握程度，还考察其编程实现能力。因此，深入研究图论问题及其解题方法对于提高竞赛成绩具有重要意义。

二、图论基础

（一）图的基本概念

图是一种由顶点（节点）和边（或弧）组成的离散结构，用于表示对象之间的关系。图可以分为无向图和有向图。无向图中的边没有方向，表示两个顶点之间的对称关系；有向图中的边有方向，表示从一个顶点指向另一个顶点的关系。

术语定义
顶点（Vertex）图中的基本元素，表示对象
边（Edge）连接两个顶点的线段，表示对象之间的关系
度（Degree）与一个顶点相连的边的数量
路径（Path）从一个顶点到另一个顶点的边的序列
连通性（Connectivity）图中任意两个顶点之间是否存在路径

（二）图的存储结构

在计算机中，图可以通过邻接矩阵、邻接表等数据结构来存储。

  1. 邻接矩阵：用一个二维数组表示图的顶点之间的关系。对于无向图，邻接矩阵是对称的；对于有向图，邻接矩阵不一定对称。邻接矩阵的优点是实现简单，判断两个顶点之间是否存在边的时间复杂度为O(1)，但缺点是空间复杂度较高，尤其是对于稀疏图。

  2. 邻接表：用一个数组存储图的顶点，每个顶点对应一个链表，链表中的节点表示与该顶点相连的边。邻接表的优点是节省空间，适合稀疏图，但判断两个顶点之间是否存在边的时间复杂度较高。

三、图论算法

（一）最短路径算法

最短路径问题是图论中的经典问题，目标是找到从一个顶点到另一个顶点的最短路径。常见的最短路径算法包括Dijkstra算法、Bellman-Ford算法和Floyd-Warshall算法。

1. Dijkstra算法

Dijkstra算法用于求解单源最短路径问题，即从一个起点到所有其他顶点的最短路径。算法的基本思想是通过贪心策略逐步扩展已知的最短路径集合。Dijkstra算法的时间复杂度为O(V^2)，其中V是顶点的数量。通过使用优先队列优化，时间复杂度可以降低到O(VlogV)。

2. Floyd-Warshall算法

Floyd-Warshall算法用于求解所有顶点对之间的最短路径。算法的核心思想是动态规划，通过逐步考虑每个顶点作为中间点来更新路径长度。Floyd-Warshall算法的时间复杂度为O(V^3)，适用于顶点数量较少的图。

（二）最小生成树算法

最小生成树是图论中的另一个重要问题，目标是在一个连通图中找到一棵包含所有顶点的生成树，使得树的边权总和最小。常见的最小生成树算法包括Prim算法和Kruskal算法。

1. Prim算法

Prim算法从一个顶点开始，逐步扩展生成树，每次选择与当前生成树相连的最小边。Prim算法的时间复杂度为O(V^2)，通过使用优先队列优化，时间复杂度可以降低到O(VlogV)。

2. Kruskal算法

Kruskal算法通过选择最小的边逐步构建生成树，同时避免形成环。Kruskal算法的时间复杂度主要取决于边的排序，通常为O(ElogE)，其中E是边的数量。

（三）深度优先搜索（DFS）与广度优先搜索（BFS）

DFS和BFS是图论中的两种基本搜索算法，广泛应用于路径搜索、连通性判断等问题。

1. 深度优先搜索（DFS）

DFS从一个顶点开始，沿着路径尽可能深地搜索，直到无法继续为止，然后回溯。DFS通常使用递归实现，时间复杂度为O(V + E)，其中V是顶点数量，E是边的数量。

2. 广度优先搜索（BFS）

BFS从一个顶点开始，依次访问所有相邻顶点，然后再从这些相邻顶点开始，依次访问它们的相邻顶点。

（四）实例分析

1. 最短路径问题

假设有一个图，顶点集合为{A, B, C, D, E}，边集合为{(A, B, 1), (A, C, 4), (B, C, 2), (B, D, 5), (C, D, 1), (C, E, 3), (D, E, 2)}，其中每个元组表示边的起点、终点和权重。使用Dijkstra算法求解从顶点A到其他所有顶点的最短路径。

步骤当前顶点距离集合已访问集合
1A{A: 0, B: 1, C: 4, D: ∞, E: ∞}{A}
2B{A: 0, B: 1, C: 3, D: 6, E: ∞}{A, B}
3C{A: 0, B: 1, C: 3, D: 4, E: 6}{A, B, C}
4D{A: 0, B: 1, C: 3, D: 4, E: 6}{A, B, C, D}
5E{A: 0, B: 1, C: 3, D: 4, E: 6}{A, B, C, D, E}

最终，从顶点A到其他顶点的最短路径分别为：A到B为1，A到C为3，A到D为4，A到E为6。

2. 最小生成树问题

假设有一个图，顶点集合为{A, B, C, D, E}，边集合为{(A, B, 1), (A, C, 4), (B, C, 2), (B, D, 5), (C, D, 1), (C, E, 3), (D, E, 2)}，使用Kruskal算法求解最小生成树。

步骤边集合是否加入原因
1(A, B, 1)是不形成环
2(C, D, 1)是不形成环
3(B, C, 2)是不形成环
4(D, E, 2)是不形成环
5(C, E, 3)否形成环
6(A, C, 4)否形成环
7(B, D, 5)否形成环

最终，最小生成树的边集合为{(A, B, 1), (C, D, 1), (B, C, 2), (D, E, 2)}。

四、结论

图论是蓝桥杯C语言组竞赛中的重要内容，掌握图论的基本概念和常见算法对于参赛选手来说至关重要。通过实例分析和表格解释，本文详细介绍了图论问题的解题思路和实现方法，希望对参赛选手有所帮助。

以下是几个关于图论问题的例题及其解决代码，涵盖常见的图论算法，如Dijkstra算法、Floyd-Warshall算法、拓扑排序等，适用于蓝桥杯C语言组竞赛的备考。

例题1：单源最短路径问题（Dijkstra算法）

问题描述：给定一个带权有向图，求从某个源点到所有其他顶点的最短路径。

C语言实现代码：

#include <stdio.h>
#include <stdlib.h>
#include <limits.h> // For INT_MAX

#define V 5 // 假设图中有5个顶点

// 找到距离最小且未被访问的顶点
int minDistance(int dist[], int sptSet[], int n) {
    int min = INT_MAX, min_index;
    for (int v = 0; v < n; v++)
        if (sptSet[v] == 0 && dist[v] <= min)
            min = dist[v], min_index = v;
    return min_index;
}

// Dijkstra算法实现
void dijkstra(int graph[V][V], int src) {
    int dist[V]; // dist[i] 会保存源顶点到顶点i的最短路径
    int sptSet[V]; // sptSet[i] 为真 (1) 时表示该顶点i已在最短路径树中或最短距离已确定

    // 初始化所有距离为无穷大，sptSet[]为假
    for (int i = 0; i < V; i++)
        dist[i] = INT_MAX, sptSet[i] = 0;

    dist[src] = 0; // 源顶点到自身的距离总是为0

    for (int count = 0; count < V - 1; count++) {
        int u = minDistance(dist, sptSet, V);
        sptSet[u] = 1; // 将选定的顶点标记为已处理

        // 更新相邻顶点的距离值
        for (int v = 0; v < V; v++)
            if (!sptSet[v] && graph[u][v] && dist[u] != INT_MAX
                && dist[u] + graph[u][v] < dist[v])
                dist[v] = dist[u] + graph[u][v];
    }

    // 打印结果
    printf("Vertex \t Distance from Source\n");
    for (int i = 0; i < V; i++)
        printf("%d \t\t %d\n", i, dist[i]);
}

int main() {
    int graph[V][V] = {
  
  { 0, 6, 0, 1, 0 },
                       { 6, 0, 5, 2, 2 },
                       { 0, 5, 0, 0, 5 },
                       { 1, 2, 0, 0, 1 },
                       { 0, 2, 5, 1, 0 }};

    dijkstra(graph, 0); // 假设从顶点0开始
    return 0;
}

说明：该代码实现了Dijkstra算法，用于求解单源最短路径问题。

例题2：所有顶点对的最短路径问题（Floyd-Warshall算法）

问题描述：给定一个带权图，求图中所有顶点对之间的最短路径。

C语言实现代码：

#include <stdio.h>
#include <limits.h> // For INT_MAX

#define V 4 // 假设图中有4个顶点

void printSolution(int dist[][V]);

void floydWarshall(int graph[][V]) {
    int dist[V][V], i, j, k;

    // 初始化距离矩阵
    for (i = 0; i < V; i++)
        for (j = 0; j < V; j++)
            dist[i][j] = graph[i][j];

    // 计算所有顶点对的最短路径
    for (k = 0; k < V; k++) {
        for (i = 0; i < V; i++) {
            for (j = 0; j < V; j++) {
                if (dist[i][k] + dist[k][j] < dist[i][j])
                    dist[i][j] = dist[i][k] + dist[k][j];
            }
        }
    }

    // 打印结果
    printSolution(dist);
}

void printSolution(int dist[][V]) {
    printf("The following matrix shows the shortest distances between every pair of vertices:\n");
    for (int i = 0; i < V; i++) {
        for (int j = 0; j < V; j++) {
            if (dist[i][j] == INT_MAX)
                printf("%7s", "INF");
            else
                printf("%7d", dist[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int graph[V][V] = {
  
  { 0, 5, INT_MAX, 10 },
                       { INT_MAX, 0, 3, INT_MAX },
                       { INT_MAX, INT_MAX, 0, 1 },
                       { INT_MAX, INT_MAX, INT_MAX, 0 }};

    floydWarshall(graph);
    return 0;
}

说明：该代码实现了Floyd-Warshall算法，用于求解所有顶点对之间的最短路径。

例题3：拓扑排序（Kahn算法）

问题描述：给定一个有向无环图（DAG），对图中的顶点进行拓扑排序。

C语言实现代码：

#include <stdio.h>
#include <stdlib.h>

#define V 6 // 假设图中有6个顶点

void topologicalSort(int adj[][V], int inDegree[], int result[]) {
    int count = 0;
    int queue[V], front = 0, rear = 0;

    // 初始化队列，将所有入度为0的顶点入队
    for (int i = 0; i < V; i++) {
        if (inDegree[i] == 0) {
            queue[rear++] = i;
        }
    }

    while (front < rear) {
        int u = queue[front++];
        result[count++] = u;

        // 遍历所有邻接点，减少其入度
        for (int v = 0; v < V; v++) {
            if (adj[u][v]) {
                if (--inDegree[v] == 0) {
                    queue[rear++] = v;
                }
            }
        }
    }

    if (count != V) {
        printf("There exists a cycle in the graph\n");
    }
}

int main() {
    int adj[V][V] = {
        {0, 1, 1, 0, 0, 0},
        {0, 0, 0, 1, 0, 0},
        {0, 0, 0, 1, 0, 0},
        {0, 0, 0, 0, 1, 1},
        {0, 0, 0, 0, 0, 0},
        {0, 0, 0, 0, 0, 0}
    };

    int inDegree[V] = {0};
    for (int i = 0; i < V; i++) {
        for (int j = 0; j < V; j++) {
            inDegree[i] += adj[j][i];
        }
    }

    int result[V];
    topologicalSort(adj, inDegree, result);

    printf("Topological Sort: ");
    for (int i = 0; i < V; i++) {
        printf("%d ", result[i]);
    }
    printf("\n");

    return 0;
}

说明：该代码实现了Kahn算法，用于对有向无环图进行拓扑排序。

例题4：最小生成树（Prim算法）

问题描述：给定一个无向连通图，求该图的最小生成树。

C语言实现代码：

#include <stdio.h>
#include <limits.h> // For INT_MAX

#define V 5 // 假设图中有5个顶点

int minKey(int key[], int mstSet[], int n) {
    int min = INT_MAX, min_index;
    for (int v = 0; v < n; v++)
        if (mstSet[v] == 0 && key[v] < min)
            min = key[v], min_index = v;
    return min_index;
}

void primMST(int graph[V][V]) {
    int parent[V]; // 存储最小生成树的构建过程
    int key[V]; // key[i]保存顶点i到最小生成树的最小权重
    int mstSet[V]; // mstSet[i]为真(1)时表示该顶点i已在最小生成树中

    for (int i = 0; i < V; i++)
        key[i] = INT_MAX, mstSet[i] = 0;

    key[0] = 0; // 从顶点0开始
    parent[0] = -1;

    for (int i = 0; i < V - 1; i++) {
        int u = minKey(key, mstSet, V);
        mstSet[u] = 1;

        for (int v = 0; v < V; v++)
            if (graph[u][v] && mstSet[v] == 0 && graph[u][v] < key[v])
                parent[v] = u, key[v] = graph[u][v];
    }

    printf("Edge \tWeight\n");
    for (int i = 1; i < V; i++)
        printf("%d - %d \t%d \n", parent[i], i, graph[i][parent[i]]);
}

int main() {
    int graph[V][V] = {
  
  { 0, 2, 0, 6, 0 },
                       { 2, 0, 3, 8, 5 },
                       { 0, 3, 0, 0, 7 },
                       { 6, 8, 0, 0, 9 },
                       { 0, 5, 7, 9, 0 }};

    primMST(graph);
    return 0;
}

说明：该代码实现了Prim算法，用于求解无向连通图的最小生成树。

例题5：深度优先搜索（DFS）与连通分量

问题描述：给定一个无向图，使用深度优先搜索（DFS）找出图中的所有连通分量。

C语言实现代码：

#include <stdio.h>
#include <stdlib.h>

#define V 5 // 假设图中有5个顶点

void DFS(int adj[][V], int visited[], int v) {
    visited[v] = 1;
    printf("%d ", v);

    for (int i = 0; i < V; i++) {
        if (adj[v][i] && !visited[i]) {
            DFS(adj, visited, i);
        }
    }
}

void findConnectedComponents(int adj[][V], int visited[]) {
    for (int i = 0; i < V; i++) {
        if (!visited[i]) {
            DFS(adj, visited, i);
            printf("\n");
        }
    }
}

int main() {
    int adj[V][V] = {
        {0, 1, 0, 0, 0},
        {1, 0, 1, 0, 0},
        {0, 1, 0, 1, 0},
        {0, 0, 1, 0, 1},
        {0, 0, 0, 1, 0}
    };

    int visited[V] = {0};

    printf("Connected components:\n");
    findConnectedComponents(adj, visited);

    return 0;
}

说明：该代码实现了深度优先搜索（DFS），用于找出无向图中的所有连通分量。

例题6：广度优先搜索（BFS）与最短路径

问题描述：给定一个无权图，使用广度优先搜索（BFS）找出从源点到所有其他顶点的最短路径。

C语言实现代码：

#include <stdio.h>
#include <stdlib.h>

#define V 6 // 假设图中有6个顶点

void BFS(int adj[][V], int src, int dist[]) {
    int visited[V] = {0};
    int queue[V], front = 0, rear = 0;

    visited[src] = 1;
    dist[src] = 0;
    queue[rear++] = src;

    while (front < rear) {
        int u = queue[front++];
        for (int v = 0; v < V; v++) {
            if (adj[u][v] && !visited[v]) {
                visited[v] = 1;
                dist[v] = dist[u] + 1;
                queue[rear++] = v;
            }
        }
    }
}

int main() {
    int adj[V][V] = {
        {0, 1, 1, 0, 0, 0},
        {1, 0, 0, 1, 0, 0},
        {1, 0, 0, 1, 0, 0},
        {0, 1, 1, 0, 1, 1},
        {0, 0, 0, 1, 0, 0},
        {0, 0, 0, 1, 0, 0}
    };

    int dist[V];
    BFS(adj, 0, dist);

    printf("Shortest distances from source vertex 0:\n");
    for (int i = 0; i < V; i++) {
        printf("Vertex %d: %d\n", i, dist[i]);
    }

    return 0;
}

说明：该代码实现了广度优先搜索（BFS），用于找出无权图中从源点到所有其他顶点的最短路径。

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

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

相关文章

windows通过网络向Ubuntu发送文件/目录

windows通过网络向Ubuntu发送文件/目录

由于最近要使用树莓派进行一些代码练习&#xff0c;但是好多东西都在windows里或虚拟机上&#xff0c;就想将文件传输到树莓派上&#xff0c;但试了发现u盘不能简单传送&#xff0c;就在网络上找到了通过windows 的scp命令传送 前提是树莓派先开启ssh服务&#xff0c;且Window…
阅读更多...
Unity抖音云启动测试:如何用cmd命令行启动exe

Unity抖音云启动测试:如何用cmd命令行启动exe

相关资料&#xff1a;弹幕云启动&#xff08;原“玩法云启动能力”&#xff09;_直播小玩法_抖音开放平台 1&#xff0c;操作方法 在做云启动的时候&#xff0c;接完发现需要命令行模拟云环境测试启动&#xff0c;所以研究了下。 首先进入cmd命令&#xff0c;CD进入对应包的文件…
阅读更多...
ZU47DR 100G光纤 高性能板卡

ZU47DR 100G光纤 高性能板卡

简介 2347DR是一款最大可提供8路ADC接收和8路DAC发射通道的高性能板卡。板卡选用高性价比的Xilinx的Zynq UltraScale RFSoC系列中XCZU47DR-FFVE1156作为处理芯片&#xff08;管脚可以兼容XCZU48DR-FFVE1156&#xff0c;主要差别在有无FEC&#xff08;信道纠错编解码&#xff0…
阅读更多...
【算法】动态规划专题⑥ —— 完全背包问题 python

【算法】动态规划专题⑥ —— 完全背包问题 python

目录 前置知识进入正题模板 前置知识 【算法】动态规划专题⑤ —— 0-1背包问题 滚动数组优化 完全背包问题是动态规划中的一种经典问题&#xff0c;它与0-1背包问题相似&#xff0c;但有一个关键的区别&#xff1a;在完全背包问题中&#xff0c;每种物品都有无限的数量可用。…
阅读更多...
C#中深度解析BinaryFormatter序列化生成的二进制文件

C#中深度解析BinaryFormatter序列化生成的二进制文件

C#中深度解析BinaryFormatter序列化生成的二进制文件 BinaryFormatter序列化时,对象必须有 可序列化特性[Serializable] 一.新建窗体测试程序BinaryDeepAnalysisDemo,将默认的Form1重命名为FormBinaryDeepAnalysis 二.新建测试类Test Test.cs源程序如下: using System; us…
阅读更多...
51单片机之引脚图（详解）

51单片机之引脚图（详解）

8051单片机引脚分类与功能笔记 1. 电源引脚 VCC&#xff08;第40脚&#xff09;&#xff1a;接入5V电源&#xff0c;为单片机提供工作电压。GND&#xff08;第20脚&#xff09;&#xff1a;接地端&#xff0c;确保电路的电位参考点。 2.时钟引脚 XTAL1&#xff08;第19脚&a…
阅读更多...
jupyterLab插件开发

jupyterLab插件开发

jupyter lab安装、配置&#xff1a; jupyter lab安装、配置教程_容器里装jupyterlab-CSDN博客 『Linux笔记』服务器搭建神器JupyterLab_linux_布衣小张-腾讯云开发者社区 Jupyter Lab | 安装、配置、插件推荐、多用户使用教程-腾讯云开发者社区-腾讯云 jupyterLab插件开发教…
阅读更多...
配置#include “nlohmann/json.hpp“，用于处理json文件

配置#include “nlohmann/json.hpp“，用于处理json文件

#include “nlohmann/json.hpp” // 需要安装 nlohmann/json.hpp 头文件 using json = nlohmann::json; 下载链接：https://github.com/nlohmann/json/tree/develop 1.下载并解压：首先，需要从nlohmann/json的GitHub仓库下载源代码，并解压得到的文件。 地址： nlohmann/json…
阅读更多...
MATLAB | 基于Theil-Sen斜率和Mann-Kendall检验的栅格数据趋势分析

MATLAB | 基于Theil-Sen斜率和Mann-Kendall检验的栅格数据趋势分析

最近看到一些博主分享关于 SenMK 检验的代码&#xff0c;对于新手来说可能有点复杂。我们编写了一段 MATLAB 代码&#xff0c;能够一次性解决这些问题&#xff0c;简化操作流程。我们还准备了几个关于趋势检验的空间分布图&#xff0c;供大家参考。 一、Sens Slope和Mann-Kenda…
阅读更多...
Windows 系统下使用 Ollama 离线部署 DeepSeek - R1 模型指南

Windows 系统下使用 Ollama 离线部署 DeepSeek - R1 模型指南

引言 随着人工智能技术的飞速发展&#xff0c;各类大语言模型层出不穷。DeepSeek - R1 凭借其出色的语言理解和生成能力&#xff0c;受到了广泛关注。而 Ollama 作为一款便捷的模型管理和部署工具&#xff0c;能够帮助我们轻松地在本地环境中部署和使用模型。本文将详细介绍如…
阅读更多...
Docker、Ollama、Dify 及 DeepSeek 安装配置与搭建企业级本地私有化知识库实践

Docker、Ollama、Dify 及 DeepSeek 安装配置与搭建企业级本地私有化知识库实践

在现代企业中&#xff0c;管理和快速访问知识库是提升工作效率、促进创新的关键。为了满足这些需求&#xff0c;企业越来越倾向于构建本地私有化的知识库系统&#xff0c;这样可以更好地保护企业数据的安全性和隐私性。本文将介绍如何利用 **Docker**、**Ollama**、**Dify** 和…
阅读更多...
【漫话机器学习系列】087.常见的神经网络最优化算法（Common Optimizers Of Neural Nets）

【漫话机器学习系列】087.常见的神经网络最优化算法（Common Optimizers Of Neural Nets）

常见的神经网络优化算法 1. 引言 在深度学习中&#xff0c;优化算法&#xff08;Optimizers&#xff09;用于更新神经网络的权重&#xff0c;以最小化损失函数&#xff08;Loss Function&#xff09;。一个高效的优化算法可以加速训练过程&#xff0c;并提高模型的性能和稳定…
阅读更多...
【JVM详解四】执行引擎

【JVM详解四】执行引擎

一、概述 Java程序运行时&#xff0c;JVM会加载.class字节码文件&#xff0c;但是字节码并不能直接运行在操作系统之上&#xff0c;而JVM中的执行引擎就是负责将字节码转化为对应平台的机器码让CPU运行的组件。 执行引擎是JVM核心的组成部分之一。可以把JVM架构分成三部分&am…
阅读更多...
route 与 router 之间的差别

route 与 router 之间的差别

简述&#xff1a; router&#xff1a;主要用于处理一些动作&#xff0c; route&#xff1a;主要获得或处理一些数据&#xff0c;比如地址、参数等 例&#xff1a; videoInfo1.vue&#xff1a; <template><div class"video-info"><h3>二级组件…
阅读更多...
SamWaf开源轻量级的网站应用防火墙（安装包），私有化部署，加密本地存储的数据，易于启动，并支持 Linux 和 Windows 64 位和 Arm64

SamWaf开源轻量级的网站应用防火墙（安装包），私有化部署，加密本地存储的数据，易于启动，并支持 Linux 和 Windows 64 位和 Arm64

一、SamWaf轻量级开源防火墙介绍 &#xff08;文末提供下载&#xff09; SamWaf网站防火墙是一款适用于小公司、工作室和个人网站的开源轻量级网站防火墙&#xff0c;完全私有化部署&#xff0c;数据加密且仅保存本地&#xff0c;一键启动&#xff0c;支持Linux&#xff0c;Wi…
阅读更多...
极客说｜利用 Azure AI Agent Service 创建自定义 VS Code Chat participant

极客说｜利用 Azure AI Agent Service 创建自定义 VS Code Chat participant

作者&#xff1a;卢建晖 - 微软高级云技术布道师 「极客说」 是一档专注 AI 时代开发者分享的专栏&#xff0c;我们邀请来自微软以及技术社区专家&#xff0c;带来最前沿的技术干货与实践经验。在这里&#xff0c;您将看到深度教程、最佳实践和创新解决方案。关注「极客说」&a…
阅读更多...
windows + visual studio 2019 使用cmake 编译构建静、动态库并调用详解

windows + visual studio 2019 使用cmake 编译构建静、动态库并调用详解

环境 windows visual studio 2019 visual studio 2019创建cmake工程 1. 静态库.lib 1.1 静态库编译生成 以下是我创建的cmake工程文件结构&#xff0c;只关注高亮文件夹部分 libout 存放编译生成的.lib文件libsrc 存放编译用的源代码和头文件CMakeLists.txt 此次编译CMak…
阅读更多...
【kafka实战】05 Kafka消费者消费消息过程源码剖析

【kafka实战】05 Kafka消费者消费消息过程源码剖析

1. 概述 Kafka消费者&#xff08;Consumer&#xff09;是Kafka系统中负责从Kafka集群中拉取消息的客户端组件。消费者消费消息的过程涉及多个步骤&#xff0c;包括消费者组的协调、分区分配、消息拉取、消息处理等。本文将深入剖析Kafka消费者消费消息的源码&#xff0c;并结合…
阅读更多...
[EAI-033] SFT 记忆，RL 泛化，LLM和VLM的消融研究

[EAI-033] SFT 记忆，RL 泛化，LLM和VLM的消融研究

Paper Card 论文标题&#xff1a;SFT Memorizes, RL Generalizes: A Comparative Study of Foundation Model Post-training 论文作者&#xff1a;Tianzhe Chu, Yuexiang Zhai, Jihan Yang, Shengbang Tong, Saining Xie, Dale Schuurmans, Quoc V. Le, Sergey Levine, Yi Ma 论…
阅读更多...
算法与数据结构（字符串相乘）

算法与数据结构（字符串相乘）

题目 思路 这道题我们可以使用竖式乘法&#xff0c;从右往左遍历每个乘数&#xff0c;将其相乘&#xff0c;并且把乘完的数记录在nums数组中&#xff0c;然后再进行进位运算&#xff0c;将同一列的数进行相加&#xff0c;进位。 解题过程 首先求出两个数组的长度&#xff0c;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023