Add solution 690

Author: halfrost

README.md

@@ -0,0 +1,26 @@
+package leetcode
+
+type Employee struct {
+	Id           int
+	Importance   int
+	Subordinates []int
+}
+
+func getImportance(employees []*Employee, id int) int {
+	m, queue, res := map[int]*Employee{}, []int{id}, 0
+	for _, e := range employees {
+		m[e.Id] = e
+	}
+	for len(queue) > 0 {
+		e := m[queue[0]]
+		queue = queue[1:]
+		if e == nil {
+			continue
+		}
+		res += e.Importance
+		for _, i := range e.Subordinates {
+			queue = append(queue, i)
+		}
+	}
+	return res
+}

leetcode/0690.Employee-Importance/690. Employee Importance.go

@@ -0,0 +1,43 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question690 struct {
+	para690
+	ans690
+}
+
+// para 是参数
+// one 代表第一个参数
+type para690 struct {
+	employees []*Employee
+	id        int
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans690 struct {
+	one int
+}
+
+func Test_Problem690(t *testing.T) {
+
+	qs := []question690{
+
+		{
+			para690{[]*Employee{{1, 5, []int{2, 3}}, {2, 3, []int{}}, {3, 3, []int{}}}, 1},
+			ans690{11},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 690------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans690, q.para690
+		fmt.Printf("【input】:%v       【output】:%v\n", p, getImportance(p.employees, p.id))
+	}
+	fmt.Printf("\n\n\n")
+}

leetcode/0690.Employee-Importance/690. Employee Importance_test.go

@@ -0,0 +1,62 @@
+# [690. Employee Importance](https://leetcode.com/problems/employee-importance/)
+
+## 题目
+
+You are given a data structure of employee information, which includes the employee's **unique id**, their **importance value** and their **direct** subordinates' id.
+
+For example, employee 1 is the leader of employee 2, and employee 2 is the leader of employee 3. They have importance value 15, 10 and 5, respectively. Then employee 1 has a data structure like [1, 15, [2]], and employee 2 has [2, 10, [3]], and employee 3 has [3, 5, []]. Note that although employee 3 is also a subordinate of employee 1, the relationship is **not direct**.
+
+Now given the employee information of a company, and an employee id, you need to return the total importance value of this employee and all their subordinates.
+
+**Example 1:**
+
+```
+Input: [[1, 5, [2, 3]], [2, 3, []], [3, 3, []]], 1
+Output: 11
+Explanation:
+Employee 1 has importance value 5, and he has two direct subordinates: employee 2 and employee 3. They both have importance value 3. So the total importance value of employee 1 is 5 + 3 + 3 = 11.
+```
+
+**Note:**
+
+1. One employee has at most one **direct** leader and may have several subordinates.
+2. The maximum number of employees won't exceed 2000.
+
+## 题目大意
+
+给定一个保存员工信息的数据结构，它包含了员工 唯一的 id ，重要度 和 直系下属的 id 。比如，员工 1 是员工 2 的领导，员工 2 是员工 3 的领导。他们相应的重要度为 15 , 10 , 5 。那么员工 1 的数据结构是 [1, 15, [2]] ，员工 2的 数据结构是 [2, 10, [3]] ，员工 3 的数据结构是 [3, 5, []] 。注意虽然员工 3 也是员工 1 的一个下属，但是由于 并不是直系 下属，因此没有体现在员工 1 的数据结构中。现在输入一个公司的所有员工信息，以及单个员工 id ，返回这个员工和他所有下属的重要度之和。
+
+## 解题思路
+
+- 简单题。根据题意，DFS 或者 BFS 搜索找到所求 id 下属所有员工，累加下属员工的重要度，最后再加上这个员工本身的重要度，即为所求。
+
+## 代码
+
+```go
+package leetcode
+
+type Employee struct {
+	Id           int
+	Importance   int
+	Subordinates []int
+}
+
+func getImportance(employees []*Employee, id int) int {
+	m, queue, res := map[int]*Employee{}, []int{id}, 0
+	for _, e := range employees {
+		m[e.Id] = e
+	}
+	for len(queue) > 0 {
+		e := m[queue[0]]
+		queue = queue[1:]
+		if e == nil {
+			continue
+		}
+		res += e.Importance
+		for _, i := range e.Subordinates {
+			queue = append(queue, i)
+		}
+	}
+	return res
+}
+```

leetcode/0690.Employee-Importance/README.md

@@ -113,5 +113,5 @@ func findRoot(parent *[]int, k int) int {
 ----------------------------------------------
 <div style="display: flex;justify-content: space-between;align-items: center;">
 <p><a href="https://books.halfrost.com/leetcode/ChapterFour/0600~0699/0684.Redundant-Connection/">⬅️上一页</a></p>
-<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0600~0699/0693.Binary-Number-with-Alternating-Bits/">下一页➡️</a></p>
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0600~0699/0690.Employee-Importance/">下一页➡️</a></p>
 </div>

website/content/ChapterFour/0600~0699/0685.Redundant-Connection-II.md

@@ -0,0 +1,69 @@
+# [690. Employee Importance](https://leetcode.com/problems/employee-importance/)
+
+## 题目
+
+You are given a data structure of employee information, which includes the employee's **unique id**, their **importance value** and their **direct** subordinates' id.
+
+For example, employee 1 is the leader of employee 2, and employee 2 is the leader of employee 3. They have importance value 15, 10 and 5, respectively. Then employee 1 has a data structure like [1, 15, [2]], and employee 2 has [2, 10, [3]], and employee 3 has [3, 5, []]. Note that although employee 3 is also a subordinate of employee 1, the relationship is **not direct**.
+
+Now given the employee information of a company, and an employee id, you need to return the total importance value of this employee and all their subordinates.
+
+**Example 1:**
+
+```
+Input: [[1, 5, [2, 3]], [2, 3, []], [3, 3, []]], 1
+Output: 11
+Explanation:
+Employee 1 has importance value 5, and he has two direct subordinates: employee 2 and employee 3. They both have importance value 3. So the total importance value of employee 1 is 5 + 3 + 3 = 11.
+```
+
+**Note:**
+
+1. One employee has at most one **direct** leader and may have several subordinates.
+2. The maximum number of employees won't exceed 2000.
+
+## 题目大意
+
+给定一个保存员工信息的数据结构，它包含了员工 唯一的 id ，重要度 和 直系下属的 id 。比如，员工 1 是员工 2 的领导，员工 2 是员工 3 的领导。他们相应的重要度为 15 , 10 , 5 。那么员工 1 的数据结构是 [1, 15, [2]] ，员工 2的 数据结构是 [2, 10, [3]] ，员工 3 的数据结构是 [3, 5, []] 。注意虽然员工 3 也是员工 1 的一个下属，但是由于 并不是直系 下属，因此没有体现在员工 1 的数据结构中。现在输入一个公司的所有员工信息，以及单个员工 id ，返回这个员工和他所有下属的重要度之和。
+
+## 解题思路
+
+- 简单题。根据题意，DFS 或者 BFS 搜索找到所求 id 下属所有员工，累加下属员工的重要度，最后再加上这个员工本身的重要度，即为所求。
+
+## 代码
+
+```go
+package leetcode
+
+type Employee struct {
+	Id           int
+	Importance   int
+	Subordinates []int
+}
+
+func getImportance(employees []*Employee, id int) int {
+	m, queue, res := map[int]*Employee{}, []int{id}, 0
+	for _, e := range employees {
+		m[e.Id] = e
+	}
+	for len(queue) > 0 {
+		e := m[queue[0]]
+		queue = queue[1:]
+		if e == nil {
+			continue
+		}
+		res += e.Importance
+		for _, i := range e.Subordinates {
+			queue = append(queue, i)
+		}
+	}
+	return res
+}
+```
+
+
+----------------------------------------------
+<div style="display: flex;justify-content: space-between;align-items: center;">
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0600~0699/0685.Redundant-Connection-II/">⬅️上一页</a></p>
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0600~0699/0693.Binary-Number-with-Alternating-Bits/">下一页➡️</a></p>
+</div>

website/content/ChapterFour/0600~0699/0690.Employee-Importance.md

@@ -82,6 +82,6 @@ func hasAlternatingBits1(n int) bool {
 
 ----------------------------------------------
 <div style="display: flex;justify-content: space-between;align-items: center;">
-<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0600~0699/0685.Redundant-Connection-II/">⬅️上一页</a></p>
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0600~0699/0690.Employee-Importance/">⬅️上一页</a></p>
 <p><a href="https://books.halfrost.com/leetcode/ChapterFour/0600~0699/0695.Max-Area-of-Island/">下一页➡️</a></p>
 </div>