algorithm/leetcode-master
1
0
Fork 0
mirror of https://github.com/youngyangyang04/leetcode-master.git synced 2025-07-07 15:45:40 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #752 from youngqqcn/master

Browse Source 
0684.冗余连接, 0685.冗余连接II，增加Java, Golang, Python实现
This commit is contained in:
程序员Carl
2021-09-17 09:09:20 +08:00
committed by GitHub
parent 105c35e713 3ac368fc5a
commit 6418abe040
3 changed files with 473 additions and 8 deletions
Download Patch File Download Diff File Expand all files Collapse all files

148
problems/0684.冗余连接.md
View File

@ -10,6 +10,9 @@
# 684.冗余连接
[力扣题目链接](https://leetcode-cn.com/problems/redundant-connection/)
树可以看成是一个连通且 无环 的 无向 图。
给定往一棵 n 个节点 (节点值 1～n) 的树中添加一条边后的图。添加的边的两个顶点包含在 1 到 n 中间，且这条附加的边不属于树中已存在的边。图的信息记录于长度为 n 的二维数组 edges ，edges[i] = [ai, bi] 表示图中在 ai 和 bi 之间存在一条边。
@ -140,16 +143,161 @@ public:
## Java
```java
class Solution {
private int n; // 节点数量3 到 1000
private int[] father;
public Solution() {
n = 1005;
father = new int[n];
// 并查集初始化
for (int i = 0; i < n; ++i) {
father[i] = i;
}
}
// 并查集里寻根的过程
private int find(int u) {
if(u == father[u]) {
return u;
}
father[u] = find(father[u]);
return father[u];
}
// 将v->u 这条边加入并查集
private void join(int u, int v) {
u = find(u);
v = find(v);
if (u == v) return ;
father[v] = u;
}
// 判断 u 和 v是否找到同一个根，本题用不上
private Boolean same(int u, int v) {
u = find(u);
v = find(v);
return u == v;
}
public int[] findRedundantConnection(int[][] edges) {
for (int i = 0; i < edges.length; i++) {
if (same(edges[i][0], edges[i][1])) {
return edges[i];
} else {
join(edges[i][0], edges[i][1]);
}
}
return null;
}
}
```
## Python
```python
class Solution:
def __init__(self):
"""
初始化
"""
self.n = 1005
self.father = [i for i in range(self.n)]
def find(self, u):
"""
并查集里寻根的过程
"""
if u == self.father[u]:
return u
self.father[u] = self.find(self.father[u])
return self.father[u]
def join(self, u, v):
"""
将v->u 这条边加入并查集
"""
u = self.find(u)
v = self.find(v)
if u == v : return
self.father[v] = u
pass
def same(self, u, v ):
"""
判断 u 和 v是否找到同一个根，本题用不上
"""
u = self.find(u)
v = self.find(v)
return u == v
def findRedundantConnection(self, edges: List[List[int]]) -> List[int]:
for i in range(len(edges)):
if self.same(edges[i][0], edges[i][1]) :
return edges[i]
else :
self.join(edges[i][0], edges[i][1])
return []
```
## Go
```go
// 全局变量
var (
n = 1005 // 节点数量3 到 1000
father = make([]int, 1005)
)
// 并查集初始化
func initialize() {
for i := 0; i < n; i++ {
father[i] = i
}
}
// 并查集里寻根的过程
func find(u int) int {
if u == father[u] {
return u
}
father[u] = find(father[u])
return father[u]
}
// 将v->u 这条边加入并查集
func join(u, v int) {
u = find(u)
v = find(v)
if u == v {
return
}
father[v] = u
}
// 判断 u 和 v是否找到同一个根，本题用不上
func same(u, v int) bool {
u = find(u)
v = find(v)
return u == v
}
func findRedundantConnection(edges [][]int) []int {
initialize()
for i := 0; i < len(edges); i++ {
if same(edges[i][0], edges[i][1]) {
return edges[i]
} else {
join(edges[i][0], edges[i][1])
}
}
return []int{}
}
```
## JavaScript

307
problems/0685.冗余连接II.md
View File

@ -39,7 +39,7 @@
**这说明题目中的图原本是是一棵树，只不过在不增加节点的情况下多加了一条边！**
还有**若有多个答案，返回最后出现在给定二维数组的答案。**这说明在两天边都可以删除的情况下，要删顺序靠后的！
还有**若有多个答案，返回最后出现在给定二维数组的答案。**这说明在两条边都可以删除的情况下，要删顺序靠后的！
那么有如下三种情况，前两种情况是出现入度为2的点，如图：
@ -58,7 +58,7 @@
首先先计算节点的入度，代码如下：
```CPP
```cpp
int inDegree[N] = {0}; // 记录节点入度
n = edges.size(); // 边的数量
for (int i = 0; i < n; i++) {
@ -70,7 +70,7 @@ for (int i = 0; i < n; i++) {
代码如下：
```CPP
```cpp
vector<int> vec; // 记录入度为2的边（如果有的话就两条边）
// 找入度为2的节点所对应的边，注意要倒叙，因为优先返回最后出现在二维数组中的答案
for (int i = n - 1; i >= 0; i--) {
@ -112,7 +112,7 @@ vector<int> getRemoveEdge(const vector<vector<int>>& edges)
本题C++代码如下：（详细注释了）
```CPP
```cpp
class Solution {
private:
static const int N = 1010; // 如题：二维数组大小的在3到1000范围内
@ -174,7 +174,7 @@ public:
inDegree[edges[i][1]]++; // 统计入度
}
vector<int> vec; // 记录入度为2的边（如果有的话就两条边）
// 找入度为2的节点所对应的边，注意要倒叙，因为优先返回最后出现在二维数组中的答案
// 找入度为2的节点所对应的边，注意要倒序，因为优先返回最后出现在二维数组中的答案
for (int i = n - 1; i >= 0; i--) {
if (inDegree[edges[i][1]] == 2) {
vec.push_back(i);
@ -203,16 +203,313 @@ public:
## Java
```java
class Solution {
private static final int N = 1010; // 如题：二维数组大小的在3到1000范围内
private int[] father;
public Solution() {
father = new int[N];
// 并查集初始化
for (int i = 0; i < N; ++i) {
father[i] = i;
}
}
// 并查集里寻根的过程
private int find(int u) {
if(u == father[u]) {
return u;
}
father[u] = find(father[u]);
return father[u];
}
// 将v->u 这条边加入并查集
private void join(int u, int v) {
u = find(u);
v = find(v);
if (u == v) return ;
father[v] = u;
}
// 判断 u 和 v是否找到同一个根，本题用不上
private Boolean same(int u, int v) {
u = find(u);
v = find(v);
return u == v;
}
/**
* 初始化并查集
*/
private void initFather() {
// 并查集初始化
for (int i = 0; i < N; ++i) {
father[i] = i;
}
}
/**
* 在有向图里找到删除的那条边，使其变成树
* @param edges
* @return 要删除的边
*/
private int[] getRemoveEdge(int[][] edges) {
initFather();
for(int i = 0; i < edges.length; i++) {
if(same(edges[i][0], edges[i][1])) { // 构成有向环了，就是要删除的边
return edges[i];
}
join(edges[i][0], edges[i][1]);
}
return null;
}
/**
* 删一条边之后判断是不是树
* @param edges
* @param deleteEdge 要删除的边
* @return true: 是树， false： 不是树
*/
private Boolean isTreeAfterRemoveEdge(int[][] edges, int deleteEdge)
{
initFather();
for(int i = 0; i < edges.length; i++)
{
if(i == deleteEdge) continue;
if(same(edges[i][0], edges[i][1])) { // 构成有向环了，一定不是树
return false;
}
join(edges[i][0], edges[i][1]);
}
return true;
}
public int[] findRedundantDirectedConnection(int[][] edges) {
int[] inDegree = new int[N];
for(int i = 0; i < edges.length; i++)
{
// 入度
inDegree[ edges[i][1] ] += 1;
}
// 找入度为2的节点所对应的边，注意要倒序，因为优先返回最后出现在二维数组中的答案
ArrayList<Integer> twoDegree = new ArrayList<Integer>();
for(int i = edges.length - 1; i >= 0; i--)
{
if(inDegree[edges[i][1]] == 2) {
twoDegree.add(i);
}
}
// 处理图中情况1 和 情况2
// 如果有入度为2的节点，那么一定是两条边里删一个，看删哪个可以构成树
if(!twoDegree.isEmpty())
{
if(isTreeAfterRemoveEdge(edges, twoDegree.get(0))) {
return edges[ twoDegree.get(0)];
}
return edges[ twoDegree.get(1)];
}
// 明确没有入度为2的情况，那么一定有有向环，找到构成环的边返回就可以了
return getRemoveEdge(edges);
}
}
```
## Python
```python
class Solution:
def __init__(self):
self.n = 1010
self.father = [i for i in range(self.n)]
def find(self, u: int):
"""
并查集里寻根的过程
"""
if u == self.father[u]:
return u
self.father[u] = self.find(self.father[u])
return self.father[u]
def join(self, u: int, v: int):
"""
将v->u 这条边加入并查集
"""
u = self.find(u)
v = self.find(v)
if u == v : return
self.father[v] = u
pass
def same(self, u: int, v: int ):
"""
判断 u 和 v是否找到同一个根，本题用不上
"""
u = self.find(u)
v = self.find(v)
return u == v
def init_father(self):
self.father = [i for i in range(self.n)]
pass
def getRemoveEdge(self, edges: List[List[int]]) -> List[int]:
"""
在有向图里找到删除的那条边，使其变成树
"""
self.init_father()
for i in range(len(edges)):
if self.same(edges[i][0], edges[i][1]): # 构成有向环了，就是要删除的边
return edges[i]
self.join(edges[i][0], edges[i][1]);
return []
def isTreeAfterRemoveEdge(self, edges: List[List[int]], deleteEdge: int) -> bool:
"""
删一条边之后判断是不是树
"""
self.init_father()
for i in range(len(edges)):
if i == deleteEdge: continue
if self.same(edges[i][0], edges[i][1]): # 构成有向环了，一定不是树
return False
self.join(edges[i][0], edges[i][1]);
return True
def findRedundantDirectedConnection(self, edges: List[List[int]]) -> List[int]:
inDegree = [0 for i in range(self.n)]
for i in range(len(edges)):
inDegree[ edges[i][1] ] += 1
# 找入度为2的节点所对应的边，注意要倒序，因为优先返回最后出现在二维数组中的答案
towDegree = []
for i in range(len(edges))[::-1]:
if inDegree[edges[i][1]] == 2 :
towDegree.append(i)
# 处理图中情况1 和 情况2
# 如果有入度为2的节点，那么一定是两条边里删一个，看删哪个可以构成树
if len(towDegree) > 0:
if(self.isTreeAfterRemoveEdge(edges, towDegree[0])) :
return edges[towDegree[0]]
return edges[towDegree[1]]
# 明确没有入度为2的情况，那么一定有有向环，找到构成环的边返回就可以了
return self.getRemoveEdge(edges)
```
## Go
```go
// 全局变量
var (
n = 1010// 节点数量3 到 1000
father = make([]int, n)
)
// 并查集初始化
func initialize() {
for i := 0; i < n; i++ {
father[i] = i
}
}
// 并查集里寻根的过程
func find(u int) int {
if u == father[u] {
return u
}
father[u] = find(father[u])
return father[u]
}
// 将v->u 这条边加入并查集
func join(u, v int) {
u = find(u)
v = find(v)
if u == v {
return
}
father[v] = u
}
// 判断 u 和 v是否找到同一个根，本题用不上
func same(u, v int) bool {
u = find(u)
v = find(v)
return u == v
}
// getRemoveEdge 在有向图里找到删除的那条边，使其变成树
func getRemoveEdge(edges [][]int) []int {
initialize()
for i := 0; i < len(edges); i++ { // 遍历所有的边
if same(edges[i][0], edges[i][1]) { // 构成有向环了，就是要删除的边
return edges[i]
}
join(edges[i][0], edges[i][1])
}
return []int{}
}
// isTreeAfterRemoveEdge 删一条边之后判断是不是树
func isTreeAfterRemoveEdge(edges [][]int, deleteEdge int) bool {
initialize()
for i := 0; i < len(edges); i++ {
if i == deleteEdge {
continue
}
if same(edges[i][0], edges[i][1]) { // 构成有向环了，一定不是树
return false
}
join(edges[i][0], edges[i][1])
}
return true
}
func findRedundantDirectedConnection(edges [][]int) []int {
inDegree := make([]int, len(father))
for i := 0; i < len(edges); i++ {
// 统计入度
inDegree[edges[i][1]] += 1
}
// 记录入度为2的边（如果有的话就两条边）
// 找入度为2的节点所对应的边，注意要倒序，因为优先返回最后出现在二维数组中的答案
twoDegree := make([]int, 0)
for i := len(edges) - 1; i >= 0; i-- {
if inDegree[edges[i][1]] == 2 {
twoDegree = append(twoDegree, i)
}
}
// 处理图中情况1 和 情况2
// 如果有入度为2的节点，那么一定是两条边里删一个，看删哪个可以构成树
if len(twoDegree) > 0 {
if isTreeAfterRemoveEdge(edges, twoDegree[0]) {
return edges[twoDegree[0]]
}
return edges[twoDegree[1]]
}
// 处理图中情况3
// 明确没有入度为2的情况，那么一定有有向环，找到构成环的边返回就可以了
return getRemoveEdge(edges)
}
```
## JavaScript

26
problems/0724.寻找数组的中心索引.md
View File

@ -9,6 +9,8 @@
# 724.寻找数组的中心下标
[力扣题目链接](https://leetcode-cn.com/problems/find-pivot-index/)
给你一个整数数组 nums ，请计算数组的 中心下标 。
数组 中心下标 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。
@ -87,15 +89,15 @@ class Solution {
}
```
## Python
## Python3
```python3
```python
class Solution:
def pivotIndex(self, nums: List[int]) -> int:
numSum = sum(nums) #数组总和
leftSum = 0
for i in range(len(nums)):
if numSum - leftSum -nums[i] == leftSum: #左右和相等
if numSum - leftSum -nums[i] == leftSum: #左右和相等
return i
leftSum += nums[i]
return -1
@ -104,6 +106,24 @@ class Solution:
## Go
```go
func pivotIndex(nums []int) int {
sum := 0
for _, v := range nums {
sum += v;
}
leftSum := 0 // 中心索引左半和
rightSum := 0 // 中心索引右半和
for i := 0; i < len(nums); i++ {
leftSum += nums[i]
rightSum = sum - leftSum + nums[i]
if leftSum == rightSum{
return i
}
}
return -1
}
```
## JavaScript