Merge branch 'master' of github.com:zjming/LeetCodeAnimation

these are solved leetcode problem!

notes/LeetCode第877号问题：石子游戏.md

+# LeetCode 第 877 号问题：石子游戏
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+### 题目描述
+
+喜羊羊和灰太狼用几堆石子在做游戏。偶数堆石子**排成一行**，每堆都有正整数颗石子 `piles[i]` 。
+
+游戏以谁手中的石子最多来决出胜负。石子的总数是奇数，所以没有平局。
+
+喜羊羊和灰太狼轮流进行，喜羊羊先开始。 每回合，玩家从行的开始或结束处取走整堆石头。 这种情况一直持续到没有更多的石子堆为止，此时手中石子最多的玩家获胜。
+
+假设喜羊羊和灰太狼都发挥出最佳水平，当喜羊羊赢得比赛时返回 `true` ，当灰太狼赢得比赛时返回 `false` 。
+
+### 题目分析
+
+举两个例子来帮助理解题意。
+
+#### 例子一：
+
+输入：[ 5，3，4，5 ]
+
+输出：true
+
+**解释**：
+
+喜羊羊先开始，只能拿前 5 颗或后 5 颗石子 。
+
+假设他取了前 5 颗，这一行就变成了 [ 3 ，4，5 ] 。
+
+如果灰太狼拿走前 3 颗，那么剩下的是 [ 4，5 ]，喜羊羊拿走后 5 颗赢得 10 分。
+
+如果灰太狼拿走后 5 颗，那么剩下的是 [ 3，4 ]，喜羊羊拿走后 4 颗赢得 9 分。
+
+这表明，取前 5 颗石子对喜羊羊来说是一个胜利的举动，所以我们返回 true 。
+
+
+
+
+
+#### 例子二：
+
+输入：[ 5，10000，2，3 ]
+
+输出：true
+
+**解释**：
+
+喜羊羊先开始，只能拿前 5 颗或后 3 颗石子 。
+
+假设他取了后 3 颗，这一行就变成了 [ 5，10000，2 ]。
+
+灰太狼肯定会在剩下的这一行中取走前 5 颗，这一行就变成了 [ 10000，2 ]。
+
+然后喜羊羊取走前 10000 颗，总共赢得 10003 分，灰太狼赢得 7 分。
+
+这表明，取后 3 颗石子对喜羊羊来说是一个胜利的举动，所以我们返回 true 。
+
+**这个例子表明，并不是需要每次都挑选最大的那堆石头**。
+
+
+
+### 题目回答
+
+涉及到最优解的问题，那么肯定要去尝试一下使用 **动态规划 **来解决了。
+
+先看一下力扣的正规题解：
+
+让我们改变游戏规则，使得每当灰太狼得分时，都会从喜羊羊的分数中扣除。
+
+令 `dp(i, j)` 为喜羊羊可以获得的最大分数，其中剩下的堆中的石子数是 `piles[i], piles[i+1], ..., piles[j]`。这在比分游戏中很自然：我们想知道游戏中每个位置的值。
+
+我们可以根据 `dp(i + 1，j)` 和 `dp(i，j-1)` 来制定 `dp(i，j)` 的递归，我们可以使用动态编程以不重复这个递归中的工作。（该方法可以输出正确的答案，因为状态形成一个DAG（有向无环图）。）
+
+当剩下的堆的石子数是 `piles[i], piles[i+1], ..., piles[j]` 时，轮到的玩家最多有 2 种行为。
+
+可以通过比较 `j-i`和 `N modulo 2` 来找出轮到的人。
+
+如果玩家是喜羊羊，那么它将取走 `piles[i]` 或 `piles[j]` 颗石子，增加它的分数。之后，总分为 `piles[i] + dp(i+1, j)` 或 `piles[j] + dp(i, j-1)`；我们想要其中的最大可能得分。
+
+如果玩家是灰太狼，那么它将取走 `piles[i]` 或 `piles[j]` 颗石子，减少喜羊羊这一数量的分数。之后，总分为 `-piles[i] + dp(i+1, j)` 或 `-piles[j] + dp(i, j-1)`；我们想要其中的最小可能得分。
+
+代码如下：
+
+![](https://blog-1257126549.cos.ap-guangzhou.myqcloud.com/blog/af7fm.jpg)
+
+
+
+上面的代码并不算复杂，当然，如果你看不懂也没关系，不影响解决问题，请看下面的数学分析。
+
+
+
+### 数学分析
+
+因为石头的数量是奇数，因此只有两种结果，输或者赢。
+
+喜羊羊先开始拿石头，随便拿！然后比较石头数量：
+
+1. 如果石头数量多于对手，赢了；
+2. 如果石头数量少于对手，自己拿石头的顺序和对手拿石头的顺序对调（**因为是偶数堆石头，所以可以全部对调**），还是赢。
+
+所以代码如下：
+
+```java
+class Solution {
+    public boolean stoneGame(int[] piles) {
+        return true;
+    }
+}
+```
+
+下面给给大家介绍一种简单的策略作为参考，使用这种策略可以保证先取石头的喜羊羊一定能够获胜。
+
+首先分别计算出序号为奇数和序号为偶数的石头堆中的石头总数，然后进行比较，如果奇数堆石头总数更多则喜羊羊永远保证自己选取奇数石堆，反之则选择偶数。
+
+举例来说，假设石堆为 [ 5，10000，2，3 ] ，那么奇数石堆总和为 7（从 1 开始编号），偶数石堆总数为 1003 ，则喜羊羊要保证自己永远选择偶数堆即第四堆和第二堆，就可以取胜。
+
+但是这种选择方法得到的**结果未必是最优解**，例如石堆为 [ 2，1，3，5 ] 当使用动态规划确保喜羊羊和灰太狼都选择最优解的时候，喜羊羊会拿走 [ 2，5 ] 两堆棋子，而灰太狼则拿走 [ 1，3 ] 两堆。但是使用这种策略在即使不是最优解的情况下依然可以保证喜羊羊胜利，所以作为先手的喜羊羊必定有方法取得比赛的胜利。
+
+看完之后，你的心情是怎么样的？
+
+此题的LeetCode 的评论区里一片吐槽：**这是什么沙雕题目！**
+
+可能搞过 ACM 等竞赛的人都会微微一笑：不会几万个套路怎么好意思说自己是 acmer 。我们这些普通人为之惊奇的题目，到他们这里就是彻底被玩坏了，各种稀奇古怪的秒解。
+
+
+
+
+
+
+
+![](https://blog-1257126549.cos.ap-guangzhou.myqcloud.com/blog/lnwx8.png)

notes/LeetCode第92号问题：反转链表II.md

+# LeetCode 第 92 号问题：反转链表 II
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 上第 92 号问题：反转链表 II。题目难度为 Medium，目前通过率为 43.8% 。
+
+### 题目描述
+
+反转从位置 *m* 到 *n* 的链表。请使用一趟扫描完成反转。
+
+**说明:**
+1 ≤ *m* ≤ *n* ≤ 链表长度。
+
+**示例:**
+
+```
+输入: 1->2->3->4->5->NULL, m = 2, n = 4
+输出: 1->4->3->2->5->NULL
+```
+
+### 题目解析
+
+**[Reverse Linked List](https://xiaozhuanlan.com/topic/7513064892)**的延伸题。
+
+可以考虑取出需要反转的这一小段链表，反转完后再插入到原先的链表中。
+
+**以本题为例：**
+
+变换的是 2，3，4这三个点，那么我们可以先取出 2 ，用 front 指针指向 2 ，然后当取出 3 的时候，我们把 3 加到 2 的前面，把 front 指针前移到 3 ，依次类推，到 4 后停止，这样我们得到一个新链表 4 -> 3 -> 2 ,  front 指针指向4。
+
+对于原链表来说，**有两个点的位置很重要**，需要用指针记录下来，分别是 1 和 5 ，把新链表插入的时候需要这两个点的位置。
+
+- 用 pre 指针记录 1 的位置
+- 当 4 结点被取走后，5 的位置需要记下来
+- 这样我们就可以把倒置后的那一小段链表加入到原链表中
+
+
+
+### 动画描述
+
+![](https://blog-1257126549.cos.ap-guangzhou.myqcloud.com/blog/rjjr0.gif)
+
+### 代码实现
+
+```
+class Solution {
+public:
+    ListNode *reverseBetween(ListNode *head, int m, int n) {
+        ListNode *dummy = new ListNode(-1);
+        dummy->next = head;
+        ListNode *cur = dummy;
+        ListNode *pre, *front, *last;
+        for (int i = 1; i <= m - 1; ++i) cur = cur->next;
+        pre = cur;
+        last = cur->next;
+        for (int i = m; i <= n; ++i) {
+            cur = pre->next;
+            pre->next = cur->next;
+            cur->next = front;
+            front = cur;
+        }
+        cur = pre->next;
+        pre->next = front;
+        last->next = cur;
+        return dummy->next;
+    }
+};
+```
+
+
+
+
+
+![](https://blog-1257126549.cos.ap-guangzhou.myqcloud.com/blog/l2f8n.png)
\ No newline at end of file

notes/LeetCode第94号问题：二叉树的中序遍历.md

+# LeetCode 第 94 号问题：二叉树的中序遍历
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 上第 94 号问题：二叉树的中序遍历。题目难度为 Medium，目前通过率为 35.8% 。
+
+### 题目描述
+
+给定一个二叉树，返回它的*中序* 遍历。
+
+**示例:**
+
+```
+输入: [1,null,2,3]
+   1
+    \
+     2
+    /
+   3
+
+输出: [1,3,2]
+```
+
+**进阶:** 递归算法很简单，你可以通过迭代算法完成吗？
+
+### 题目解析
+
+用**栈(Stack)**的思路来处理问题。
+
+中序遍历的顺序为**左-根-右**，具体算法为：
+
+- 从根节点开始，先将根节点压入栈
+- 然后再将其所有左子结点压入栈，取出栈顶节点，保存节点值
+- 再将当前指针移到其右子节点上，若存在右子节点，则在下次循环时又可将其所有左子结点压入栈中
+
+
+
+### 动画描述
+
+![](https://blog-1257126549.cos.ap-guangzhou.myqcloud.com/blog/v17b8.gif)
+
+### 代码实现
+
+```
+class Solution {
+        public List<Integer> inorderTraversal(TreeNode root) {
+            List<Integer> list = new ArrayList<>();
+            Stack<TreeNode> stack = new Stack<>();
+            TreeNode cur = root;
+            while (cur != null || !stack.isEmpty()) {
+                if (cur != null) {
+                    stack.push(cur);
+                    cur = cur.left;
+                } else {
+                    cur = stack.pop();
+                    list.add(cur.val);
+                    cur = cur.right;
+                }
+            }
+            return list;
+        }
+}
+```
+
+
+
+![](https://blog-1257126549.cos.ap-guangzhou.myqcloud.com/blog/4beoi.png)
\ No newline at end of file

notes/LeetCode第9号问题：回文数.md

+# LeetCode 第 9 号问题：回文数
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+
+
+题目来源于 LeetCode 第 9 号问题：回文数。题目难度为 Easy，目前通过率为 56.0%。
+
+## 题目描述
+
+判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
+
+**示例 1:**
+
+```
+输入: 121
+输出: true
+```
+
+**示例 2:**
+
+```
+输入: -121
+输出: false
+解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
+```
+
+**示例 3:**
+
+```
+输入: 10
+输出: false
+解释: 从右向左读, 为 01 。因此它不是一个回文数。
+```
+
+**进阶:**
+
+你能不将整数转为字符串来解决这个问题吗？
+
+
+
+## 题目解析
+
+### 解法一：普通解法
+
+最好理解的一种解法就是先将 **整数转为字符串** ，然后将字符串分割为数组，只需要循环数组的一半长度进行判断对应元素是否相等即可。
+
+#### 动画描述
+
+![](https://blog-1257126549.cos.ap-guangzhou.myqcloud.com/blog/ods8b.gif)
+
+#### 代码实现
+
+```java
+///简单粗暴，看看就行
+class Solution {
+    public boolean isPalindrome(int x) {
+        String reversedStr = (new StringBuilder(x + "")).reverse().toString();
+        return (x + "").equals(reversedStr);
+    }
+}
+```
+
+
+
+### 解法二：进阶解法---数学解法
+
+通过取整和取余操作获取整数中对应的数字进行比较。
+
+举个例子：1221 这个数字。
+
+- 通过计算 1221 / 1000， 得首位1
+- 通过计算 1221 % 10， 可得末位 1
+- 进行比较
+- 再将 22 取出来继续比较
+
+#### 动画描述
+
+![](https://blog-1257126549.cos.ap-guangzhou.myqcloud.com/blog/v3tkl.gif)
+
+#### 代码实现
+
+```java
+class Solution {
+    public boolean isPalindrome(int x) {
+        //边界判断
+        if (x < 0) return false;
+        int div = 1;
+        //
+        while (x / div >= 10) div *= 10;
+        while (x > 0) {
+            int left = x / div;
+            int right = x % 10;
+            if (left != right) return false;
+            x = (x % div) / 10;
+            div /= 100;
+        }
+        return true;
+    }
+}
+```
+
+
+
+### 解法三：进阶解法---巧妙解法
+
+直观上来看待回文数的话，就感觉像是将数字进行对折后看能否一一对应。
+
+所以这个解法的操作就是 **取出后半段数字进行翻转**。
+
+这里需要注意的一个点就是由于回文数的位数可奇可偶，所以当它的长度是偶数时，它对折过来应该是相等的；当它的长度是奇数时，那么它对折过来后，有一个的长度需要去掉一位数（除以 10 并取整）。
+
+具体做法如下：
+
+- 每次进行取余操作 （ %10），取出最低的数字：`y = x % 10`
+- 将最低的数字加到取出数的末尾：`revertNum = revertNum * 10 + y`
+- 每取一个最低位数字，x 都要自除以 10
+- 判断 `x` 是不是小于 `revertNum` ，当它小于的时候，说明数字已经对半或者过半了
+- 最后，判断奇偶数情况：如果是偶数的话，revertNum 和 x 相等；如果是奇数的话，最中间的数字就在revertNum 的最低位上，将它除以 10 以后应该和 x 相等。
+
+#### 动画描述
+
+![](https://blog-1257126549.cos.ap-guangzhou.myqcloud.com/blog/0siv7.png)
+
+#### 代码实现
+
+```java
+class Solution {
+    public boolean isPalindrome(int x) {
+        //思考：这里大家可以思考一下，为什么末尾为 0 就可以直接返回 false
+        if (x < 0 || (x % 10 == 0 && x != 0)) return false;
+        int revertedNumber = 0;
+        while (x > revertedNumber) {
+            revertedNumber = revertedNumber * 10 + x % 10;
+            x /= 10;
+        }
+        return x == revertedNumber || x == revertedNumber / 10;
+    }
+}
+```
+
+
+
+![](https://blog-1257126549.cos.ap-guangzhou.myqcloud.com/blog/kcet5.png)
\ No newline at end of file