update

Author: Zhenghao-Liu

0815.公交路线/README.md

@@ -0,0 +1,34 @@
+给你一个数组 ```routes``` ，表示一系列公交线路，其中每个 ```routes[i]``` 表示一条公交线路，第 ```i``` 辆公交车将会在上面循环行驶。
+
+* 例如，路线 ```routes[0] = [1, 5, 7]``` 表示第 0 辆公交车会一直按序列 ```1 -> 5 -> 7 -> 1 -> 5 -> 7 -> 1 -> ...``` 这样的车站路线行驶。
+
+现在从 ```source``` 车站出发（初始时不在公交车上），要前往 ```target``` 车站。 期间仅可乘坐公交车。
+
+求出 **最少乘坐的公交车数量** 。如果不可能到达终点车站，返回 ```-1``` 。
+
+ 
+
+**示例 1：**
+```
+输入：routes = [[1,2,7],[3,6,7]], source = 1, target = 6
+输出：2
+解释：最优策略是先乘坐第一辆公交车到达车站 7 , 然后换乘第二辆公交车到车站 6 。 
+```
+**示例 2：**
+```
+输入：routes = [[7,12],[4,5,15],[6],[15,19],[9,12,13]], source = 15, target = 12
+输出：-1
+```
+
+**提示：**
+
+* ```1 <= routes.length <= 500.```
+* ```1 <= routes[i].length <= 105```
+* ```routes[i]``` 中的所有值 互不相同
+* ```sum(routes[i].length) <= 10^5```
+* ```0 <= routes[i][j] < 10^6```
+* ```0 <= source, target < 106```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/bus-routes
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

0815.公交路线/solution.cpp

@@ -0,0 +1,46 @@
+const int MAXN=1e6;
+int vis[MAXN];
+const int MAXL=500;
+int busVis[MAXL];
+const int INF=0x3f3f3f3f;
+class Solution {
+public:
+    int numBusesToDestination(vector<vector<int>>& routes, int source, int target) {
+        if (source==target) {
+            return 0;
+        }
+        int sz=routes.size();
+        unordered_map<int,vector<int>> ump;
+        for (int i=0;i<sz;i++) {
+            for (int j:routes.at(i)) {
+                ump[j].push_back(i);
+            }
+        }
+        memset(vis,0x3f,sizeof(vis));
+        memset(busVis,0,sizeof(busVis));
+        vis[source]=0;
+        queue<int> que;
+        que.push(source);
+        while (!que.empty()) {
+            int cur=que.front();
+            que.pop();
+            for (int bus:ump.at(cur)) {
+                if (busVis[bus]==1) {
+                    continue;
+                }
+                for (int nxt:routes.at(bus)) {
+                    if (vis[nxt]!=INF) {
+                        continue;
+                    }
+                    vis[nxt]=vis[cur]+1;
+                    que.push(nxt);
+                    if (nxt==target) {
+                        return vis[nxt];
+                    }
+                }
+                busVis[bus]=1;
+            }
+        }
+        return -1;
+    }
+};

0909.蛇梯棋/909_1.png

@@ -0,0 +1,50 @@
+N x N 的棋盘 ```board``` 上，按从 ```1``` 到 ```N*N``` 的数字给方格编号，编号 **从左下角开始**，每一行交替方向。
+
+例如，一块 6 x 6 大小的棋盘，编号如下：
+![img](909_1.png)
+
+```r``` 行 ```c``` 列的棋盘，按前述方法编号，棋盘格中可能存在 “蛇” 或 “梯子”；如果 ```board[r][c] != -1```，那个蛇或梯子的目的地将会是 ```board[r][c]```。
+
+玩家从棋盘上的方格 ```1``` （总是在最后一行、第一列）开始出发。
+
+每一回合，玩家需要从当前方格 ```x``` 开始出发，按下述要求前进：
+
+* 选定目标方格：从编号为 ```x+1，x+2，x+3，x+4，x+5```，或者 ```x+6``` 的方格中选出一个作为目标方格 ```s``` ，目标方格的编号 ```<= N*N```。
+    * 该选择模拟了掷骰子的情景，无论棋盘大小如何，你的目的地范围也只能处于区间 ```[x+1, x+6]``` 之间。
+* 传送玩家：如果目标方格 ```S``` 处存在蛇或梯子，那么玩家会传送到蛇或梯子的目的地。否则，玩家传送到目标方格 ```S``` 。 
+
+注意，玩家在每回合的前进过程中最多只能爬过蛇或梯子一次：就算目的地是另一条蛇或梯子的起点，你也不会继续移动。
+
+返回达到方格 N*N 所需的最少移动次数，如果不可能，则返回 ```-1```。
+
+ 
+
+**示例：**
+```
+输入：[
+[-1,-1,-1,-1,-1,-1],
+[-1,-1,-1,-1,-1,-1],
+[-1,-1,-1,-1,-1,-1],
+[-1,35,-1,-1,13,-1],
+[-1,-1,-1,-1,-1,-1],
+[-1,15,-1,-1,-1,-1]]
+输出：4
+解释：
+首先，从方格 1 [第 5 行，第 0 列] 开始。
+你决定移动到方格 2，并必须爬过梯子移动到到方格 15。
+然后你决定移动到方格 17 [第 3 行，第 4 列]，必须爬过蛇到方格 13。
+然后你决定移动到方格 14，且必须通过梯子移动到方格 35。
+然后你决定移动到方格 36, 游戏结束。
+可以证明你需要至少 4 次移动才能到达第 N*N 个方格，所以答案是 4。
+```
+
+**提示：**
+
+* ```2 <= board.length = board[0].length <= 20```
+* ```board[i][j]``` 介于 ```1``` 和 ```N*N``` 之间或者等于 ```-1```。
+* 编号为 ```1``` 的方格上没有蛇或梯子。
+* 编号为 ```N*N``` 的方格上没有蛇或梯子。
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/snakes-and-ladders
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

0909.蛇梯棋/README.md

@@ -0,0 +1,44 @@
+const int MAXN=20;
+int vis[MAXN*MAXN+1];
+const int MAXS=6;
+const int INF=0x3f3f3f3f;
+class Solution {
+public:
+    int snakesAndLadders(vector<vector<int>>& board) {
+        int n=board.size();
+        int tar=n*n;
+        vector<int> vec;
+        vec.reserve(n*n+1);
+        vec.push_back(0);
+        int j=-1,step=-1;
+        for (int i=n-1;i>=0;i--) {
+            step*=-1;
+            for (j= j==-1 ? 0 : n-1;j>=0 && j<n;j+=step) {
+                vec.push_back(board.at(i).at(j));
+            }
+        }
+        queue<int> que;
+        que.push(1);
+        memset(vis,0x3f,sizeof(vis));
+        vis[1]=0;
+        while (!que.empty()) {
+            int cur=que.front();
+            que.pop();
+            for (int s=1;s<=MAXS;s++) {
+                int nxt=cur+s;
+                if (vec.at(nxt)!=-1) {
+                    nxt=vec.at(nxt);
+                }
+                if (vis[nxt]!=INF) {
+                    continue;
+                }
+                vis[nxt]=vis[cur]+1;
+                if (nxt==tar) {
+                    return vis[nxt];
+                }
+                que.push(nxt);
+            }
+        }
+        return -1;
+    }
+};

0909.蛇梯棋/solution.cpp

@@ -0,0 +1,34 @@
+给你一个 **从 0 开始的排列** ```nums```（**下标也从 0 开始**）。请你构建一个 **同样长度** 的数组 ```ans``` ，其中，对于每个 ```i（0 <= i < nums.length）```，都满足 ```ans[i] = nums[nums[i]]``` 。返回构建好的数组 ```ans``` 。
+
+**从 0 开始的排列** ```nums``` 是一个由 ```0``` 到 ```nums.length - 1```（```0``` 和 ```nums.length - 1``` 也包含在内）的不同整数组成的数组。
+
+ 
+
+**示例 1：**
+```
+输入：nums = [0,2,1,5,3,4]
+输出：[0,1,2,4,5,3]
+解释：数组 ans 构建如下：
+ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
+    = [nums[0], nums[2], nums[1], nums[5], nums[3], nums[4]]
+    = [0,1,2,4,5,3]
+```
+**示例 2：**
+```
+输入：nums = [5,0,1,2,3,4]
+输出：[4,5,0,1,2,3]
+解释：数组 ans 构建如下：
+ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
+    = [nums[5], nums[0], nums[1], nums[2], nums[3], nums[4]]
+    = [4,5,0,1,2,3]
+```
+
+**提示：**
+
+* ```1 <= nums.length <= 1000```
+* ```0 <= nums[i] < nums.length```
+* ```nums``` 中的元素 互不相同
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/build-array-from-permutation
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1920.基于排列构建数组/README.md

@@ -0,0 +1,11 @@
+class Solution {
+public:
+    vector<int> buildArray(vector<int>& nums) {
+        int sz=nums.size();
+        vector<int> ans(sz);
+        for (int i=0;i<sz;i++) {
+            ans.at(i)=nums.at(nums.at(i));
+        }
+        return ans;
+    }
+};

1920.基于排列构建数组/solution.cpp

@@ -0,0 +1,51 @@
+你正在玩一款电子游戏，在游戏中你需要保护城市免受怪物侵袭。给你一个 **下标从 0 开始** 且长度为 ```n``` 的整数数组 ```dist``` ，其中 ```dist[i]``` 是第 ```i``` 个怪物与城市的 **初始距离**（单位：米）。
+
+怪物以 **恒定** 的速度走向城市。给你一个长度为 ```n``` 的整数数组 ```speed``` 表示每个怪物的速度，其中 ```speed[i]``` 是第 ```i``` 个怪物的速度（单位：米/分）。
+
+怪物从 **第 0 分钟** 时开始移动。你有一把武器，并可以 **选择** 在每一分钟的开始时使用，包括第 0 分钟。但是你无法在一分钟的中间使用武器。这种武器威力惊人，一次可以消灭任一还活着的怪物。
+
+一旦任一怪物到达城市，你就输掉了这场游戏。如果某个怪物 **恰** 在某一分钟开始时到达城市，这会被视为 **输掉** 游戏，在你可以使用武器之前，游戏就会结束。
+
+返回在你输掉游戏前可以消灭的怪物的 **最大** 数量。如果你可以在所有怪物到达城市前将它们全部消灭，返回  ```n``` 。
+
+ 
+
+**示例 1：**
+```
+输入：dist = [1,3,4], speed = [1,1,1]
+输出：3
+解释：
+第 0 分钟开始时，怪物的距离是 [1,3,4]，你消灭了第一个怪物。
+第 1 分钟开始时，怪物的距离是 [X,2,3]，你没有消灭任何怪物。
+第 2 分钟开始时，怪物的距离是 [X,1,2]，你消灭了第二个怪物。
+第 3 分钟开始时，怪物的距离是 [X,X,1]，你消灭了第三个怪物。
+所有 3 个怪物都可以被消灭。
+```
+**示例 2：**
+```
+输入：dist = [1,1,2,3], speed = [1,1,1,1]
+输出：1
+解释：
+第 0 分钟开始时，怪物的距离是 [1,1,2,3]，你消灭了第一个怪物。
+第 1 分钟开始时，怪物的距离是 [X,0,1,2]，你输掉了游戏。
+你只能消灭 1 个怪物。
+```
+**示例 3：**
+```
+输入：dist = [3,2,4], speed = [5,3,2]
+输出：1
+解释：
+第 0 分钟开始时，怪物的距离是 [3,2,4]，你消灭了第一个怪物。
+第 1 分钟开始时，怪物的距离是 [X,0,2]，你输掉了游戏。 
+你只能消灭 1 个怪物。
+```
+
+**提示：**
+
+* ```n == dist.length == speed.length```
+* ```1 <= n <= 10^5```
+* ```1 <= dist[i], speed[i] <= 10^5```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/eliminate-maximum-number-of-monsters
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1921.消灭怪物的最大数量/README.md

@@ -0,0 +1,31 @@
+const int MAXN=1e5+5;
+int cnt[MAXN];
+class Solution {
+public:
+    int eliminateMaximum(vector<int>& dist, vector<int>& speed) {
+        memset(cnt,0,sizeof(cnt));
+        int sz=dist.size();
+        for (int i=0;i<sz;i++) {
+            int cur=dist.at(i)/speed.at(i);
+            if (cur*speed.at(i)!=dist.at(i)) {
+                cur++;
+            }
+            cnt[cur]++;
+        }
+        int sco=0;
+        int ans=0;
+        for (int i=0;i<MAXN;i++) {
+            if (cnt[i]==0) {
+                sco++;
+                continue;
+            }
+            ans+=min(cnt[i],sco);
+            sco-=cnt[i];
+            if (sco<0) {
+                return ans;
+            }
+            sco++;
+        }
+        return ans;
+    }
+};

1921.消灭怪物的最大数量/solution.cpp

@@ -0,0 +1,34 @@
+我们称一个数字字符串是 **好数字** 当它满足（下标从 ```0``` 开始）**偶数** 下标处的数字为 **偶数** 且 **奇数** 下标处的数字为 **质数** （```2，3，5 或 7```）。
+
+* 比方说，"```2582```" 是好数字，因为偶数下标处的数字（```2 和 8```）是偶数且奇数下标处的数字（```5 和 2```）为质数。但 "```3245```" **不是** 好数字，因为 ```3``` 在偶数下标处但不是偶数。
+
+给你一个整数 ```n``` ，请你返回长度为 ```n``` 且为好数字的数字字符串 **总数** 。由于答案可能会很大，请你将它对 ```10^9 + 7``` 取余后返回 。
+
+一个 **数字字符串** 是每一位都由 0 到 9 组成的字符串，且可能包含前导 0 。
+
+ 
+
+**示例 1：**
+```
+输入：n = 1
+输出：5
+解释：长度为 1 的好数字包括 "0"，"2"，"4"，"6"，"8" 。
+```
+**示例 2：**
+```
+输入：n = 4
+输出：400
+```
+**示例 3：**
+```
+输入：n = 50
+输出：564908303
+```
+
+**提示**
+
+* ```1 <= n <= 10^15```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/count-good-numbers
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1922.统计好数字的数目/README.md

@@ -0,0 +1,33 @@
+typedef long long ll;
+ll mod=1e9+7;
+class Solution {
+public:
+    int countGoodNumbers(long long n) {
+        ll half=n/2;
+        return quick_pow2(4,half)*quick_pow2(5,n-half)%mod;
+    }
+    long long quick_pow2(long long a,long long n)
+    {
+        if (n<0)
+        {
+            cerr << "error quick pow" << endl;
+            return -1;
+        }
+        if (a==0)
+            return 0;
+        a%=mod;
+        long long ans=1;
+        while (n!=0)
+        {
+            if ((n&1)==1)
+            {
+                ans*=a;
+                ans%=mod;
+            }
+            a*=a;
+            a%=mod;
+            n>>=1;
+        }
+        return ans;
+    }
+};