Leetcode、poj图（basic(2)）

最新推荐文章于 2024-07-17 12:13:29 发布
最新推荐文章于 2024-07-17 12:13:29 发布
阅读量156 收藏
点赞数
分类专栏： 图 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46485428/article/details/107379140
版权

简单做个刷题记录，涉及的知识点是：最小生成树、最短路径

网络延迟时间

https://leetcode-cn.com/problems/network-delay-time/
思路：可以当做最短路径的模板题，采用DisjKstra算法和 Floyd算法都可以，不了解的可以看一下王卓老师的教学PPT
DisjKstra算法：
在这里插入图片描述
Floyd算法：在这里插入图片描述

解法一：DisjKstra算法
class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int N, int K) {
        //构建有向图
        vector<vector<long long>> graph(N+1,vector<long long>(N+1,INT_MAX));//用 long long类型是防止溢出，如 INT_MAX+2
        //使用邻接矩阵存储邻接关系
        for(int i = 0;i<times.size();i++){
            graph[times[i][0]][times[i][1]] = times[i][2];
        }
        for(int i = 1;i<=N;i++){
            graph[i][i] = 0;
        }
        vector<bool> visited(N+1,false);
        visited[K] = true;

        for(int i = 1;i<N;i++){
            int index = 0;
            int dis = INT_MAX;//每次在未访问的点中找到距离K最近的那个
            for(int j = 1;j<=N;j++){
                if(visited[j]==false&&graph[K][j]<dis){
                    dis = graph[K][j];
                    index = j;
                }
            }
            visited[index] = true;
            //加入这个点后，更新最短路径图
            for(int j = 1;j<=N;j++){
                if(graph[K][index]+graph[index][j]<graph[K][j]){
                    graph[K][j] = graph[K][index]+graph[index][j];
                }
            }
        }

        int res = 0;
        for(int i = 1;i<=N;i++){
            if(graph[K][i]==INT_MAX){
                return -1;
            }
            res = max(res,(int)graph[K][i]);//max比较的两个数必须类型相同，因此要用类型转换
        }
        return res;
    }
};

解法二：Floyd算法
class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int N, int K) {
        //构建有向图
        vector<vector<long long>> graph(N+1,vector<long long>(N+1,INT_MAX));//用 long long类型是防止溢出，如 INT_MAX+2
        for(int i = 0;i<times.size();i++){
            graph[times[i][0]][times[i][1]] = times[i][2];
        }
        for(int i = 1;i<=N;i++){
            graph[i][i] = 0;
        }

        for(int k = 1;k<=N;k++){
            for(int i = 1;i<=N;i++){
                for(int j = 1;j<=N;j++){
                    graph[i][j] = min(graph[i][j],graph[i][k]+graph[k][j]);
                }
            }
        }

        int res = 0;
        for(int i = 1;i<=N;i++){
            if(graph[K][i]==INT_MAX){
                return -1;
            }
            res = max(res,(int)graph[K][i]);//max比较的两个数必须类型相同，因此要用类型转换
        }
        return res;
    }
};
阈值距离内邻居最少的城市

https://leetcode-cn.com/problems/find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance/
思路：Dijkstra 算法。dis数组用于记录两城市间最短距离，遍历每一个城市city[i]，通过Dijkstra算法找到城市city[i]到其余（n - 1）个城市的最短距离，并将结果保存在dis[i]中。再通过遍历dis数组，找与城市city[i]的最短距离小于等于threshold distance的城市个数。每次比较以某一个城市为起点且最短路径距离小于等于threshold distance最终得到的城市个数，找到最大编号，即为所求

class Solution {
public:
    int findTheCity(int n, vector<vector<int>>& edges, int distanceThreshold) {
         int Max = 0xfff;
        vector<vector<int>> graph(n,vector(n,-1));
        for(int i = 0;i<edges.size();i++){
            graph[edges[i][0]][edges[i][1]]=edges[i][2];
            graph[edges[i][1]][edges[i][0]]=edges[i][2];
        }
        int res = 0;
        //每个结点作为源，求到其他顶点的最短路径
        for(int i = 0;i<n;i++){
            vector<int> dis (n,INT_MAX);
            dis[i] = 0; 

            queue<int> q;
            for(int j = 0;j<n;j++){
                if(graph[i][j]!=-1){
                    dis[j] = graph[i][j];//把直接相连的顶点长度值存储到dis数组中
                    q.push(j);
                }
            }
            while(!q.empty()){
                int t = q.front();
                q.pop();
                for(int j = 0;j<n;j++){
                    if(graph[t][j]!=-1){
                        if(dis[t]+graph[t][j]<dis[j]&&dis[t]+graph[t][j]<=distanceThreshold){
                            dis[j] = dis[t]+graph[t][j];
                            q.push(j);
                        }
                    }
                }
            }
            int val = 0;
            for(int j = 0;j<n;j++){
                if(j!=i&&dis[j]>0&&dis[j]<=distanceThreshold)
                    val++;//含有的节点数量
            }
            if(val<=Max){
                Max = val;
                res = i;
            }
        }
        return res;
    }
};
课程安排 IV

https://leetcode-cn.com/problems/course-schedule-iv/
思路：Floyd算法。直接套模板。

class Solution {
public:
    vector<bool> checkIfPrerequisite(int n, vector<vector<int>>& prerequisites, vector<vector<int>>& queries) {
        vector<vector<int>> graph(n,vector<int>(n,0xfff));
        for(int i = 0;i<n;i++){
            graph[i][i] = 0;
        }
        for(int j = 0;j<prerequisites.size();j++){
            graph[prerequisites[j][0]][prerequisites[j][1]] = 1;
        }
        //Floyd算法
        for(int k = 0;k<n;k++){
            for(int i = 0;i<n;i++){
                for(int j = 0;j<n;j++){
                    if(graph[i][j]>graph[i][k]+graph[k][j]){
                        graph[i][j] = graph[i][k]+graph[k][j];
                    }
                }
            }
        }
        vector<bool> res(queries.size(),false);
        for(int i = 0;i<queries.size();i++){
            res[i] = graph[queries[i][0]][queries[i][1]]!=0xfff;
        }
        return res;
    }
};
K 站中转内最便宜的航班

https://leetcode-cn.com/problems/cheapest-flights-within-k-stops/
思路：基于动态规划的Bellman-Ford算法。设dp(k, i)表示由src最多经过k个中转站到达i的最低花费。因此可以推知dp(k, i) = min（dp(k-1, i), dp(k-1, j) + w(j, i)）
所以要求得dp(k, dst)即要求dp(k-1, dst)和dp(k-1, u)的值

class Solution {
public:
    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int K) {
        vector<long long> dis(n,INT_MAX);
        dis[src] = 0;
        for(int i = 0;i<=K;i++){
            vector<long long> pre = dis;
            for(int j = 0;j<flights.size();j++){
                dis[flights[j][1]] = min(dis[flights[j][1]],pre[flights[j][0]]+flights[j][2]);
            }
        }
        return (int)dis[dst]==INT_MAX?-1:(int)dis[dst];
    }
};
最小生成树模板题

poj的这三道题感觉更适合基础练习（直接套模板 ）

Truck History

http://poj.org/problem?id=1789
思路：题目要找到合适的方案使得总代价最小，也就是距离最小（两个编号之间的距离代表这两个编号之间不同字母的个数），假如把每一个字符串当作图的一个顶点，两个字符串的距离当作两点之间的权值，那么问题可以转化为求最小生成树的最小代价问题。因此可用prim算法来求最小生成树从而得到最终结果

#include <iostream>
using namespace std;

int t;
char graph[2001][10];
int w[2001][2001];
int dis[2001];//dis数组是每一个顶点到生成树的任意一个顶点到的最短距离 
int visited[1001];
int cal(int f,int s){
	int dis = 0;
	for(int i = 0;i<7;i++){
		if(graph[f][i]!=graph[s][i])
			dis++;
	}
	return dis;
}
//prime算法
int prime(){
	int res = 0;
	for(int i = 1;i<=t;i++){
		dis[i] = INT_MAX;
		visited[i] = 0;
	}
	dis[1] = 0;
	for(int i = 1;i<=t;i++){
		int index,Min = INT_MAX;
		for(int j = 1;j<=t;j++){//从dis数组中找到离生成树最近的顶点下标 
			if(!visited[j]&&dis[j]<=Min){
				Min = dis[j];
				index = j;
			}
		}
		visited[index] = 1;
		res+=dis[index];
		//以index为中间点，更新生成树到每一个非树顶点的距离 
		for(int k = 1;k<=t;k++){
			if(!visited[k]){
				dis[k] = min(dis[k],w[index][k]);
			}
		}
	}
	return res;
}
int main(){
	while(scanf("%d",&t)!=EOF){
		if(t==0)
			break;
		for(int i = 1;i<=t;i++){
			scanf("%s",graph[i]);
		}
		for(int i = 1;i<=t;i++){
			for(int j = i+1;j<=t;j++){
				w[i][j] = cal(i,j);
				w[j][i] = w[i][j];
			}
		}
		int res = prime();
		printf("The highest possible quality is 1/%d.\n",res);
	}
	return 0;	
}
Highways

http://poj.org/problem?id=2485
思路：求最小生成树的最大边
Prim算法：

#include <iostream>
using namespace std;

int t,n;
int w[501][501];//代价矩阵 
int visited[501];
int dis[501];

int Prim(){
	for(int i = 1;i<=n;i++){
		dis[i] = w[1][i];
		visited[i] = 0;
	}
	visited[1] = 1;//将第一个顶点加入最小生成树中 
	int res = -1;
	for(int i = 1;i<=n-1;i++){
		int Min = INT_MAX;
		int index = 0;
		for(int j = 1;j<=n;j++){
			if(!visited[j]&&dis[j]<Min){//没有在最小生成树中且权值最小的边 
				Min = dis[j];
				index = j;
			}
		} 
		res = res>Min?res:Min;
		visited[index] = 1;
		for(int j = 1;j<=n;j++){
			if(!visited[j]&&dis[j]>w[index][j]){
				dis[j] = w[index][j];
			}
		}
	}
	return res;
}
int main(){
	scanf("%d",&t);
	while(t--){
		scanf("%d",&n);
		for(int i = 1;i<=n;i++){
			for(int j = 1;j<=n;j++){
				scanf("%d",&w[i][j]);
			}
		}
		int res = Prim();
		printf("%d\n",res);
	}
	return 0;	
}

Kruskal算法

#include <iostream>
#include <algorithm>
using namespace std;

int t,n;
int f[505]; 
struct Node{
	int s,e,dis;
}w[1000];
int compare(Node a,Node b){
	return a.dis<b.dis;
}

void Init(){
	for(int i = 0;i<=n;i++){
		f[i] = i;
	}
}
//并查集寻找是否是同一个根节点 
int find(int num){
	if(f[num]==num)
		return num;
	else{
		//路径压缩 
		f[num] = find(f[num]);
		return f[num];
	}
}
bool merge(int a,int b){
	int t1 = find(a);
	int t2 = find(b);
	if(t1!=t2){//判断两个点是否在同一个集合当中 
		f[t2] = t1;
		return true;
	}
	return false; 
}
int main(){
	scanf("%d",&t);
	while(t--){
		scanf("%d",&n);
		int a,k = 0;
		for(int i = 1;i<=n;i++){
			for(int j = 1;j<=n;j++){
				scanf("%d",&a);
				if(i<j){//存储一半的数据
				 	w[k].s = i;
				 	w[k].e = j;
				 	w[k].dis = a;
					k++;	
				}
			}
		}
		sort(w+1,w+k+1,compare);//按距离从小到大对边进行排列
	
		//并查集初始化
		Init();
		int Max = 0;
		//Kruskal核心算法部分
		for(int i = 1;i<=k;i++){//从小到大枚举每一条边
			if(merge(w[i].s,w[i].e)) {
				if(Max<w[i].dis)//判断是否是最大边
					Max = w[i].dis; 
			}	
		} 
		printf("%d\n",Max);
	}
	return 0;	
}
Agri-Net

http://poj.org/problem?id=1258
思路：求最小生成树的最小代价

//Prime算法 
#include <iostream>
#include <climits>
using namespace std;

int t;
int graph[105][105];
int dis[105];
int vis[105];
int Prime(){
	for(int i = 1;i<=t;i++){
		dis[i] = graph[1][i];
		vis[i] = 0;
	}
	vis[1] = 1;
	int res = 0;
	for(int i = 1;i<=t-1;i++){
		int Min = INT_MAX;
		int index = 0;
		for(int j = 1;j<=t;j++){
			if(!vis[j]&&dis[j]<Min){
				Min = dis[j];
				index = j;
			}
		}
		res += Min;
		vis[index] = 1;
		for(int k = 1;k<=t;k++){
			if(!vis[k]){
				dis[k] = min(dis[k],graph[index][k]);
			}
		}
	}
	return res;
}

int main(){
	scanf("%d",&t);
	for(int i = 1;i<=t;i++){
		for(int j = 1;j<=t;j++){
			scanf("%d",&graph[i][j]);
		}
	}
	int val = Prime();
	printf("%d\n",val);
	return 0;
}
编程小鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
poj还是leetcode-ProgrammingCompetionCareer:编程竞赛生涯
07-06
poj还是leetcode ProgrammingCompetionCareer 大学的竞赛生涯结束了，抽时间整理了一部分曾经在OJ刷过的题，还有一些找不到了，或者是因为杂物太多（除了代码以外还有题解的pdf、题目的测试数据等等），不想整理了就没有放上来。 以后可能把做题当成一种兴趣爱好吧，退役了之后也不会像当初那样投入那么多的时间去做题，毕竟还是有很多其它的事情要做。 codefores/problemset/还有HDUOJ、POJ和洛谷/这几个文件夹的以后可能还会更新吧，因为无聊的时候可能会去刷刷题，当然其它的也有可能更新，以后的事也说不准。 update 20210123 开始转战。以后有时间偶尔可能会在上面刷刷题或者打打周赛。
bfs和dfs:poj2386和leetcode130
aigui1439的博客
04-22 117
poj2386 如果发现一个’W’则使用dfs递归将与其相连的’W’都改为’.’，每遇到一个’W’（亦即调用一次dfs）将ans加一（发现一个水坑）。 #include <iostream> using namespace std; const int MAX_NM = 105; char ch[MAX_NM][MAX_NM]; int m, ...
poj和leetcode|44带通配符的字符串匹配
zxxc111的博客
08-03 251
给定一个字符串 (s) 和一个字符模式 § ，实现一个支持 ‘?’ 和 ‘*’ 的通配符匹配。 ‘?’ 可以匹配任何单个字符。 ‘*’ 可以匹配任意字符串（包括空字符串）。 两个字符串完全匹配才算匹配成功。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/wildcard-matching 不说了，本人就是菜，对着leetcode的反例反复修改。 简洁的大佬答案，请移步：大佬的代码 大佬代码思路是动态规划。 A[i][j]表示是a[i]和b[j]之前的
POJ.2559[leetcode.84]直方图最大矩形及二维情况
某科学的程序员
08-10 1743
LeetCode Hard 84 . Largest Rectangle in Histogram POJ 2559 Largest Rectangle in a Histogram | N=10W GDUFE OJ 1181 | N=5000 给出一个直方图，求里面的最大矩形面积，如下图面积为10。 暴力 O(n^2) 最简单粗暴的办法是对于每个方块，我们求出它向左和向右能延...
LeetCode 1. 两数之和（哈希）
Michael是个半路程序员
07-24 9724
题目链接：https://leetcode-cn.com/problems/two-sum/ 1. 暴力解法 class Solution { public: vector<int> twoSum(vector<int>& nums, int target) { int i,j; vector<int&gt...
leetcode_basic_60
02-14
这个“leetcode_basic_60”主题可能聚焦于LeetCode上的第60题，即“Permutation Sequence”（排列序列）。这个问题涉及到组合数学、递归和字符串处理，是Python编程者常见的练习题目。 【描述】"leetcode_basic_60...
leetcode-常见考题2.pdf
02-23
leetcode-常见考题2.pdf
leetcode2-leetcode2:leetcode2
06-30
这个名为"leetcode2-leetcode2:leetcode2"的压缩包可能包含了一个与LeetCode相关的项目或者是一系列关于LeetCode问题的解决方案。由于描述只重复了标题，没有提供更多信息，我们将主要围绕LeetCode和“系统开源”这...
【每日一题】LeetCode. 67. 二进制求和
Johnson的博客
06-23 189
每日一题，防止痴呆 = = 一、题目大意 给你两个二进制字符串，返回它们的和（用二进制表示）。 输入为 非空 字符串且只包含数字 1 和 0。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/add-binary 二、题目思路以及AC代码 思路 这题思路无非就是两种，一种是转化为十进制数，直接利用加法去做，当然这里给定二进制数长度最大时10000，所以可能需要利用大数加法来做。另一种就是直接模拟进行加法。 这里我是直接模拟来做的，直接设立指针从最.
POJ 刷题顺序
热门推荐
thestoryofsnow的专栏
11-09 30万+
POJ从简到难（按照AC数目排序）的列表如下，作为小弱的刷题
oj和leetcode区别_Leetcode上的题目相当于什么水准？
weixin_31308305的博客
12-23 2634
个人水平正好大概在leetcode和acm之间…大概感受是easy是真的easy，mid不至于一眼但面试那几分钟也能整出来，hard有大概方向但可能得想想写一阵…对大多数人来说，ez适合计算机初学者和完全没接触过编程题的同学…面试简单的话会问这种…mid是程序员应该有的水准，做的费劲找工作也会费劲…属于面试正常难度…hard对不打oi/acm没怎么刷题过的会比较难，确实也没有直接的作用…偶尔面试会...
LeetCode 1480. 一维数组的动态和（前缀和）
Michael是个半路程序员
06-14 1164
1. 题目 给你一个数组 nums 。数组「动态和」的计算公式为：runningSum[i] = sum(nums[0]…nums[i]) 。 请返回 nums 的动态和。 示例 1： 输入：nums = [1,2,3,4] 输出：[1,3,6,10] 解释：动态和计算过程为 [1, 1+2, 1+2+3, 1+2+3+4] 。 示例 2： 输入：nums = [1,1,1,1,1] 输出：[1,2,3,4,5] 解释：动态和计算过程为 [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1
POJ 2479 最大子段和 解题心得
petercsj的专栏
09-17 1351
问题描述：         给一串整数下标从1~n，找出两个子串（每个子串中的下标连续），下标分别为s1~t1和s2~t2,其中1 引：求一串数中一个连续子串和最大值的DP解法为:设原数组为a[]令b[j]为以第j个元素结尾的字串和的最大值。只有两种情况：1.只有a[j]  2.a[j]接在以a[j-1]结尾的字串后面对于情况二的证明，可用反证法证明得，以a[j
【Java--数据结构】二叉树
2301_80898480的博客
07-16 1055
如有错误，欢迎指出~
数据结构第32节 无锁编程
最新发布
hummhumm的专栏
07-17 835
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
常见排序算法总结
mydaily_的博客
07-16 825
大概是因为插入排序没预处理，极端情况可能让一个很小很右的数一直比比比比比，比到最开头，浪费比较次数。某种情况比计数排序好，因为数字，如果按照普通十进制理解，则只需准备10个不同数字的桶就好了！整体的quickSort函数swap后，再进行partition，划分三部分后，所以这种不基于比较的算法应用范围很局限，大部分情况下，不如之前的所有比较算法！前提得知道空间范围，比如人的年龄，正数[0-200]，否则内存爆炸！间隔分组，且分组间隔依次减半，每次分组后，每个组内排序都是插入排序。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1888
栈超超超详解
数据结构(5.1)——树的性质
m0_65240792的博客
07-16 233
1%29%5D。
vscode配置leetcode刷题图片加载
09-24
配置VS Code以加载LeetCode刷题图片的方法如下： 1. 打开VS Code，点击左侧的扩展按钮（四个方块组成的图标）。 2. 在搜索框中输入"leetcode"并选择"LeetCode"插件，点击安装。 3. 安装完成后，点击左侧的"LeetCode...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值