Merge pull request #932 from 0xff-dev/2751

Add solution and test-cases for problem 2751

Author: 6boris

leetcode/2701-2800/2751.Robot-Collisions/1.png

@@ -0,0 +1,53 @@
+# [2751. Robot Collisions][title]
+
+## Description
+There are `n` **1-indexed** robots, each having a position on a line, health, and movement direction.
+
+You are given **0-indexed** integer arrays `positions`, `healths`, and a string `directions` (`directions[i]` is either **'L'** for **left** or **'R'** for **right**). All integers in `positions` are **unique**.
+
+All robots start moving on the line **simultaneously** at the **same speed** in their given directions. If two robots ever share the same position while moving, they will **collide**.
+
+If two robots collide, the robot with **lower health** is **removed** from the line, and the health of the other robot **decreases by one**. The surviving robot continues in the **same** direction it was going. If both robots have the **same** health, they are both removed from the line.
+
+Your task is to determine the **health** of the robots that survive the collisions, in the same **order** that the robots were given, i.e. final heath of robot 1 (if survived), final health of robot 2 (if survived), and so on. If there are no survivors, return an empty array.
+
+Return an array containing the health of the remaining robots (in the order they were given in the input), after no further collisions can occur.
+
+**Note**: The positions may be unsorted.
+
+**Example 1:**  
+
+![1](./1.png)
+
+```
+Input: positions = [5,4,3,2,1], healths = [2,17,9,15,10], directions = "RRRRR"
+Output: [2,17,9,15,10]
+Explanation: No collision occurs in this example, since all robots are moving in the same direction. So, the health of the robots in order from the first robot is returned, [2, 17, 9, 15, 10].
+```
+
+**Example 2:**  
+
+![2](./2.png)
+
+```
+Input: positions = [3,5,2,6], healths = [10,10,15,12], directions = "RLRL"
+Output: [14]
+Explanation: There are 2 collisions in this example. Firstly, robot 1 and robot 2 will collide, and since both have the same health, they will be removed from the line. Next, robot 3 and robot 4 will collide and since robot 4's health is smaller, it gets removed, and robot 3's health becomes 15 - 1 = 14. Only robot 3 remains, so we return [14].
+```
+
+**Example 3:**  
+
+![3](./3.png)
+
+```
+Input: positions = [1,2,5,6], healths = [10,10,11,11], directions = "RLRL"
+Output: []
+Explanation: Robot 1 and robot 2 will collide and since both have the same health, they are both removed. Robot 3 and 4 will collide and since both have the same health, they are both removed. So, we return an empty array, [].
+```
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/robot-collisions
+[me]: https://github.com/kylesliu/awesome-golang-algorithm

leetcode/2701-2800/2751.Robot-Collisions/2.png

@@ -1,5 +1,73 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+import "sort"
+
+type tmp2751 struct {
+	i    []int
+	p, h []int
+	d    []byte
+}
+
+func (t tmp2751) Len() int {
+	return len(t.p)
+}
+
+func (t tmp2751) Swap(i, j int) {
+	t.p[i], t.p[j] = t.p[j], t.p[i]
+	t.h[i], t.h[j] = t.h[j], t.h[i]
+	t.d[i], t.d[j] = t.d[j], t.d[i]
+	t.i[i], t.i[j] = t.i[j], t.i[i]
+}
+
+func (t tmp2751) Less(i, j int) bool {
+	return t.p[i] < t.p[j]
+}
+
+func Solution(positions []int, healths []int, directions string) []int {
+	ans := make([]int, 0)
+	l := len(positions)
+	indies := make([]int, l)
+	for i := 0; i < l; i++ {
+		indies[i] = i
+	}
+	s := tmp2751{p: positions, h: healths, d: []byte(directions), i: indies}
+	sort.Sort(s)
+
+	stack := make([]int, len(positions))
+	stackIndex := -1
+	for i := 0; i < l; i++ {
+		dir := s.d[i]
+		if dir == 'L' {
+			for stackIndex >= 0 && healths[stack[stackIndex]] < healths[i] {
+				healths[i]--
+				stackIndex--
+			}
+
+			if stackIndex == -1 {
+				ans = append(ans, i)
+				continue
+			}
+			if healths[stack[stackIndex]] == healths[i] {
+				stackIndex--
+				continue
+			}
+
+			healths[stack[stackIndex]]--
+
+			continue
+		}
+		stackIndex++
+		stack[stackIndex] = i
+	}
+	for i := 0; i <= stackIndex; i++ {
+		ans = append(ans, stack[i])
+	}
+	sort.Slice(ans, func(i, j int) bool {
+		return indies[ans[i]] < indies[ans[j]]
+	})
+	for i := 0; i < len(ans); i++ {
+		ans[i] = healths[ans[i]]
+	}
+
+	return ans
 }

leetcode/2701-2800/2751.Robot-Collisions/3.png

@@ -10,30 +10,31 @@ func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
 		name   string
-		inputs bool
-		expect bool
+		p, h   []int
+		d      string
+		expect []int
 	}{
-		{"TestCase", true, true},
-		{"TestCase", true, true},
-		{"TestCase", false, false},
+		{"TestCase1", []int{5, 4, 3, 2, 1}, []int{2, 17, 9, 15, 10}, "RRRRR", []int{2, 17, 9, 15, 10}},
+		{"TestCase2", []int{3, 5, 2, 6}, []int{10, 10, 15, 12}, "RLRL", []int{14}},
+		{"TestCase3", []int{1, 2, 5, 6}, []int{10, 10, 11, 11}, "RLRL", []int{}},
 	}
 
 	//	开始测试
 	for i, c := range cases {
 		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
-			got := Solution(c.inputs)
+			got := Solution(c.p, c.h, c.d)
 			if !reflect.DeepEqual(got, c.expect) {
-				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
-					c.expect, got, c.inputs)
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v %v %v",
+					c.expect, got, c.p, c.h, c.d)
 			}
 		})
 	}
 }
 
-//	压力测试
+// 压力测试
 func BenchmarkSolution(b *testing.B) {
 }
 
-//	使用案列
+// 使用案列
 func ExampleSolution() {
 }