PAT A1134 Vertex Cover【对边进行哈希】⭐⭐⭐⭐⭐

37 篇文章 1 订阅

题目描述

在这里插入图片描述

知识点

图、STL

实现

码前思考

  1. 由于之前看了柳神的某一题的题解,想到了使用u*10000+v对边进行标记,但是我还是道行不够深。。。

代码实现

#include "bits/stdc++.h"
using namespace std;
const int maxn = 1e4+10; 
const int multi = 10000;
//边采用特殊的方式编号
//大顶点*10000+小顶点 
unordered_set<int> st;

int n;
int m;
int k;
vector<int> adj[maxn]; 

int main(){
	scanf("%d%d",&n,&m);
	for(int i=0;i<m;i++){
		int u;
		int v;
		scanf("%d %d",&u,&v);
		adj[u].push_back(v);
		adj[v].push_back(u);
	}
	scanf("%d",&k);
	for(int i=0;i<k;i++){
		st.clear();
		int nv;
		scanf("%d",&nv);
		for(int j=0;j<nv;j++){
			int u;
			scanf("%d",&u);
			for(int i=0;i<adj[u].size();i++){
				if(adj[u][i] >= u){
					st.insert(adj[u][i]*multi+u); 
				}else{
					st.insert(u*multi+adj[u][i]);
				}
			}	
		}
		//判断set的个数是否等于边数
		if(st.size() == m){
			printf("Yes\n");
		}else{
			printf("No\n");
		} 
	}
	

	return 0;
}

码后反思

  1. 柳神是直接在一开始就是对边进行编号,邻接表中存储边的编号,而不是邻接点,真是牛逼。
#include <iostream>
#include <vector>
using namespace std;
int main() {
    int n, m, k, nv, a, b, num;
    scanf("%d%d", &n, &m);
    vector<int> v[n];
    for (int i = 0;i < m; i++) {
        scanf("%d%d", &a, &b);
        v[a].push_back(i);
        v[b].push_back(i);
    }
    scanf("%d", &k);
    for (int i = 0; i < k; i++) {
        scanf("%d", &nv);
        int flag = 0;
        vector<int> hash(m, 0);
        for (int j = 0; j < nv; j++) {
            scanf("%d", &num);
            for (int t = 0; t < v[num].size(); t++)
                hash[v[num][t]] = 1;
        }
        for (int j = 0; j < m; j++) {
            if (hash[j] == 0) {
                printf("No\n");
                flag = 1;
                break;
            }
        }
        if (flag == 0) printf("Yes\n");
    }
    return 0;
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 用Python实现Dijkstra算法的堆优化需要使用堆数据结构来存储节点,然后使用优先队列来保存最小距离的节点,以便从中每次选取最小距离的节点。这样可以提高搜索算法的效率,从而实现Dijkstra算法的堆优化。 ### 回答2: Dijkstra算法是一种用于求解最短路径问题的经典算法,但其在处理大规模图时效率较低。为了提高其效率,可以通过堆优化的方式来实现。下面是用Python对Dijkstra算法进行堆优化的一种方法: 1. 首先,导入所需的库,包括heapq(堆队列算法模块)和sys(系统相关模块): ```python import heapq import sys ``` 2. 创建一个图的类,包括初始化、添加边和运行Dijkstra算法的方法: ```python class Graph: def __init__(self, vertex_num): self.vertex_num = vertex_num self.edges = [[] for _ in range(vertex_num)] def add_edge(self, u, v, weight): self.edges[u].append((v, weight)) def dijkstra(self, start): distances = [sys.maxsize] * self.vertex_num # 初始距离设置为无穷大 distances[start] = 0 heap = [(0, start)] # 用堆来保存节点和其距离的元组 while heap: curr_distance, curr_vertex = heapq.heappop(heap) # 弹出堆顶(距离最短的节点) if curr_distance > distances[curr_vertex]: # 如果该节点已被处理过,则跳过 continue for neighbor, edge_weight in self.edges[curr_vertex]: # 遍历当前节点的邻居节点 distance = curr_distance + edge_weight if distance < distances[neighbor]: # 更新邻居节点的最短距离 distances[neighbor] = distance heapq.heappush(heap, (distance, neighbor)) # 将邻居节点及其更新后的距离压入堆 return distances ``` 3. 创建一个Graph对象,并调用其方法添加边和运行Dijkstra算法: ```python if __name__ == "__main__": g = Graph(6) g.add_edge(0, 1, 5) g.add_edge(0, 2, 2) g.add_edge(1, 3, 4) g.add_edge(1, 4, 2) g.add_edge(2, 1, 1) g.add_edge(2, 3, 4) g.add_edge(3, 4, 2) g.add_edge(3, 5, 5) g.add_edge(4, 5, 3) distances = g.dijkstra(0) print(distances) ``` 上述代码实现了对Dijkstra算法的堆优化。通过使用堆来保存节点和其距离的元组,可以在每次选择最短距离的节点时提高效率。此外,在处理大规模图时,Dijkstra算法的堆优化版本相对于原始版本具有更高的效率。 ### 回答3: Dijkstra算法是一种用于解决最短路径问题的经典算法,它可以在带权重的有向图中找到起点到其他所有顶点的最短路径。 要实现Dijkstra算法的堆优化,首先需要引入堆数据结构。Python中可以使用heapq模块来实现堆。 接下来,我们需要定义一个最小堆,并初始化一个距离数组和堆数组。距离数组用于存储每个顶点到起点的距离,堆数组用于存储顶点的索引。 首先,将起点的距离设置为0,并将其添加到堆中。然后,对于堆不为空的情况下,重复以下步骤: 1. 弹出堆中最小距离的顶点作为当前顶点。 2. 遍历当前顶点的所有邻接顶点,计算通过当前顶点到达这些邻接顶点的距离。 3. 如果新的距离小于邻接顶点的当前距离,则更新距离数组,并将邻接顶点添加到堆中。 最后,距离数组中存储的即为起点到其他所有顶点的最短路径长度。 下面是使用Python实现Dijkstra算法的堆优化的示例代码: ```python import heapq def dijkstra_heap(graph, start): n = len(graph) distance = [float('inf')] * n distance[start] = 0 heap = [] heapq.heappush(heap, (0, start)) while heap: dist, node = heapq.heappop(heap) if dist > distance[node]: continue for neighbor, weight in graph[node]: new_dist = dist + weight if new_dist < distance[neighbor]: distance[neighbor] = new_dist heapq.heappush(heap, (new_dist, neighbor)) return distance ``` 在这个例子中,`graph`是一个邻接表形式的图表示,`start`是起点的索引。函数`dijkstra_heap`返回一个包含起点到其他顶点的最短路径距离的数组。 这就是如何使用Python对Dijkstra算法进行堆优化的方法。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值