Merge remote-tracking branch 'origin/master'

# Conflicts:
#	src/main/java/leetcode/editor/cn/doc/all.json
#	src/main/java/leetcode/editor/cn/doc/translation.json

src/main/java/leetcode/editor/cn/ContainsDuplicate.java

@@ -26,6 +26,8 @@
 
 package leetcode.editor.cn;
 
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
 
@@ -35,16 +37,26 @@ class ContainsDuplicate{
         //测试代码
         Solution solution = new ContainsDuplicate().new Solution();
     }
+
     //力扣代码
     //leetcode submit region begin(Prohibit modification and deletion)
     class Solution {
+        //    public boolean containsDuplicate(int[] nums) {
+//        Set<Integer> set = new HashSet<>();
+//        for (int num : nums) {
+//            if (set.contains(num)) {
+//                return true;
+//            }
+//            set.add(num);
+//        }
+//        return false;
+//    }
         public boolean containsDuplicate(int[] nums) {
-        Set<Integer> set = new HashSet<>();
+            Arrays.sort(nums);
-        for (int num : nums) {
+            for (int i = 1; i < nums.length; i++) {
-            if (set.contains(num)) {
+                if(nums[i]==nums[i-1]){
                     return true;
                 }
-            set.add(num);
             }
             return false;
         }

src/main/java/leetcode/editor/cn/DivideTwoIntegers.java

@@ -0,0 +1,87 @@
+//给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。 
+//
+// 返回被除数 dividend 除以除数 divisor 得到的商。 
+//
+// 整数除法的结果应当截去（truncate）其小数部分，例如：truncate(8.345) = 8 以及 truncate(-2.7335) = -2 
+//
+// 
+//
+// 示例 1: 
+//
+// 输入: dividend = 10, divisor = 3
+//输出: 3
+//解释: 10/3 = truncate(3.33333..) = truncate(3) = 3 
+//
+// 示例 2: 
+//
+// 输入: dividend = 7, divisor = -3
+//输出: -2
+//解释: 7/-3 = truncate(-2.33333..) = -2 
+//
+// 
+//
+// 提示： 
+//
+// 
+// 被除数和除数均为 32 位有符号整数。 
+// 除数不为 0。 
+// 假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−2³¹, 231 − 1]。本题中，如果除法结果溢出，则返回 231 − 1。 
+// 
+// Related Topics 位运算 数学 👍 700 👎 0
+
+package leetcode.editor.cn;
+
+//29:两数相除
+class DivideTwoIntegers {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new DivideTwoIntegers().new Solution();
+        solution.divide(-2147483648, 2);
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public int divide(int dividend, int divisor) {
+            if (divisor == 0 || dividend == 0) {
+                return 0;
+            }
+            if (divisor == 1) {
+                return dividend;
+            }
+            if (divisor == -1) {
+                return dividend == -2147483648 ? 2147483647 : -dividend;
+            }
+            if (divisor == -2147483648) {
+                return dividend == -2147483648 ? 1 : 0;
+            }
+            int count = 0;
+            int bl1 = 0;
+            int bl2 = 0;
+            int temp = dividend;
+            if (dividend == -2147483648) {
+                dividend = 2147483647;
+                bl1 = 1;
+            } else if (dividend < 0) {
+                dividend = -dividend;
+                bl1 = 1;
+            }
+            if (divisor < 0) {
+                divisor = -divisor;
+                bl2 = 1;
+            }
+            while (dividend >= divisor) {
+                count++;
+                dividend -= divisor;
+            }
+            if (temp == -2147483648) {
+                if (dividend + 1 >= divisor) {
+                    count++;
+                }
+            }
+            return (bl1 ^ bl2) == 0 ? count : -count;
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/IntegerToEnglishWords.java

@@ -0,0 +1,96 @@
+//将非负整数 num 转换为其对应的英文表示。 
+//
+// 
+//
+// 示例 1： 
+//
+// 
+//输入：num = 123
+//输出："One Hundred Twenty Three"
+// 
+//
+// 示例 2： 
+//
+// 
+//输入：num = 12345
+//输出："Twelve Thousand Three Hundred Forty Five"
+// 
+//
+// 示例 3： 
+//
+// 
+//输入：num = 1234567
+//输出："One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven"
+// 
+//
+// 示例 4： 
+//
+// 
+//输入：num = 1234567891
+//输出："One Billion Two Hundred Thirty Four Million Five Hundred Sixty Seven 
+//Thousand Eight Hundred Ninety One"
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// 0 <= num <= 2³¹ - 1 
+// 
+// Related Topics 递归 数学 字符串 👍 198 👎 0
+
+package leetcode.editor.cn;
+
+//273:整数转换英文表示
+class IntegerToEnglishWords {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new IntegerToEnglishWords().new Solution();
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        String[] singles = {"", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"};
+        String[] teens = {"Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"};
+        String[] tens = {"", "Ten", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"};
+        String[] thousands = {"", "Thousand", "Million", "Billion"};
+
+        public String numberToWords(int num) {
+            if (num == 0) {
+                return "Zero";
+            }
+            StringBuffer sb = new StringBuffer();
+            for (int i = 3, unit = 1000000000; i >= 0; i--, unit /= 1000) {
+                int curNum = num / unit;
+                if (curNum != 0) {
+                    num -= curNum * unit;
+                    StringBuffer curr = new StringBuffer();
+                    recursion(curr, curNum);
+                    curr.append(thousands[i]).append(" ");
+                    sb.append(curr);
+                }
+            }
+            return sb.toString().trim();
+        }
+
+        public void recursion(StringBuffer curr, int num) {
+            if (num == 0) {
+                return;
+            } else if (num < 10) {
+                curr.append(singles[num]).append(" ");
+            } else if (num < 20) {
+                curr.append(teens[num - 10]).append(" ");
+            } else if (num < 100) {
+                curr.append(tens[num / 10]).append(" ");
+                recursion(curr, num % 10);
+            } else {
+                curr.append(singles[num / 100]).append(" Hundred ");
+                recursion(curr, num % 100);
+            }
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/LargestPalindromeProduct.java

@@ -0,0 +1,48 @@
+//你需要找到由两个 n 位数的乘积组成的最大回文数。 
+//
+// 由于结果会很大，你只需返回最大回文数 mod 1337得到的结果。 
+//
+// 示例: 
+//
+// 输入: 2 
+//
+// 输出: 987 
+//
+// 解释: 99 x 91 = 9009, 9009 % 1337 = 987 
+//
+// 说明: 
+//
+// n 的取值范围为 [1,8]。 
+// Related Topics 数学 👍 41 👎 0
+
+package leetcode.editor.cn;
+
+//479:最大回文数乘积
+class LargestPalindromeProduct {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new LargestPalindromeProduct().new Solution();
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public int largestPalindrome(int n) {
+            if (n == 1) {
+                return 9;
+            }
+            long max = (long) Math.pow(10, n) - 1;
+            for (long i = max; i > max / 10; i--) {
+                long mul = Long.parseLong(i + new StringBuilder("" + i).reverse().toString());
+                for (long j = max; j * j >= mul; j--) {
+                    if (mul % j == 0) {
+                        return (int) (mul % 1337);
+                    }
+                }
+            }
+            return 0;
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/MinimumOperationsToMakeAUniValueGrid.java

@@ -0,0 +1,98 @@
+//给你一个大小为 m x n 的二维整数网格 grid 和一个整数 x 。每一次操作，你可以对 grid 中的任一元素 加 x 或 减 x 。 
+//
+// 单值网格 是全部元素都相等的网格。 
+//
+// 返回使网格化为单值网格所需的 最小 操作数。如果不能，返回 -1 。 
+//
+// 
+//
+// 示例 1： 
+//
+// 
+//
+// 
+//输入：grid = [[2,4],[6,8]], x = 2
+//输出：4
+//解释：可以执行下述操作使所有元素都等于 4 ： 
+//- 2 加 x 一次。
+//- 6 减 x 一次。
+//- 8 减 x 两次。
+//共计 4 次操作。
+// 
+//
+// 示例 2： 
+//
+// 
+//
+// 
+//输入：grid = [[1,5],[2,3]], x = 1
+//输出：5
+//解释：可以使所有元素都等于 3 。
+// 
+//
+// 示例 3： 
+//
+// 
+//
+// 
+//输入：grid = [[1,2],[3,4]], x = 2
+//输出：-1
+//解释：无法使所有元素相等。
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// m == grid.length 
+// n == grid[i].length 
+// 1 <= m, n <= 10⁵ 
+// 1 <= m * n <= 10⁵ 
+// 1 <= x, grid[i][j] <= 10⁴ 
+// 
+// 👍 8 👎 0
+
+package leetcode.editor.cn;
+
+import com.code.leet.entiy.TwoArray;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+//2033:获取单值网格的最小操作数
+class MinimumOperationsToMakeAUniValueGrid {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new MinimumOperationsToMakeAUniValueGrid().new Solution();
+        TwoArray twoArray = new TwoArray("[[146]]", true);
+        solution.minOperations(twoArray.getArr(), 86);
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public int minOperations(int[][] grid, int x) {
+            List<Integer> list = new ArrayList<>();
+            int temp = grid[0][0];
+            for (int[] ints : grid) {
+                for (int j = 0; j < grid[0].length; j++) {
+                    if (Math.abs(ints[j] - temp) % x > 0) {
+                        return -1;
+                    }
+                    list.add(ints[j]);
+                }
+            }
+            Collections.sort(list);
+            int num = list.get(list.size() / 2);
+            int sum = 0;
+            for (Integer integer : list) {
+                sum += Math.abs(integer - num) / x;
+            }
+            return sum;
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/StockPriceFluctuation.java

@@ -0,0 +1,160 @@
+//给你一支股票价格的数据流。数据流中每一条记录包含一个 时间戳 和该时间点股票对应的 价格 。 
+//
+// 不巧的是，由于股票市场内在的波动性，股票价格记录可能不是按时间顺序到来的。某些情况下，有的记录可能是错的。如果两个有相同时间戳的记录出现在数据流中，前一条
+//记录视为错误记录，后出现的记录 更正 前一条错误的记录。 
+//
+// 请你设计一个算法，实现： 
+//
+// 
+// 更新 股票在某一时间戳的股票价格，如果有之前同一时间戳的价格，这一操作将 更正 之前的错误价格。 
+// 找到当前记录里 最新股票价格 。最新股票价格 定义为时间戳最晚的股票价格。 
+// 找到当前记录里股票的 最高价格 。 
+// 找到当前记录里股票的 最低价格 。 
+// 
+//
+// 请你实现 StockPrice 类： 
+//
+// 
+// StockPrice() 初始化对象，当前无股票价格记录。 
+// void update(int timestamp, int price) 在时间点 timestamp 更新股票价格为 price 。 
+// int current() 返回股票 最新价格 。 
+// int maximum() 返回股票 最高价格 。 
+// int minimum() 返回股票 最低价格 。 
+// 
+//
+// 
+//
+// 示例 1： 
+//
+// 输入：
+//["StockPrice", "update", "update", "current", "maximum", "update", "maximum", 
+//"update", "minimum"]
+//[[], [1, 10], [2, 5], [], [], [1, 3], [], [4, 2], []]
+//输出：
+//[null, null, null, 5, 10, null, 5, null, 2]
+//
+//解释：
+//StockPrice stockPrice = new StockPrice();
+//stockPrice.update(1, 10); // 时间戳为 [1] ，对应的股票价格为 [10] 。
+//stockPrice.update(2, 5);  // 时间戳为 [1,2] ，对应的股票价格为 [10,5] 。
+//stockPrice.current();     // 返回 5 ，最新时间戳为 2 ，对应价格为 5 。
+//stockPrice.maximum();     // 返回 10 ，最高价格的时间戳为 1 ，价格为 10 。
+//stockPrice.update(1, 3);  // 之前时间戳为 1 的价格错误，价格更新为 3 。
+//                          // 时间戳为 [1,2] ，对应股票价格为 [3,5] 。
+//stockPrice.maximum();     // 返回 5 ，更正后最高价格为 5 。
+//stockPrice.update(4, 2);  // 时间戳为 [1,2,4] ，对应价格为 [3,5,2] 。
+//stockPrice.minimum();     // 返回 2 ，最低价格时间戳为 4 ，价格为 2 。
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// 1 <= timestamp, price <= 10⁹ 
+// update，current，maximum 和 minimum 总 调用次数不超过 10⁵ 。 
+// current，maximum 和 minimum 被调用时，update 操作 至少 已经被调用过 一次 。 
+// 
+// 👍 6 👎 0
+
+package leetcode.editor.cn;
+
+import java.util.TreeMap;
+
+//2034:股票价格波动
+class StockPriceFluctuation {
+    public static void main(String[] args) {
+        //测试代码
+//        Solution solution = new StockPriceFluctuation().new Solution();
+        StockPrice stockPrice = new StockPriceFluctuation().new StockPrice();
+        stockPrice.update(38, 2308);
+        stockPrice.maximum();
+        stockPrice.current();
+        stockPrice.minimum();
+        stockPrice.maximum();
+        stockPrice.maximum();
+        stockPrice.maximum();
+        stockPrice.minimum();
+        stockPrice.minimum();
+        stockPrice.maximum();
+        stockPrice.update(47, 7876);
+        stockPrice.maximum();
+        stockPrice.minimum();
+        stockPrice.update(58, 1866);
+        stockPrice.maximum();
+        stockPrice.minimum();
+        stockPrice.current();
+        stockPrice.maximum();
+        stockPrice.update(43, 121);
+        stockPrice.minimum();
+        stockPrice.maximum();
+        stockPrice.update(40, 5339);
+        stockPrice.maximum();
+        stockPrice.maximum();
+        stockPrice.current();
+        stockPrice.update(32, 5339);
+        stockPrice.current();//
+        stockPrice.minimum();
+        stockPrice.update(43, 6414);
+        stockPrice.update(49, 9369);
+        stockPrice.minimum();
+        stockPrice.minimum();
+        stockPrice.update(36, 3192);
+        stockPrice.current();//
+        stockPrice.update(48, 1006);
+        stockPrice.maximum();
+        stockPrice.update(53, 8013);
+        stockPrice.minimum();
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class StockPrice {
+
+        TreeMap<Integer, Integer> map;
+        TreeMap<Integer, Integer> priceMap;
+        int cur;
+
+        public StockPrice() {
+            map = new TreeMap<>();
+            priceMap = new TreeMap<>();
+            cur = 0;
+        }
+
+        public void update(int timestamp, int price) {
+            if (map.containsKey(timestamp)) {
+                int oldPrice = map.get(timestamp);
+                priceMap.put(oldPrice, priceMap.get(oldPrice) - 1);
+                if (priceMap.get(oldPrice) == 0) {
+                    priceMap.remove(oldPrice);
+                }
+            }
+            priceMap.put(price, priceMap.getOrDefault(price, 0) + 1);
+            map.put(timestamp, price);
+            cur = Math.max(cur, timestamp);
+        }
+
+        public int current() {
+            return map.get(cur);
+        }
+
+        public int maximum() {
+            return priceMap.lastKey();
+        }
+
+        public int minimum() {
+            return priceMap.firstKey();
+        }
+    }
+
+/**
+ * Your StockPrice object will be instantiated and called as such:
+ * StockPrice obj = new StockPrice();
+ * obj.update(timestamp,price);
+ * int param_2 = obj.current();
+ * int param_3 = obj.maximum();
+ * int param_4 = obj.minimum();
+ */
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/TwoSum.java

@@ -45,9 +45,7 @@
 
 package leetcode.editor.cn;
 
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Arrays;
-import java.util.List;
 
 //1:两数之和
 public class TwoSum {
@@ -55,42 +53,69 @@ public class TwoSum{
         //测试代码
         Solution solution = new TwoSum().new Solution();
     }
+
     //力扣代码
     //leetcode submit region begin(Prohibit modification and deletion)
     class Solution {
+        //    public int[] twoSum(int[] nums, int target) {
+//        int start = 0;
+//        int end = nums.length - 1;
+//        int[] result = new int[2];
+//        if (nums.length == 2) {
+//            result[0] = start;
+//            result[1] = end;
+//        } else {
+//            List<Integer> list = new ArrayList();
+//            for (int i = 0; i < nums.length; i++) {
+//                list.add(nums[i]);
+//            }
+//            Arrays.sort(nums);
+//            while (nums[start] + nums[end] != target) {
+//                if (nums[start] + nums[end] > target) {
+//                    end--;
+//                } else {
+//                    start++;
+//                }
+//            }
+//            result[0] = list.indexOf(nums[start]);
+//            list.remove(result[0]);
+//            result[1] = list.indexOf(nums[end]);
+//            if (result[1] >= result[0]) {
+//                result[1]++;
+//            }
+//            if (result[0] > result[1]) {
+//                int temp = result[0];
+//                result[0] = result[1];
+//                result[1] = temp;
+//            }
+//        }
+//        return result;
+//    }
         public int[] twoSum(int[] nums, int target) {
+            int[] arrs = new int[2];
             int start = 0;
             int end = nums.length - 1;
-        int[] result = new int[2];
+            List<Integer> list = new ArrayList<>();
-        if (nums.length == 2) {
+            for (int num : nums) {
-            result[0] = start;
+                list.add(num);
-            result[1] = end;
-        } else {
-            List<Integer> list = new ArrayList();
-            for (int i = 0; i < nums.length; i++) {
-                list.add(nums[i]);
             }
             Arrays.sort(nums);
-            while (nums[start] + nums[end] != target) {
+            while (start < end) {
-                if (nums[start] + nums[end] > target) {
+                if (nums[start] + nums[end] < target) {
+                    start++;
+                } else if (nums[start] + nums[end] > target) {
                     end--;
                 } else {
-                    start++;
+                    break;
                 }
             }
-            result[0] = list.indexOf(nums[start]);
+            arrs[0] = list.indexOf(nums[start]);
-            list.remove(result[0]);
+            list.remove(arrs[0]);
-            result[1] = list.indexOf(nums[end]);
+            arrs[1] = list.indexOf(nums[end]);
-            if (result[1] >= result[0]) {
+            if (arrs[1] >= arrs[0]) {
-                result[1]++;
+                arrs[1]++;
             }
-            if (result[0] > result[1]) {
+            return arrs;
-                int temp = result[0];
-                result[0] = result[1];
-                result[1] = temp;
-            }
-        }
-        return result;
         }
     }
 //leetcode submit region end(Prohibit modification and deletion)

src/main/java/leetcode/editor/cn/TwoSumIiInputArrayIsSorted.java

@@ -43,12 +43,14 @@
 // 👍 533 👎 0
 
 package leetcode.editor.cn;
+
 //167:两数之和 II - 输入有序数组
 class TwoSumIiInputArrayIsSorted {
     public static void main(String[] args) {
         //测试代码
         Solution solution = new TwoSumIiInputArrayIsSorted().new Solution();
     }
+
     //力扣代码
     //leetcode submit region begin(Prohibit modification and deletion)
     class Solution {

src/main/java/leetcode/editor/cn/doc/content/DivideTwoIntegers.md

@@ -0,0 +1,30 @@
+<p>给定两个整数，被除数&nbsp;<code>dividend</code>&nbsp;和除数&nbsp;<code>divisor</code>。将两数相除，要求不使用乘法、除法和 mod 运算符。</p>
+
+<p>返回被除数&nbsp;<code>dividend</code>&nbsp;除以除数&nbsp;<code>divisor</code>&nbsp;得到的商。</p>
+
+<p>整数除法的结果应当截去（<code>truncate</code>）其小数部分，例如：<code>truncate(8.345) = 8</code> 以及 <code>truncate(-2.7335) = -2</code></p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例&nbsp;1:</strong></p>
+
+<pre><strong>输入:</strong> dividend = 10, divisor = 3
+<strong>输出:</strong> 3
+<strong>解释: </strong>10/3 = truncate(3.33333..) = truncate(3) = 3</pre>
+
+<p><strong>示例&nbsp;2:</strong></p>
+
+<pre><strong>输入:</strong> dividend = 7, divisor = -3
+<strong>输出:</strong> -2
+<strong>解释:</strong> 7/-3 = truncate(-2.33333..) = -2</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li>被除数和除数均为 32 位有符号整数。</li>
+	<li>除数不为&nbsp;0。</li>
+	<li>假设我们的环境只能存储 32 位有符号整数，其数值范围是 [&minus;2<sup>31</sup>,&nbsp; 2<sup>31&nbsp;</sup>&minus; 1]。本题中，如果除法结果溢出，则返回 2<sup>31&nbsp;</sup>&minus; 1。</li>
+</ul>
+<div><div>Related Topics</div><div><li>位运算</li><li>数学</li></div></div><br><div><li>👍 700</li><li>👎 0</li></div>

src/main/java/leetcode/editor/cn/doc/content/IntegerToEnglishWords.md

@@ -0,0 +1,40 @@
+<p>将非负整数 <code>num</code> 转换为其对应的英文表示。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>num = 123
+<strong>输出：</strong>"One Hundred Twenty Three"
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>num = 12345
+<strong>输出：</strong>"Twelve Thousand Three Hundred Forty Five"
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>num = 1234567
+<strong>输出：</strong>"One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven"
+</pre>
+
+<p><strong>示例 4：</strong></p>
+
+<pre>
+<strong>输入：</strong>num = 1234567891
+<strong>输出：</strong>"One Billion Two Hundred Thirty Four Million Five Hundred Sixty Seven Thousand Eight Hundred Ninety One"
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>0 <= num <= 2<sup>31</sup> - 1</code></li>
+</ul>
+<div><div>Related Topics</div><div><li>递归</li><li>数学</li><li>字符串</li></div></div><br><div><li>👍 198</li><li>👎 0</li></div>

src/main/java/leetcode/editor/cn/doc/content/LargestPalindromeProduct.md

@@ -0,0 +1,16 @@
+<p>你需要找到由两个 n 位数的乘积组成的最大回文数。</p>
+
+<p>由于结果会很大，你只需返回最大回文数 mod 1337得到的结果。</p>
+
+<p><strong>示例:</strong></p>
+
+<p>输入: 2</p>
+
+<p>输出: 987</p>
+
+<p>解释: 99 x 91 = 9009, 9009 % 1337 = 987</p>
+
+<p><strong>说明:</strong></p>
+
+<p>n 的取值范围为&nbsp;[1,8]。</p>
+<div><div>Related Topics</div><div><li>数学</li></div></div><br><div><li>👍 41</li><li>👎 0</li></div>

src/main/java/leetcode/editor/cn/doc/content/MinimumOperationsToMakeAUniValueGrid.md

@@ -0,0 +1,54 @@
+<p>给你一个大小为&nbsp;<code>m x n</code> 的二维整数网格 <code>grid</code> 和一个整数 <code>x</code> 。每一次操作，你可以对 <code>grid</code> 中的任一元素 <strong>加</strong> <code>x</code> 或 <strong>减</strong> <code>x</code> 。</p>
+
+<p><strong>单值网格</strong> 是全部元素都相等的网格。</p>
+
+<p>返回使网格化为单值网格所需的 <strong>最小</strong> 操作数。如果不能，返回 <code>-1</code> 。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2021/09/21/gridtxt.png" style="width: 164px; height: 165px;" /></p>
+
+<pre>
+<strong>输入：</strong>grid = [[2,4],[6,8]], x = 2
+<strong>输出：</strong>4
+<strong>解释：</strong>可以执行下述操作使所有元素都等于 4 ： 
+- 2 加 x 一次。
+- 6 减 x 一次。
+- 8 减 x 两次。
+共计 4 次操作。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2021/09/21/gridtxt-1.png" style="width: 164px; height: 165px;" /></p>
+
+<pre>
+<strong>输入：</strong>grid = [[1,5],[2,3]], x = 1
+<strong>输出：</strong>5
+<strong>解释：</strong>可以使所有元素都等于 3 。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2021/09/21/gridtxt-2.png" style="width: 164px; height: 165px;" /></p>
+
+<pre>
+<strong>输入：</strong>grid = [[1,2],[3,4]], x = 2
+<strong>输出：</strong>-1
+<strong>解释：</strong>无法使所有元素相等。
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>m == grid.length</code></li>
+	<li><code>n == grid[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= x, grid[i][j] &lt;= 10<sup>4</sup></code></li>
+</ul>
+<div><li>👍 8</li><li>👎 0</li></div>

src/main/java/leetcode/editor/cn/doc/content/StockPriceFluctuation.md

@@ -0,0 +1,56 @@
+<p>给你一支股票价格的数据流。数据流中每一条记录包含一个 <strong>时间戳</strong>&nbsp;和该时间点股票对应的 <strong>价格</strong>&nbsp;。</p>
+
+<p>不巧的是，由于股票市场内在的波动性，股票价格记录可能不是按时间顺序到来的。某些情况下，有的记录可能是错的。如果两个有相同时间戳的记录出现在数据流中，前一条记录视为错误记录，后出现的记录 <b>更正</b>&nbsp;前一条错误的记录。</p>
+
+<p>请你设计一个算法，实现：</p>
+
+<ul>
+	<li><strong>更新 </strong>股票在某一时间戳的股票价格，如果有之前同一时间戳的价格，这一操作将&nbsp;<strong>更正</strong>&nbsp;之前的错误价格。</li>
+	<li>找到当前记录里 <b>最新股票价格</b>&nbsp;。<strong>最新股票价格</strong>&nbsp;定义为时间戳最晚的股票价格。</li>
+	<li>找到当前记录里股票的 <strong>最高价格</strong>&nbsp;。</li>
+	<li>找到当前记录里股票的 <strong>最低价格</strong>&nbsp;。</li>
+</ul>
+
+<p>请你实现&nbsp;<code>StockPrice</code>&nbsp;类：</p>
+
+<ul>
+	<li><code>StockPrice()</code>&nbsp;初始化对象，当前无股票价格记录。</li>
+	<li><code>void update(int timestamp, int price)</code>&nbsp;在时间点 <code>timestamp</code>&nbsp;更新股票价格为 <code>price</code>&nbsp;。</li>
+	<li><code>int current()</code>&nbsp;返回股票 <strong>最新价格</strong>&nbsp;。</li>
+	<li><code>int maximum()</code>&nbsp;返回股票 <strong>最高价格</strong>&nbsp;。</li>
+	<li><code>int minimum()</code>&nbsp;返回股票 <strong>最低价格</strong>&nbsp;。</li>
+</ul>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>
+["StockPrice", "update", "update", "current", "maximum", "update", "maximum", "update", "minimum"]
+[[], [1, 10], [2, 5], [], [], [1, 3], [], [4, 2], []]
+<strong>输出：</strong>
+[null, null, null, 5, 10, null, 5, null, 2]
+
+<strong>解释：</strong>
+StockPrice stockPrice = new StockPrice();
+stockPrice.update(1, 10); // 时间戳为 [1] ，对应的股票价格为 [10] 。
+stockPrice.update(2, 5);  // 时间戳为 [1,2] ，对应的股票价格为 [10,5] 。
+stockPrice.current();     // 返回 5 ，最新时间戳为 2 ，对应价格为 5 。
+stockPrice.maximum();     // 返回 10 ，最高价格的时间戳为 1 ，价格为 10 。
+stockPrice.update(1, 3);  // 之前时间戳为 1 的价格错误，价格更新为 3 。
+                          // 时间戳为 [1,2] ，对应股票价格为 [3,5] 。
+stockPrice.maximum();     // 返回 5 ，更正后最高价格为 5 。
+stockPrice.update(4, 2);  // 时间戳为 [1,2,4] ，对应价格为 [3,5,2] 。
+stockPrice.minimum();     // 返回 2 ，最低价格时间戳为 4 ，价格为 2 。
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= timestamp, price &lt;= 10<sup>9</sup></code></li>
+	<li><code>update</code>，<code>current</code>，<code>maximum</code>&nbsp;和&nbsp;<code>minimum</code>&nbsp;<strong>总</strong> 调用次数不超过&nbsp;<code>10<sup>5</sup></code>&nbsp;。</li>
+	<li><code>current</code>，<code>maximum</code>&nbsp;和&nbsp;<code>minimum</code>&nbsp;被调用时，<code>update</code>&nbsp;操作 <strong>至少</strong>&nbsp;已经被调用过 <strong>一次</strong>&nbsp;。</li>
+</ul>
+<div><li>👍 6</li><li>👎 0</li></div>