2023.11.15 每日一题（AI自生成应用）【C++】【Python】【Java】【Go】 动态路径分析

news2024/11/26 14:56:28

目录

一、题目

二、解决方法

三、改进

一、题目

背景： 在一个城市中，有数个交通节点，每个节点间有双向道路相连。每条道路具有一个初始权重，代表通行该路段的成本（例如时间、费用等）。随着时间的变化，道路的权重可能会发生变化，比如由于交通堵塞或道路维修。

问题： 设计一个算法，以处理以下两种类型的查询：

  1. 更新查询：给定两个节点及新的权重值，更新这两个节点之间道路的权重。
  2. 最短路径查询：给定两个节点，找出这两个节点之间的最短路径及其权重。

输入格式：

输出格式：

  • 对于每个最短路径查询，输出一个整数，表示最短路径的权重。如果两个节点之间没有路径，则输出 -1。

实际应用： 这个问题可以应用于交通管理系统，例如实时更新交通状况并为司机提供最优路线。也适用于网络数据流量管理，其中节点代表数据中心，道路代表连接它们的网络。

挑战：

  • 设计一个高效的数据结构来存储和更新节点间的道路权重。
  • 实现一个算法来快速回答最短路径查询，考虑到道路权重可能频繁变化。

二、解决方法

解决：

为了解决这个动态路径分析问题，我们可以采用以下策略：

  1. 数据结构：使用邻接表来表示图，其中每个节点都有一个列表存储它与其他节点的连接及其权重。
  2. 路径更新：对于更新操作，我们只需要修改邻接表中对应的权重。
  3. 最短路径查询：使用 Dijkstra 算法来找到最短路径。由于权重可能会频繁变化，我们在每次查询时都从头开始执行 Dijkstra 算法。

C++实现：

#include <iostream>
#include <vector>
#include <queue>
#include <climits>

using namespace std;

typedef pair<int, int> pii; // pair of (weight, node)

class Graph {
    int V; // Number of vertices
    vector<vector<pii>> adj; // Adjacency list

public:
    Graph(int V) : V(V), adj(V) {}

    void addEdge(int u, int v, int w) {
        adj[u].push_back({w, v});
        adj[v].push_back({w, u}); // For undirected graph
    }

    void updateEdge(int u, int v, int w) {
        // Update weight for edge u-v
        for (auto &p : adj[u]) {
            if (p.second == v) {
                p.first = w;
                break;
            }
        }
        for (auto &p : adj[v]) {
            if (p.second == u) {
                p.first = w;
                break;
            }
        }
    }

    int shortestPath(int source, int destination) {
        priority_queue<pii, vector<pii>, greater<pii>> pq;
        vector<int> dist(V, INT_MAX);

        pq.push({0, source});
        dist[source] = 0;

        while (!pq.empty()) {
            int u = pq.top().second;
            pq.pop();

            for (auto &[w, v] : adj[u]) {
                if (dist[v] > dist[u] + w) {
                    dist[v] = dist[u] + w;
                    pq.push({dist[v], v});
                }
            }
        }

        return (dist[destination] == INT_MAX) ? -1 : dist[destination];
    }
};

int main() {
    int N, M, u, v, w;
    cin >> N >> M;

    Graph g(N);

    for (int i = 0; i < M; ++i) {
        cin >> u >> v >> w;
        g.addEdge(u, v, w);
    }

    // Queries
    char queryType;
    while (cin >> queryType) {
        if (queryType == 'U') {
            cin >> u >> v >> w;
            g.updateEdge(u, v, w);
        } else if (queryType == 'Q') {
            cin >> u >> v;
            cout << g.shortestPath(u, v) << endl;
        }
    }

    return 0;
}

Python：

import heapq

class Graph:
    def __init__(self, V):
        self.V = V
        self.graph = {i: {} for i in range(V)}

    def add_edge(self, u, v, w):
        self.graph[u][v] = w
        self.graph[v][u] = w

    def update_edge(self, u, v, w):
        if v in self.graph[u]:
            self.graph[u][v] = w
        if u in self.graph[v]:
            self.graph[v][u] = w

    def shortest_path(self, source, destination):
        dist = [float('inf')] * self.V
        dist[source] = 0
        pq = [(0, source)]

        while pq:
            d, u = heapq.heappop(pq)
            if d > dist[u]:
                continue

            for v, w in self.graph[u].items():
                if dist[u] + w < dist[v]:
                    dist[v] = dist[u] + w
                    heapq.heappush(pq, (dist[v], v))

        return dist[destination] if dist[destination] != float('inf') else -1

# Example usage
g = Graph(N)  # N is the number of vertices
# Add edges and handle queries similarly to the C++ example

JAVA：

import java.util.*;

public class Graph {
    private int V;
    private Map<Integer, Map<Integer, Integer>> adj;

    public Graph(int V) {
        this.V = V;
        this.adj = new HashMap<>();
        for (int i = 0; i < V; i++) {
            adj.put(i, new HashMap<>());
        }
    }

    public void addEdge(int u, int v, int w) {
        adj.get(u).put(v, w);
        adj.get(v).put(u, w);
    }

    public void updateEdge(int u, int v, int w) {
        if (adj.get(u).containsKey(v)) {
            adj.get(u).put(v, w);
        }
        if (adj.get(v).containsKey(u)) {
            adj.get(v).put(u, w);
        }
    }

    public int shortestPath(int source, int destination) {
        int[] dist = new int[V];
        Arrays.fill(dist, Integer.MAX_VALUE);
        dist[source] = 0;

        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));
        pq.add(new int[]{source, 0});

        while (!pq.isEmpty()) {
            int[] current = pq.poll();
            int u = current[0];

            if (u == destination) {
                break;
            }

            for (Map.Entry<Integer, Integer> entry : adj.get(u).entrySet()) {
                int v = entry.getKey();
                int weight = entry.getValue();

                if (dist[u] + weight < dist[v]) {
                    dist[v] = dist[u] + weight;
                    pq.add(new int[]{v, dist[v]});
                }
            }
        }

        return dist[destination] == Integer.MAX_VALUE ? -1 : dist[destination];
    }

    // Example usage
    public static void main(String[] args) {
        Graph g = new Graph(N); // N is the number of vertices
        // Add edges and handle queries similarly to the C++ example
    }
}

Go语言：

package main

import (
	"container/heap"
	"fmt"
	"math"
)

type Edge struct {
	node, weight int
}

type Graph struct {
	V     int
	edges map[int]map[int]int
}

func NewGraph(V int) *Graph {
	g := &Graph{
		V:     V,
		edges: make(map[int]map[int]int),
	}
	for i := 0; i < V; i++ {
		g.edges[i] = make(map[int]int)
	}
	return g
}
func (g *Graph) UpdateEdge(u, v, w int) {
	if _, ok := g.edges[u][v]; ok {
		g.edges[u][v] = w
	}
	if _, ok := g.edges[v][u]; ok {
		g.edges[v][u] = w
	}
}

func (g *Graph) ShortestPath(source, destination int) int {
	dist := make([]int, g.V)
	for i := range dist {
		dist[i] = math.MaxInt32
	}
	dist[source] = 0

	pq := make(PriorityQueue, 0)
	heap.Init(&pq)
	heap.Push(&pq, &Item{
		value:    source,
		priority: 0,
	})

	for pq.Len() > 0 {
		item := heap.Pop(&pq).(*Item)
		u := item.value

		if u == destination {
			break
		}

		for v, w := range g.edges[u] {
			if dist[u]+w < dist[v] {
				dist[v] = dist[u] + w
				heap.Push(&pq, &Item{
					value:    v,
					priority: dist[v],
				})
			}
		}
	}

	if dist[destination] == math.MaxInt32 {
		return -1
	}
	return dist[destination]
}

// Define the priority queue used for Dijkstra's algorithm
type Item struct {
	value    int // The node index
	priority int // The node's priority (distance)
	index    int // The index of the item in the heap
}

type PriorityQueue []*Item

func (pq PriorityQueue) Len() int { return len(pq) }

func (pq PriorityQueue) Less(i, j int) bool {
	return pq[i].priority < pq[j].priority
}

func (pq PriorityQueue) Swap(i, j int) {
	pq[i], pq[j] = pq[j], pq[i]
	pq[i].index = i
	pq[j].index = j
}

func (pq *PriorityQueue) Push(x interface{}) {
	n := len(*pq)
	item := x.(*Item)
	item.index = n
	*pq = append(*pq, item)
}

func (pq *PriorityQueue) Pop() interface{} {
	old := *pq
	n := len(old)
	item := old[n-1]
	old[n-1] = nil
	item.index = -1
	*pq = old[0 : n-1]
	return item
}

func main() {
	// Example usage
	g := NewGraph(N) // N is the number of vertices
	// Add edges and handle queries similarly to the C++ example
}

三、改进

  1. 效率问题：每次查询最短路径时都需要从头执行 Dijkstra 算法。在频繁更新边权重的场景中，这可能导致效率低下。
  2. 数据结构选择：现有实现使用邻接表来存储图，这对于稀疏图是合适的。但对于密集图，这种表示方式可能导致内存使用不经济。

改进：

  1. 增量更新算法：对于频繁更新的场景，可以考虑使用更高级的图算法，如“动态最短路径算法”。这类算法可以在不重新计算整个图的情况下，有效更新最短路径。
  2. 数据结构优化：针对不同类型的图（稀疏或密集），选择合适的数据结构。例如，对于密集图，可以使用邻接矩阵来代替邻接表。
#include <iostream>
#include <vector>
#include <queue>
#include <climits>

using namespace std;

const int MAX_V = 1000; // 假设图中最多有1000个节点

class Graph {
    int V; // 顶点数
    vector<vector<int>> adjMatrix; // 邻接矩阵

public:
    Graph(int V) : V(V), adjMatrix(V, vector<int>(V, INT_MAX)) {}

    void addEdge(int u, int v, int w) {
        adjMatrix[u][v] = w;
        adjMatrix[v][u] = w;
    }

    void updateEdge(int u, int v, int w) {
        adjMatrix[u][v] = w;
        adjMatrix[v][u] = w;
    }

    int shortestPath(int source, int destination) {
        vector<int> dist(V, INT_MAX);
        vector<bool> sptSet(V, false);

        dist[source] = 0;

        for (int count = 0; count < V - 1; count++) {
            int u = minDistance(dist, sptSet);
            sptSet[u] = true;

            for (int v = 0; v < V; v++) {
                if (!sptSet[v] && adjMatrix[u][v] != INT_MAX && dist[u] != INT_MAX &&
                    dist[u] + adjMatrix[u][v] < dist[v]) {
                    dist[v] = dist[u] + adjMatrix[u][v];
                }
            }
        }

        return (dist[destination] == INT_MAX) ? -1 : dist[destination];
    }

private:
    int minDistance(const vector<int> &dist, const vector<bool> &sptSet) {
        int min = INT_MAX, min_index;

        for (int v = 0; v < V; v++) {
            if (!sptSet[v] && dist[v] <= min) {
                min = dist[v];
                min_index = v;
            }
        }

        return min_index;
    }
};

int main() {
    // 示例用法
    int N, M, u, v, w;
    cin >> N >> M;

    Graph g(N);

    for (int i = 0; i < M; ++i) {
        cin >> u >> v >> w;
        g.addEdge(u, v, w);
    }

    // 处理查询
    // ...
}

        这个实现针对密集图进行了优化，但它不包括动态最短路径算法的实现。动态最短路径算法通常更复杂，可能需要使用更高级的数据结构和算法技巧。这种算法的实现和优化通常是图算法研究的前沿话题。

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

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

相关文章

nodejs+vue黄河风景线旅游网站的设计与实现-微信小程序-安卓-python-PHP-计算机毕业设计

nodejs+vue黄河风景线旅游网站的设计与实现-微信小程序-安卓-python-PHP-计算机毕业设计

本文首先对该系统进行了详细地描述&#xff0c;然后对该系统进行了详细的描述。管理人员增加了系统首页、个人中心、用户管理、景点分类管理、景点简介管理、旅游路线管理、文章分类管理、公告文章管理、系统管理理等功能。这套黄河风景线旅游网站是根据当前的现实需要&#xf…
阅读更多...
SystemVerilog学习 （5）——接口

SystemVerilog学习 （5）——接口

一、概述 验证一个设计需要经过几个步骤&#xff1a; 生成输入激励捕获输出响应决定对错和衡量进度 但是&#xff0c;我们首先需要一个合适的测试平台&#xff0c;并将它连接到设计上。 测试平台包裹着设计,发送激励并且捕获设计的输出。测试平台组成了设计周围的“真实世界”,…
阅读更多...
【miniQMT实盘量化3】获取历史行情数据

【miniQMT实盘量化3】获取历史行情数据

前言 上篇文章&#xff0c;介绍了如何与miniQMT建立连接&#xff0c;这篇开始&#xff0c;我们会深入探讨miniQMT的每个功能接口。首先&#xff0c;从获取历史数据开始。 迅投的官方文档目前已经更新&#xff0c;miniQMT对应原生API部分 接口汇总 与历史行情数据相关的接口&a…
阅读更多...
Solidity案例详解（四）投票智能合约

Solidity案例详解（四）投票智能合约

该合约为原创合约&#xff0c;功能要求如下 在⼀定时间能进⾏投票超过时间投票截⽌&#xff0c;并投赞同票超过50%则为通过。 使⽤safeMath库&#xff0c;使⽤Owner 第三⽅库拥有参与投票权的⽤户在创建合约时确定Voter 结构 要有时间戳、投票是否同意等&#xff1b;struct 结构…
阅读更多...
浅尝：iOS的CoreGraphics和Flutter的Canvas

浅尝：iOS的CoreGraphics和Flutter的Canvas

iOS的CoreGraphic 基本就是创建一个自定义的UIView&#xff0c;然后重写drawRect方法&#xff0c;在此方法里使用UIGraphicsGetCurrentContext()来绘制目标图形和样式 #import <UIKit/UIKit.h>interface MyGraphicView : UIView endimplementation MyGraphicView// Onl…
阅读更多...
智能AI系统ChatGPT网站源码+支持OpenAI DALL-E3文生图+支持ai绘画（Midjourney)/支持GPT全模型+国内AI全模型

智能AI系统ChatGPT网站源码+支持OpenAI DALL-E3文生图+支持ai绘画（Midjourney)/支持GPT全模型+国内AI全模型

一、AI创作系统 SparkAi创作系统是基于OpenAI很火的ChatGPT进行开发的Ai智能问答系统和Midjourney绘画系统&#xff0c;支持OpenAI-GPT全模型国内AI全模型。本期针对源码系统整体测试下来非常完美&#xff0c;可以说SparkAi是目前国内一款的ChatGPT对接OpenAI软件系统。那么如…
阅读更多...
【命令行魔法：掌握Linux基础工具开发的独门技艺】

【命令行魔法：掌握Linux基础工具开发的独门技艺】

本节目标 1.Linux 软件包管理器 2.Linux开发工具 3.Linux编译器-gcc/g使用 4.Linux项目自动化构建工具-make/Makefile 5.Linux第一个小程序&#xff0d;进度条 1.Linux 软件包管理器 yum 什么是软件包 在Linux下安装软件, 一个通常的办法是下载到程序的源代码, 并进行编译…
阅读更多...
k8s资源管理操作——陈述式管理方式

k8s资源管理操作——陈述式管理方式

目录 陈述式资源管理方式 1、常用的kubernetes管理命令 1&#xff09;查看版本信息 2&#xff09;查看资源对象简写 3&#xff09;查看集群信息 4&#xff09;配置kubectl自动补全 5&#xff09;node节点查看日志 2、资源管理命令 1&#xff09;创建资源 2&#xff0…
阅读更多...
保姆级教程之SABO-VMD-CNN-SVM的分类诊断，特征可视化

保姆级教程之SABO-VMD-CNN-SVM的分类诊断，特征可视化

今天出一期基于SABO-VMD-CNN-SVM的分类诊断。 依旧是采用经典的西储大学轴承数据。基本流程如下&#xff1a; 首先是以最小包络熵为适应度函数&#xff0c;采用SABO优化VMD的两个参数。其次对每种状态的数据进行特征向量的求取&#xff0c;并为每组数据打上标签。然后将数据送入…
阅读更多...
Qt控件按钮大全

Qt控件按钮大全

​ 按钮 在 Qt 里，最常用使用的控件就是按钮了，有了按钮，我们就可以点击，从而响应事件，达到人机交互的效果。不管是嵌入式或者 PC 端，界面交互，少不了按钮。Qt 按钮部件是一种常用的部件之一，Qt 内置了六种按钮部件如下： （1） QPushButton:下压按钮 （2） QToolBu…
阅读更多...
使用docker部署ELK日志框架-Elasticsearch

使用docker部署ELK日志框架-Elasticsearch

一、ELK知识了解 1-ELK组件 工作原理&#xff1a; &#xff08;1&#xff09;在所有需要收集日志的服务器上部署Logstash&#xff1b;或者先将日志进行集中化管理在日志服务器上&#xff0c;在日志服务器上部署 Logstash。 &#xff08;2&#xff09;Logstash 收集日志&#…
阅读更多...
JJJ：python学习笔记

JJJ：python学习笔记

p4 没有编译的过程 源码和输入得到输出 静态语言&#xff1a;编译型 脚本语言&#xff1a;解释型 p5 又叫做胶水语言 p7 p8 p10
阅读更多...
蓝眼开源云盘部署全过程（手动安装）

蓝眼开源云盘部署全过程（手动安装）

环境概述&#xff1a; 系统-Centos7.4 数据库-MySQL8 云盘系统-Tank4.0.1 前提&#xff1a;操作系统已完成安装&#xff0c;有外部网络。 一.安装数据库 cd到合适的目录进行下载安装操作&#xff0c;期间不要切换出去。 wget https://dev.mysql.com/get/mysql80-community-r…
阅读更多...
Synchronized面试题

Synchronized面试题

一&#xff1a;轻量锁和偏向锁的区别&#xff1a; &#xff08;1&#xff09;争夺轻量锁失败时&#xff0c;自旋尝试抢占锁 &#xff08;2&#xff09;轻量级锁每次退出同步块都需要释放锁&#xff0c;而偏向锁是在竞争发生时才释放锁&#xff0c;线程不会主动释放偏向锁 二&…
阅读更多...
STM32 LL库 TIM3定时器多通道捕获输入采集

STM32 LL库 TIM3定时器多通道捕获输入采集

为什么不用HAL库&#xff0c;使用HAL库捕获输入一个通道还尚可&#xff0c;多通道捕获由于HAL的回调函数不符合我的要求&#xff0c;干脆直接切换到LL库。网上找了许多&#xff0c;代码处理写的不符合我的要求&#xff0c;这里记录一下我的调试过程。 TIM2输出1路PWM信号&#…
阅读更多...
电磁场与电磁波part1--矢量分析

电磁场与电磁波part1--矢量分析

目录 1、方向导数 2、散度定理&#xff08;高斯定理&#xff09; 3、散度与旋度的比较 4、旋度定理&#xff08;斯托克斯定理&#xff09; 5、关于点乘、叉乘、梯度、散度、旋度的计算 ~~~~~~~~~~~~~~~~~~~~~~~~ 确认过眼神&#xff0c;是我看不懂的 ~~~~~~~~~~~~~~~~…
阅读更多...
FPGA时序分析与约束（13）——I/O接口约束

FPGA时序分析与约束（13）——I/O接口约束

一、概述 在应用了时钟约束后&#xff0c;所有寄存器到寄存器的路径都能定时。为了获得更加精准的FPGA外部时序信息&#xff0c;设计者需要为FPGA的I/O接口指定时序信息&#xff0c;一般时序工具只能获取FPGA器件内部的时序信息&#xff0c;对于FPGA器件引脚之外的时序信息&…
阅读更多...
【C++】-- 红黑树详解

【C++】-- 红黑树详解

目录 一、红黑树概念 1.概念 2.性质 二、红黑树定义 1.红黑树节点定义 &#xff08;1&#xff09;将新插入节点置为红色 &#xff08;2&#xff09;将新插入节点置为黑色 2.红黑树定义 三、红黑树插入 1.插入节点 2.控制颜色 &#xff08;1&#xff09;父亲为黑色 &#xff0…
阅读更多...
如何使用 Github Action 管理 Issue

如何使用 Github Action 管理 Issue

本文作者为 360 奇舞团前端开发工程师 Daryl 前言 很多小伙伴打开 github 上的仓库都只使用Code查看代码&#xff0c;或者只是把 github 当成一个代码仓库&#xff0c;但是 github 还提供了很多好用的功能。 其中&#xff0c;GitHub Action就是一个很好用的功能&#xff0c;本文…
阅读更多...
EfficientNet：通过模型效率彻底改变深度学习

EfficientNet：通过模型效率彻底改变深度学习

一、介绍 EfficientNet 是深度学习领域的里程碑&#xff0c;代表了神经网络架构方法的范式转变。EfficientNet 由 Google Research 的 Mingxing Tan 和 Quoc V. Le 开发&#xff0c;在不影响性能的情况下满足了对计算高效模型不断增长的需求。本文深入探讨了 EfficientNet 背后…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023