给你一个points 数组,表示 2D 平面上的一些点,其中 points[i] = [xi, yi] 。
连接点 [xi, yi] 和点 [xj, yj] 的费用为它们之间的 曼哈顿距离 :|xi - xj| + |yi - yj| ,其中 |val| 表示 val 的绝对值。
请你返回将所有点连接的最小总费用。只有任意两点之间 有且仅有 一条简单路径时,才认为所有点都已连接。
示例 1:
输入:points = [[0,0],[2,2],[3,10],[5,2],[7,0]]
输出:20
解释:
我们可以按照上图所示连接所有点得到最小总费用,总费用为 20 。
注意到任意两个点之间只有唯一一条路径互相到达。
思路:最小生成树——Kruskal算法
首先将所有边按权值大小升序排好,然后从权值最小的边开始遍历,如果这条边和最小生成树中的其它边不会形成环,则将它加入最小生成树;否则,这条边不是最小生成树的一部分,不能将它加进去。
判断是否成环需要用到并查集:对于添加的这条边,如果它的两个节点在同一连通分量里,那么添加这条边会产生环;反之,如果它的两个节点不在同一连通分量里,则添加这条边不会产生环。
class UF
{
public:
vector<int> parent;
int count=0;
UF(int n)//构造函数,初始化count和parent
{
parent.resize(n);
count=n;
for(int i=0;i<n;i++)
{
parent[i]=i;
}
}
void uni(int p,int q)
{
int rootP=find(p);
int rootQ=find(q);
if(rootP==rootQ)
return ;
else
{
parent[rootP]=rootQ;
count--;
}
}
int find(int x)
{
if(x!=parent[x])
{
parent[x]=find(parent[x]);
}
return parent[x];
}
};
struct Edge//用结构体来存储边的信息,如果用vector存,会超时
{
int i,j,weight;//起点、终点、权值
Edge(int i,int j,int weight):i(i),j(j),weight(weight)//构造函数,列表初始化
{
}
};
class Solution {
public:
//如果选择在类内定义cmp比较规则,需要定义为静态成员函数,静态成员函数属于类,没有this指针参数
//因为成员函数默认拥有this指针作为函数参数,而sort()函数的第三个cmp函数指针参数中并没有this指针参数,
//因此会出现输入的cmp参数和sort()要求的参数不匹配,报错
//static bool cmp(Edge a,Edge b)
//{
// return a.weight<b.weight;
//}
int minCostConnectPoints(vector<vector<int>>& points) {
int n=points.size();
vector<Edge> edges;
for(int i=0;i<n;i++)
{
for(int j=i+1;j<n;j++)
{
int xi=points[i][0];
int yi=points[i][1];
int xj=points[j][0];
int yj=points[j][1];
int weight=abs(xi-xj)+abs(yi-yj);
Edge e(i,j,weight);
edges.push_back(e);
}
}
sort(edges.begin(),edges.end(),[](Edge a, Edge b){return a.weight<b.weight; });
UF uf(n);
int sumMin=0;
for(Edge e:edges)
{
int p=e.i;
int q=e.j;
int weight=e.weight;
if(uf.find(p)==uf.find(q))//构成边的两个结点在同一连通分量中,不把它加入最小生成树
continue;
else//反之,则加入最小生成树
{
uf.uni(p,q);
sumMin+=weight;
}
}
return sumMin;
}
};
细节:
1.sort(iterator.begin(),iterator.end(),_callback)
(2条消息) 错误解决方法:error: reference to non-static member function must be called_alex_mist的博客-CSDN博客
2.lambda表达式,[](函数参数){函数体内的语句写完记得加 ; }
sort(edges.begin(),edges.end(),[](Edge a, Edge b){return a.weight<b.weight ; });
3.用“vector<int>().swap(v)”来释放容器v的空间
给你一个 n
个点组成的无向图边集 edgeList
,其中 edgeList[i] = [ui, vi, disi]
表示点 ui
和点 vi
之间有一条长度为 disi
的边。请注意,两个点之间可能有 超过一条边 。
给你一个查询数组queries
,其中 queries[j] = [pj, qj, limitj]
,你的任务是对于每个查询 queries[j]
,判断是否存在从 pj
到 qj
的路径,且这条路径上的每一条边都 严格小于 limitj
。
请你返回一个 布尔数组 answer
,其中 answer.length == queries.length
,当 queries[j]
的查询结果为 true
时, answer
第 j
个值为 true
,否则为 false
。
示例 1:
输入:n = 3, edgeList = [[0,1,2],[1,2,4],[2,0,8],[1,0,16]], queries = [[0,1,2],[0,2,5]] 输出:[false,true] 解释:上图为给定的输入数据。注意到 0 和 1 之间有两条重边,分别为 2 和 16 。 对于第一个查询,0 和 1 之间没有小于 2 的边,所以我们返回 false 。 对于第二个查询,有一条路径(0 -> 1 -> 2)两条边都小于 5 ,所以这个查询我们返回 true 。
示例 2:
输入:n = 5, edgeList = [[0,1,10],[1,2,5],[2,3,9],[3,4,13]], queries = [[0,4,14],[1,4,13]] 输出:[true,false] 解释:上图为给定数据。
思路:并查集+贪心
给定一个查询时,我们可以遍历 edgeList 中的所有边,依次将长度小于limit 的边加入到并查集中,然后使用并查集查询 p 和 q 是否属于同一个集合。如果 p 和 q 属于同一个集合,则说明存在从 p 到 q 的路径,且这条路径上的每一条边的长度都严格小于limit,查询返回 true,否则查询返回 false。
如果 queries 的 limit 是非递减的,显然上一次查询的并查集里的边都是满足当前查询的 limit 要求的,我们只需要将剩余的长度小于limit 的边加入并查集中即可。基于此,我们首先将 edgeList 按边长度从小到大进行排序,然后将 queries 按 limit 从小到大进行排序,使用 k 指向上一次查询中不满足 limit 要求的长度最小的边,初始时 k=0。
我们依次遍历 queries:如果 k 指向的边的长度小于对应查询的 limit,则将该边加入并查集中,然后将 k 加 1,直到 k 指向的边不满足要求;最后根据并查集查询对应的 p 和 q 是否属于同一集合来保存查询的结果。
检查边长度限制的路径是否存在 - 检查边长度限制的路径是否存在 - 力扣(LeetCode)
class UF
{
public:
UF(int n) {
parent.resize(n);
for(int i=0;i<parent.size();i++) {
parent[i]=i;
}
}
void uni(int p,int q) {
int parent1=find(p);
int parent2=find(q);
if(parent1==parent2)
return ;
parent[parent1]=parent2;
}
int find(int x) {
if(x!=parent[x])
{
parent[x]=find(parent[x]);
}
return parent[x];
}
bool connected(int p,int q) {
return find(p)==find(q);
}
private:
vector<int> parent;
};
class Solution {
public:
vector<bool> distanceLimitedPathsExist(int n, vector<vector<int>>& edgeList, vector<vector<int>>& queries) {
UF uf(n);
vector<bool> ans(queries.size(),false);
sort(edgeList.begin(),edgeList.end(),[](vector<int>& a,vector<int>& b){return a[2]<b[2];});//按边长升序排序edgeList
vector<int> index(queries.size());//记录queries数组的下标,保证排序后还能找到原位置
iota(index.begin(),index.end(),0);//iota自动递增填充的函数,从0开始递增,填充index数组
sort(index.begin(),index.end(),[&](int i,int j){return queries[i][2]<queries[j][2];});//queries数组顺序不变,按queries[i][2]的大小来排index数组
int k=0;
for(int i=0;i<queries.size();i++)
{
for(int j=k;j<edgeList.size();j++)
{
if(edgeList[j][2]<queries[index[i]][2])//只要满足边长小于限制就加入并查集中
{
uf.uni(edgeList[j][0],edgeList[j][1]);
}
else//一旦出现边长大于等于限制
{
k=j;
break;//跳出循环,且记录当前在edgelist中的遍历位置,下一个限制从此位置出发进行遍历
}
}
//记录结果,此时在同一连通分量中,就代表可在限制内到达
ans[index[i]]=uf.connected(queries[index[i]][0],queries[index[i]][1]);
}
return ans;
}
};