├── 03th数组、链表、跳表
    ├── 1.两数之和.php
    ├── 11.盛最多水的容器.php
    ├── 15.三数之和.php
    ├── 189.旋转数组.php
    ├── 232.用栈实现队列.php
    ├── 26.删除排序数组中的重复项.php
    ├── 283.移动零.php
    ├── 70.爬楼梯.php
    └── README.md
├── 04th栈、队列、优先队列、双端队列
    ├── 155.最小栈(fail).php
    ├── 155.最小栈.php
    ├── 20.有效的括号.php
    ├── 239.滑动窗口最大值(timeout).php
    ├── 42.接雨水.php
    ├── 641.设计循环双端队列.php
    └── README.md
├── 05th哈希表、映射、集合
    ├── 242.有效的字母异位词.php
    ├── 242.有效的字母异位词_加速.php
    ├── 49.字母异位词分组.php
    └── README.md
├── 06th树、二叉树、二叉搜索树
    ├── 06th最小的k个数.php
    ├── 06th最小的k个数_快排.php
    ├── 144.二叉树的前序遍历_迭代.php
    ├── 239.滑动窗口最大值.php
    ├── 264.丑数-ii.php
    ├── 347.前-k-个高频元素.php
    ├── 589.n叉树的前序遍历.php
    ├── 590.n叉树的后序遍历.php
    ├── 590.n叉树的后序遍历_迭代.php
    ├── 94.二叉树的中序遍历.php
    ├── 94.二叉树的中序遍历_迭代.php
    └── README.md
├── 07th泛型递归、树的递归
    ├── 104.二叉树的最大深度.php
    ├── 105.从前序与中序遍历序列构造二叉树.php
    ├── 105.从前序与中序遍历序列构造二叉树_加速.php
    ├── 111.二叉树的最小深度.php
    ├── 22.括号生成.php
    ├── 226.翻转二叉树.php
    ├── 236.二叉树的最近公共祖先.php
    ├── 46.全排列.php
    ├── 47.全排列-ii.php
    ├── 47.全排列-ii_加速.php
    ├── 70.爬楼梯_递归.php
    ├── 77.组合.php
    ├── 77.组合_加速.php
    ├── 98.验证二叉搜索树.php
    └── README.md
├── 08th分治、回溯
    ├── 17.电话号码的字母组合.php
    ├── 50.pow-x-n.php
    ├── 51.n皇后.php
    ├── 78.子集_回溯.php
    ├── 78.子集_递归.php
    └── README.md
├── 09th深度优先搜索和广度优先搜索
    ├── 102.二叉树的层序遍历_BFS.php
    ├── 127.单词接龙_超时.php
    ├── 200.岛屿数量_DFS.php
    ├── 22.括号生成_BFS.php
    ├── 22.括号生成_DFS.php
    ├── 433.最小基因变化_BFS.php
    ├── 529.扫雷游戏_DFS.php
    └── README.md
├── 10th贪心算法
    ├── 122.买卖股票的最佳时机-ii.php
    ├── 455.分发饼干.php
    ├── 55.跳跃游戏_贪心1.php
    ├── 55.跳跃游戏_贪心2.php
    └── README.md
├── 11th二分查找
    ├── 33.搜索旋转排序数组.php
    ├── 367.有效的完全平方数.php
    ├── 69.x-的平方根.php
    ├── 74.搜索二维矩阵.php
    └── README.md
├── 12th动态规划
    ├── 1143.最长公共子序列.php
    ├── 120.三角形最小路径和.php
    ├── 120.三角形最小路径和_优化内存.php
    ├── 121.买卖股票的最佳时机.php
    ├── 152.乘积最大子数组.php
    ├── 198.打家劫舍_DP.php
    ├── 198.打家劫舍_优化内存.php
    ├── 221.最大正方形.php
    ├── 312.戳气球_DP.php
    ├── 32.最长有效括号.php
    ├── 322.零钱兑换_自底向上DP.php
    ├── 410.分割数组的最大值.php
    ├── 53.最大子序和.php
    ├── 53.最大子序和_DP.php
    ├── 62.不同路径.php
    ├── 62.不同路径_优化内存.php
    ├── 621.任务调度器.php
    ├── 63.不同路径-ii.php
    ├── 64.最小路径和.php
    ├── 647.回文子串.php
    ├── 70.爬楼梯.php
    ├── 72.编辑距离.php
    ├── 91.解码方法.php
    └── README.md
├── 13th字典树和并查集
    ├── 130.被围绕的区域.php
    ├── 200.岛屿数量.php
    ├── 547.朋友圈_BFS.php
    ├── 547.朋友圈_DFS.php
    ├── 547.朋友圈_UnionFind.php
    └── README.md
├── 14th高级搜索
    ├── 22.括号生成.php
    ├── 433.最小基因变化.php
    ├── 51.n皇后.php
    ├── 70.爬楼梯.php
    └── README.md
├── 15th红黑树和AVL树
    └── README.md
├── 16th位运算
    ├── 190.颠倒二进制位.php
    ├── 191.位-1-的个数.php
    ├── 231.2-的幂.php
    └── README.md
├── 17th布隆过滤器和 LRU 缓存
    ├── 146.lru缓存机制.php
    └── README.md
├── 18th排序算法
    ├── 1122.数组的相对排序.php
    ├── 242.有效的字母异位词.php
    ├── 493.翻转对.php
    ├── 56.合并区间.php
    └── README.md
├── 19th高级动态规划
    ├── 115.不同的子序列.php
    ├── 300.最长上升子序列.php
    ├── 32.最长有效括号.php
    ├── 818.赛车_超时.php
    └── README.md
├── 20th字符串算法
    ├── 151.翻转字符串里的单词.php
    ├── 205.同构字符串.php
    ├── 387.字符串中的第一个唯一字符.php
    ├── 438.找到字符串中所有字母异位词.php
    ├── 541.反转字符串-ii.php
    ├── 557.反转字符串中的单词-iii.php
    ├── 8.字符串转换整数-atoi.php
    ├── 917.仅仅反转字母.php
    └── README.md
├── 21剑指offer系列
    └── README.md
├── 22程序员面试经典
    └── README.md
├── 23刷题路线
    ├── 128.最长连续序列.php
    ├── 128.最长连续序列_加速.php
    ├── README.md
    ├── [基础]1.两数之和.php
    ├── [基础]146.lru缓存机制.php
    ├── [基础]20.有效的括号.php
    ├── [基础]208.实现-trie-前缀树.php
    ├── [基础]211.添加与搜索单词-数据结构设计.php
    ├── [基础]212.单词搜索-ii.php
    ├── [基础]212.单词搜索-ii_超时.php
    └── [基础]394.字符串解码.php
├── README.md
├── 每日1题202007
    ├── README.md
    ├── [0713]350.两个数组的交集-ii.php
    ├── [0714]120.三角形最小路径和.php
    ├── [0715]96.不同的二叉搜索树.php
    ├── [0717]35.搜索插入位置.php
    ├── [0718]97.交错字符串.php
    ├── [0719]312.戳气球_动态规划DP.php
    ├── [0719]312.戳气球_回溯法(超时).php
    ├── [0720]167.两数之和-ii-输入有序数组.php
    ├── [0721]95.不同的二叉搜索树-ii_递归.php
    ├── [0722]剑指 Offer 11. 旋转数组的最小数字.php
    ├── [0723]64.最小路径和.php
    ├── [0724]1025.除数博弈.php
    ├── [0725]410.分割数组的最大值.php
    ├── [0726]329.矩阵中的最长递增路径.php
    ├── [0727]392.判断子序列.php
    ├── [0728]104.二叉树的最大深度.php
    ├── [0729]LCP 13. 寻宝.php
    ├── [0730]343.整数拆分.php
    └── [0731]面试题 08.03. 魔术索引.php
├── 每日1题202008
    ├── README.md
    ├── [0801]632.最小区间_未通过.php
    ├── [0802]114.二叉树展开为链表.php
    ├── [0803]415.字符串相加.php
    ├── [0804]207.课程表.php
    ├── [0805]337.打家劫舍-iii.php
    ├── [0806]336.回文对.php
    ├── [0807]100.相同的树.php
    ├── [0808]99.恢复二叉搜索树.php
    ├── [0809]93.复原ip地址.php
    ├── [0810]696.计数二进制子串.php
    ├── [0811]130.被围绕的区域.php
    ├── [0812]133.克隆图.php
    ├── [0813]43.字符串相乘_优化版.php
    ├── [0813]43.字符串相乘_普通版.php
    ├── [0814]20.有效的括号.php
    ├── [0815]546.移除盒子.php
    ├── [0816]733.图像渲染.php
    ├── [0817]110.平衡二叉树.php
    ├── [0818]109.有序链表转换二叉搜索树.php
    ├── [0819]647.回文子串.php
    ├── [0820]529.扫雷游戏.php
    ├── [0821]111.二叉树的最小深度.php
    ├── [0822]679.24-点游戏.php
    ├── [0823]201.数字范围按位与.php
    ├── [0824]459.重复的子字符串.php
    ├── [0825]491.递增子序列.php
    ├── [0826]17.电话号码的字母组合.php
    ├── [0827]332.重新安排行程.php
    ├── [0828]657.机器人能否返回原点.php
    ├── [0829]214.最短回文串.php
    ├── [0830]557.反转字符串中的单词-iii.php
    └── [0831]841.钥匙和房间.php
├── 每日1题202009
    ├── README.md
    ├── [0901]486.预测赢家_记忆化递归.php
    ├── [0901]486.预测赢家_递归.php
    ├── [0904]257.二叉树的所有路径.php
    ├── [0906]107.二叉树的层次遍历-ii.php
    ├── [0907]347.前-k-个高频元素.php
    ├── [0908]77.组合.php
    ├── [0909]39.组合总和.php
    ├── [0910]40.组合总和-ii.php
    ├── [0914]94.二叉树的中序遍历.php
    ├── [0914_1]144.二叉树的前序遍历.php
    ├── [0914_2]145.二叉树的后序遍历.php
    ├── [0915]37.解数独.php
    ├── [0916]226.翻转二叉树.php
    ├── [0917]685.冗余连接-ii_并查集.php
    ├── [0917]685.冗余连接-ii_非并查集.php
    ├── [0918]47.全排列-ii.php
    ├── [0919]404.左叶子之和.php
    ├── [0920]78.子集.php
    ├── [0921]538.把二叉搜索树转换为累加树.php
    ├── [0922]968.监控二叉树.php
    ├── [0923]617.合并二叉树.php
    ├── [0924]501.二叉搜索树中的众数.php
    ├── [0924]501.二叉搜索树中的众数_中序遍历.php
    ├── [0925]106.从中序与后序遍历序列构造二叉树.php
    ├── [0927]235.二叉搜索树的最近公共祖先.php
    ├── [0928]117.填充每个节点的下一个右侧节点指针-ii.php
    ├── [0928]117.填充每个节点的下一个右侧节点指针-ii_加速.php
    └── [0930]701.二叉搜索树中的插入操作.php
├── 每日1题202010
    ├── README.md
    ├── [1003]1.两数之和.php
    ├── [1007]75.颜色分类_单向遍历.php
    ├── [1007]75.颜色分类_双指针.php
    ├── [1008]344.反转字符串_双指针.php
    ├── [1009]141.环形链表_哈希表.php
    ├── [1009]141.环形链表_快慢指针.php
    ├── [1010]142.环形链表-ii.php
    ├── [1014]1002.查找常用字符.php
    ├── [1016]977.有序数组的平方_双指针.php
    ├── [1016]977.有序数组的平方_常规解法.php
    ├── [1017]52.n皇后-ii_回溯剪枝.php
    ├── [1018]19.删除链表的倒数第n个节点.php
    ├── [1018]19.删除链表的倒数第n个节点_双指针.php
    ├── [1019]844.比较含退格的字符串.php
    ├── [1020]143.重排链表_线性表存储.php
    ├── [1020]143.重排链表_递归.php
    ├── [1021]925.长按键入.php
    ├── [1022]763.划分字母区间.php
    ├── [1022]763.划分字母区间_暴力解法.php
    ├── [1023]234.回文链表_数组存储.php
    ├── [1028]1207.独一无二的出现次数.php
    ├── [1029]129.求根到叶子节点数字之和.php
    └── [1030]463.岛屿的周长.php
└── 每日1题202011
    ├── README.md
    ├── [1102]349.两个数组的交集_暴力解法.php
    └── [1103]941.有效的山脉数组.php


/03th数组、链表、跳表/1.两数之和.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=1 lang=php
 4 |  *
 5 |  * [1] 两数之和
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer[] $nums
13 |      * @param Integer $target
14 |      * @return Integer[]
15 |      */
16 |     function twoSum($nums, $target) {
17 | 
18 |         //$result = [];
19 | 
20 |         foreach ($nums as $k => $v) {
21 |             
22 |             if(isset($result[$target-$v]) && $nums[$result[$target-$v]] + $v === $target){
23 |                 return [$result[$target-$v], $k];
24 |             }
25 | 
26 |             $result[$v] = $k;
27 |         }
28 |     }
29 | }
30 | // @lc code=end
31 | 
32 | 


--------------------------------------------------------------------------------
/03th数组、链表、跳表/11.盛最多水的容器.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=11 lang=php
 4 |  *
 5 |  * [11] 盛最多水的容器
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer[] $height
13 |      * @return Integer
14 |      */
15 |     function maxArea($height) {
16 | 
17 |         // 双指针移动
18 |         // 初始容量
19 |         $max = 0;
20 |         // 数组长度
21 |         $len = count($height);
22 |         
23 |         for($i=0,$j=$len-1; $i<$j;) {
24 |             // 记录当前最小高度能装的水，与上一次进行对比
25 |             $max = max($max, min($height[$i],$height[$j])*($j-$i));
26 |             // 往中间收敛，保留最高的高度
27 |             $height[$i] > $height[$j] ? $j-- : $i++; 
28 |         }
29 | 
30 |         return $max;
31 |     }
32 | }
33 | // @lc code=end
34 | 
35 | 


--------------------------------------------------------------------------------
/03th数组、链表、跳表/15.三数之和.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=15 lang=php
 4 |  *
 5 |  * [15] 三数之和
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer[] $nums
13 |      * @return Integer[][]
14 |      */
15 |     function threeSum($nums) {
16 | 
17 |         $result = array();
18 |         // 边界
19 |         if(empty($nums) || count($nums) < 3){
20 |             return $result;
21 |         }
22 | 
23 |         // 排序
24 |         sort($nums);
25 |         for ($i=0; $i < count($nums)-2; $i++) {
26 | 
27 |             // 去重
28 |             if($i>0 && $nums[$i] == $nums[$i-1]) continue;
29 | 
30 |             // 头尾指针
31 |             $head = $i+1;
32 |             $tail = count($nums)-1; 
33 | 
34 |             while ($head < $tail) {
35 |                 $sum = -($nums[$head] + $nums[$tail]);
36 | 
37 |                 if($sum == $nums[$i]){
38 |                     $result[] = [$nums[$i], $nums[$head], $nums[$tail]];
39 | 
40 |                     while ($head < $tail && $nums[$head] == $nums[$head+1]) {
41 |                         $head++;
42 |                     }
43 | 
44 |                     while ($head < $tail && $nums[$tail] == $nums[$tail-1]) {
45 |                         $tail--;
46 |                     }
47 |                 }
48 | 
49 |                 $sum >= $nums[$i] ? $head++ : $tail--;
50 |             }
51 |         }
52 | 
53 |         return $result;
54 |     }
55 | }
56 | // @lc code=end


--------------------------------------------------------------------------------
/03th数组、链表、跳表/189.旋转数组.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=189 lang=php
 4 |  *
 5 |  * [189] 旋转数组
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer[] $nums
13 |      * @param Integer $k
14 |      * @return NULL
15 |      */
16 |     function rotate(&$nums, $k) {
17 | 
18 |         $k %= count($nums);
19 |         $this->reverse($nums, 0, count($nums)-1);
20 |         $this->reverse($nums, 0, $k-1);
21 |         $this->reverse($nums, $k, count($nums)-1);
22 | 
23 |         return $nums;
24 |     }
25 | 
26 |     function reverse(&$nums, $start, $end) {
27 | 
28 |         while ($start < $end) {
29 |             $temp = $nums[$start];
30 |             $nums[$start] = $nums[$end];
31 |             $nums[$end] = $temp;
32 |             $start++;$end--;
33 |         }
34 |     }
35 | }
36 | // @lc code=end
37 | 
38 | 


--------------------------------------------------------------------------------
/03th数组、链表、跳表/26.删除排序数组中的重复项.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=26 lang=php
 4 |  *
 5 |  * [26] 删除排序数组中的重复项
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer[] $nums
13 |      * @return Integer
14 |      */
15 |     function removeDuplicates(&$nums) {
16 | 
17 |         $p = 0;
18 |         $q = 1;
19 | 
20 |         while ($q < count($nums)) {
21 |             
22 |             if($nums[$p] != $nums[$q]){
23 |                 // 两个指针值不相等时，将q赋值给p+1，
24 |                 // p右移一位，q右移一位
25 |                 $nums[$p+1] = $nums[$q];
26 |                 $p++;
27 |             }
28 | 
29 |             // 两个指针值不相等时，q右移一位
30 |             $q++;
31 |         }
32 | 
33 |         return $p+1;
34 |     }
35 | }
36 | // @lc code=end


--------------------------------------------------------------------------------
/03th数组、链表、跳表/283.移动零.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=283 lang=php
 4 |  *
 5 |  * [283] 移动零
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer[] $nums
13 |      * @return NULL
14 |      */
15 |     function moveZeroes(&$nums) {
16 |         
17 |         for ($i=0; $i < count($nums); $i++) { 
18 |             if($nums[$i] == 0){
19 |                 unset($nums[$i]);
20 |                 $nums[] = 0;
21 |             }
22 |         }
23 |         return $nums;
24 |     }
25 | }
26 | // @lc code=end
27 | 
28 | 


--------------------------------------------------------------------------------
/03th数组、链表、跳表/70.爬楼梯.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=70 lang=php
 4 |  *
 5 |  * [70] 爬楼梯
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer $n
13 |      * @return Integer
14 |      */
15 |     function climbStairs($n) {
16 |         
17 |         if($n <= 2){
18 |             return $n;
19 |         }
20 | 
21 |         $f1 = 1;
22 |         $f2 = 2;
23 | 
24 |         for($i=3; $i<=$n; $i++){
25 |             $f3 = $f2 + $f1;
26 |             $f1 = $f2;
27 |             $f2 = $f3;
28 |         }
29 | 
30 |         return $f3;
31 |     }
32 | }
33 | // @lc code=end
34 | 
35 | 


--------------------------------------------------------------------------------
/03th数组、链表、跳表/README.md:
--------------------------------------------------------------------------------
1 | ### 专题知识点


--------------------------------------------------------------------------------
/04th栈、队列、优先队列、双端队列/155.最小栈.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=155 lang=php
 4 |  *
 5 |  * [155] 最小栈
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class MinStack {
10 |     private $data = array();
11 |     /**
12 |      * initialize your data structure here.
13 |      */
14 |     function __construct() {
15 | 
16 |     }
17 | 
18 |     /**
19 |      * @param Integer $x
20 |      * @return NULL
21 |      */
22 |     function push($x) {
23 |         array_push($this->data,$x);
24 |     }
25 | 
26 |     /**
27 |      * @return NULL
28 |      */
29 |     function pop() {
30 |         if(empty($this->data)){
31 |             return null;
32 |         }
33 |         return array_pop($this->data);
34 |     }
35 | 
36 |     /**
37 |      * @return Integer
38 |      */
39 |     function top() {
40 |         if(empty($this->data)){
41 |             return null;
42 |         }
43 | 
44 |         $temp = end($this->data);
45 |         reset($this->data);
46 | 
47 |         return $temp;
48 |     }
49 | 
50 |     /**
51 |      * @return Integer
52 |      */
53 |     function getMin() {
54 |         if(empty($this->data)){
55 |             return null;
56 |         }
57 |         return min($this->data);
58 |     }
59 | }
60 | 
61 | /**
62 |  * Your MinStack object will be instantiated and called as such:
63 |  * $obj = MinStack();
64 |  * $obj->push($x);
65 |  * $obj->pop();
66 |  * $ret_3 = $obj->top();
67 |  * $ret_4 = $obj->getMin();
68 |  */
69 | // @lc code=end
70 | 
71 | 


--------------------------------------------------------------------------------
/04th栈、队列、优先队列、双端队列/20.有效的括号.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=20 lang=php
 4 |  *
 5 |  * [20] 有效的括号
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param String $s
13 |      * @return Boolean
14 |      */
15 |     function isValid($s) {
16 |         
17 |         $arr = ["{"=>"}","("=>")","["=>"]","?"=>"?"];
18 |         $left_arr = ["{","(","["];
19 |         $stack = ["?"];
20 | 
21 |         for ($i=0; $i < strlen($s); $i++) { 
22 | 
23 |             if(in_array($s[$i], $left_arr)){
24 |                 $stack[] = $s[$i];
25 |             }elseif($arr[array_pop($stack)] != $s[$i]){
26 |                 return false;
27 |             }   
28 |         }
29 | 
30 |         return count($stack) == 1;
31 |     }
32 | }
33 | // @lc code=end
34 | 
35 | 


--------------------------------------------------------------------------------
/04th栈、队列、优先队列、双端队列/239.滑动窗口最大值(timeout).php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=239 lang=php
 4 |  *
 5 |  * [239] 滑动窗口最大值
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer[] $nums
13 |      * @param Integer $k
14 |      * @return Integer[]
15 |      */
16 |     function maxSlidingWindow($nums, $k) {
17 |         
18 |         $result = [];
19 |         for ($i = 0; $i < count($nums)-($k-1); $i++) { 
20 |             $temp_max = max(array_slice($nums, $i, $k));
21 |             $result[] = $temp_max;
22 |         }
23 | 
24 |         return $result;
25 |     }
26 | }
27 | // @lc code=end
28 | 
29 | 


--------------------------------------------------------------------------------
/04th栈、队列、优先队列、双端队列/42.接雨水.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=42 lang=php
 4 |  *
 5 |  * [42] 接雨水
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer[] $height
13 |      * @return Integer
14 |      */
15 |     function trap($height) {
16 |         
17 |         // 左右遍历求最高值累加面积，两个面积重合的部分 = 柱子面积 + 积水面积
18 |         $S1 = 0;
19 |         $S2 = 0;
20 | 
21 |         $left_max = 0;
22 |         $right_max = 0;
23 | 
24 |         $n = count($height);
25 | 
26 |         for($i = 0; $i < $n; $i++) {
27 |             if($height[$i] > $left_max){
28 |                 $left_max = $height[$i];
29 |             }
30 | 
31 |             if($height[$n-$i-1] > $right_max){
32 |                 $right_max = $height[$n-$i-1];
33 |             }
34 | 
35 |             $S1 += $left_max;
36 |             $S2 += $right_max;
37 |         }
38 | 
39 |         return $S1 + $S2 - $left_max*$n - array_sum($height)*1;
40 |     }
41 | }
42 | // @lc code=end
43 | 
44 | 


--------------------------------------------------------------------------------
/04th栈、队列、优先队列、双端队列/README.md:
--------------------------------------------------------------------------------
1 | ### 专题知识点


--------------------------------------------------------------------------------
/05th哈希表、映射、集合/242.有效的字母异位词.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=242 lang=php
 4 |  *
 5 |  * [242] 有效的字母异位词
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param String $s
13 |      * @param String $t
14 |      * @return Boolean
15 |      */
16 |     function isAnagram($s, $t) {
17 |         
18 |         $tmp = [];
19 |         for ($i=0; $i < strlen($s); $i++) { 
20 |             $tmp[$s[$i]] += 1;
21 |         }
22 | 
23 |         for ($i=0; $i < strlen($t); $i++) { 
24 | 
25 |             // 不存在即为假
26 |             if(!array_key_exists($t[$i], $tmp)){
27 |                 return false;
28 |             }
29 | 
30 |             $tmp[$t[$i]] -= 1;
31 | 
32 |             // 减到为负为假
33 |             if($tmp[$s[$i]] < 0){
34 |                 return false;
35 |             }
36 |         }
37 | 
38 |         foreach($tmp as $ss){
39 |             if($ss > 0){
40 |                 return false;
41 |             }
42 |         }
43 | 
44 |         return true;
45 |     }
46 | }
47 | 
48 | // Accepted
49 | // 34/34 cases passed (16 ms)
50 | // Your runtime beats 63.69 % of php submissions
51 | // Your memory usage beats 100 % of php submissions (14.9 MB)
52 | // @lc code=end
53 | 
54 | 


--------------------------------------------------------------------------------
/05th哈希表、映射、集合/242.有效的字母异位词_加速.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=242 lang=php
 4 |  *
 5 |  * [242] 有效的字母异位词
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param String $s
13 |      * @param String $t
14 |      * @return Boolean
15 |      */
16 |     function isAnagram($s, $t) {
17 |         
18 |         $s_tmp = str_split($s);
19 |         $t_tmp = str_split($t);
20 |         sort($s_tmp);
21 |         sort($t_tmp);
22 | 
23 |         return implode('', $s_tmp) === implode('', $t_tmp);
24 |     }
25 | }
26 | 
27 | // Accepted
28 | // 34/34 cases passed (68 ms)
29 | // Your runtime beats 13.1 % of php submissions
30 | // Your memory usage beats 100 % of php submissions (21.6 MB)
31 | // 效率更低。。。
32 | // @lc code=end
33 | 
34 | 


--------------------------------------------------------------------------------
/05th哈希表、映射、集合/49.字母异位词分组.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=49 lang=php
 4 |  *
 5 |  * [49] 字母异位词分组
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param String[] $strs
13 |      * @return String[][]
14 |      */
15 |     function groupAnagrams($strs) {
16 | 
17 |         $map = [];
18 | 
19 |         foreach ($strs as $str) {
20 |             $tmp = str_split($str);
21 |             sort($tmp);
22 |             $new_str = implode('', $tmp);
23 |             $result[$new_str][] = $str;
24 |         }
25 | 
26 |         return $result;
27 |     }
28 | }
29 | 
30 | // Accepted
31 | // 101/101 cases passed (24 ms)
32 | // Your runtime beats 100 % of php submissions
33 | // Your memory usage beats 100 % of php submissions (21.8 MB)
34 | // @lc code=end
35 | 
36 | 


--------------------------------------------------------------------------------
/05th哈希表、映射、集合/README.md:
--------------------------------------------------------------------------------
1 | ### 专题知识点


--------------------------------------------------------------------------------
/06th树、二叉树、二叉搜索树/06th最小的k个数.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // 输入整数数组 arr ，找出其中最小的 k 个数。
 4 | // 例如，输入4、5、1、6、2、7、3、8这8个数字，
 5 | // 则最小的4个数字是1、2、3、4。
 6 | 
 7 | // 输入：arr = [3,2,1], k = 2
 8 | // 输出：[1,2] 或者 [2,1]
 9 | 
10 | // 输入：arr = [0,1,2,1], k = 1
11 | // 输出：[0]
12 | 
13 | class Solution {
14 | 
15 |     /**
16 |      * @param Integer[] $arr
17 |      * @param Integer $k
18 |      * @return Integer[]
19 |      */
20 |     function getLeastNumbers($arr, $k) {
21 | 
22 |         sort($arr);
23 |         return array_slice($arr, 0, $k);
24 |     }
25 | 
26 | }
27 | 
28 | // 效率 72 ms	17.3 MB	Php


--------------------------------------------------------------------------------
/06th树、二叉树、二叉搜索树/144.二叉树的前序遍历_迭代.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=144 lang=php
 4 |  *
 5 |  * [144] 二叉树的前序遍历
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | /**
10 |  * Definition for a binary tree node.
11 |  * class TreeNode {
12 |  *     public $val = null;
13 |  *     public $left = null;
14 |  *     public $right = null;
15 |  *     function __construct($value) { $this->val = $value; }
16 |  * }
17 |  */
18 | class Solution {
19 | 
20 |     /**
21 |      * @param TreeNode $root
22 |      * @return Integer[]
23 |      */
24 |     function preorderTraversal($root) {
25 | 
26 |         $white = 0;
27 |         $gray = 1;
28 |         $stack[] = [$white, $root];
29 |         $res = [];
30 | 
31 |         while (!empty($stack)) {
32 |             $cur = array_pop($stack);
33 |             
34 |             if($cur[1] == null) continue;
35 |             
36 |             if($cur[0] == $white){
37 |                 $stack[] = [$white, $cur[1]->right];
38 |                 $stack[] = [$white, $cur[1]->left];
39 |                 $stack[] = [$gray, $cur[1]];
40 |             }else{
41 |                 $res[] = $cur[1]->val;
42 |             }
43 |         }
44 | 
45 |         return $res;
46 |     }
47 | }
48 | 
49 | // Accepted
50 | // 68/68 cases passed (4 ms)
51 | // Your runtime beats 95.18 % of php submissions
52 | // Your memory usage beats 100 % of php submissions (14.6 MB)
53 | // @lc code=end
54 | 
55 | 


--------------------------------------------------------------------------------
/06th树、二叉树、二叉搜索树/264.丑数-ii.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=264 lang=php
 4 |  *
 5 |  * [264] 丑数 II
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer $n
13 |      * @return Integer
14 |      */
15 |     function nthUglyNumber($n) {
16 | 
17 |         $dp[0] = 1;
18 |         $a = 0;
19 |         $b = 0;
20 |         $c = 0;
21 | 
22 |         for($i=1; $i<=$n; $i++) {
23 |             
24 |             $dp[$i] = min($dp[$a]*2, $dp[$b]*3, $dp[$c]*5);
25 | 
26 |             if($dp[$i] == $dp[$a]*2) $a++; 
27 |             if($dp[$i] == $dp[$b]*3) $b++; 
28 |             if($dp[$i] == $dp[$c]*5) $c++; 
29 |         }
30 | 
31 |         return $dp[$n-1];
32 |     }
33 | }
34 | // @lc code=end
35 | 
36 | 


--------------------------------------------------------------------------------
/06th树、二叉树、二叉搜索树/347.前-k-个高频元素.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=347 lang=php
 4 |  *
 5 |  * [347] 前 K 个高频元素
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer[] $nums
13 |      * @param Integer $k
14 |      * @return Integer[]
15 |      */
16 |     function topKFrequent($nums, $k) {
17 | 
18 |         $res = [];
19 |         foreach ($nums as $val) {
20 |             $res[$val] = isset($res[$val]) ? $res[$val]+1 : 1; 
21 |         }
22 | 
23 |         arsort($res);
24 | 
25 |         $new_res = [];
26 |         $i = 0;
27 |         foreach ($res as $key => $val) {
28 | 
29 |             $new_res[] = $key;
30 |             if(++$i == $k) break;
31 |         }
32 | 
33 |         return $new_res;
34 |     }
35 | }
36 | // @lc code=end
37 | 
38 | 


--------------------------------------------------------------------------------
/06th树、二叉树、二叉搜索树/589.n叉树的前序遍历.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=589 lang=php
 4 |  *
 5 |  * [589] N叉树的前序遍历
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | /**
10 |  * Definition for a Node.
11 |  * class Node {
12 |  *     public $val = null;
13 |  *     public $children = null;
14 |  *     function __construct($val = 0) {
15 |  *         $this->val = $val;
16 |  *         $this->children = array();
17 |  *     }
18 |  * }
19 |  */
20 | 
21 | class Solution {
22 |     /**
23 |      * @param Node $root
24 |      * @return integer[]
25 |      */
26 |     function preorder($root) {
27 |         
28 |         $res = [$root->val];
29 |         $this->backorder($root, $res);
30 |         return $res;
31 |     }
32 | 
33 |     function backorder($root, &$res) {
34 | 
35 |         if($root == null) return;
36 | 
37 |         foreach ($root->children as $child) {
38 |             $res[] = $child->val;
39 |             $this->backorder($child, $res);
40 |         }
41 |     }
42 | }
43 | 
44 | // Accepted
45 | // 37/37 cases passed (16 ms)
46 | // Your runtime beats 73.61 % of php submissions
47 | // Your memory usage beats 100 % of php submissions (18.7 MB)
48 | // @lc code=end
49 | 
50 | 


--------------------------------------------------------------------------------
/06th树、二叉树、二叉搜索树/590.n叉树的后序遍历.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=590 lang=php
 4 |  *
 5 |  * [590] N叉树的后序遍历
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | /**
10 |  * Definition for a Node.
11 |  * class Node {
12 |  *     public $val = null;
13 |  *     public $children = null;
14 |  *     function __construct($val = 0) {
15 |  *         $this->val = $val;
16 |  *         $this->children = array();
17 |  *     }
18 |  * }
19 |  */
20 | 
21 | class Solution {
22 |     /**
23 |      * @param Node $root
24 |      * @return integer[]
25 |      */
26 |     function postorder($root) {
27 | 
28 |         $res = [];
29 |         $this->backorder($root, $res);
30 |         $res[] = $root->val;
31 |         return $res;
32 |     }
33 | 
34 |     function backorder($root, &$res) {
35 | 
36 |         if($root == null) return;
37 | 
38 |         foreach ($root->children as $child) {
39 |             $this->backorder($child, $res);
40 |             $res[] = $child->val;
41 |         }
42 |     }
43 | }
44 | 
45 | // Accepted
46 | // 37/37 cases passed (16 ms)
47 | // Your runtime beats 71.43 % of php submissions
48 | // Your memory usage beats 100 % of php submissions (18.6 MB)
49 | // @lc code=end
50 | 
51 | 


--------------------------------------------------------------------------------
/06th树、二叉树、二叉搜索树/590.n叉树的后序遍历_迭代.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=590 lang=php
 4 |  *
 5 |  * [590] N叉树的后序遍历
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | /**
10 |  * Definition for a Node.
11 |  * class Node {
12 |  *     public $val = null;
13 |  *     public $children = null;
14 |  *     function __construct($val = 0) {
15 |  *         $this->val = $val;
16 |  *         $this->children = array();
17 |  *     }
18 |  * }
19 |  */
20 | 
21 | class Solution {
22 |     /**
23 |      * @param Node $root
24 |      * @return integer[]
25 |      */
26 |     function postorder($root) {
27 | 
28 |         // 利用后序遍历与前序遍历结果类似，顺序入栈子节点v1 v2 v3，出栈的时候v3 v2 v1
29 |         // 最后结果反转还是保持 v1 v2 v3
30 | 
31 |         $res = [];
32 |         $stack = [$root];
33 | 
34 |         while (!empty($stack)) {
35 |             $root = array_pop($stack);
36 | 
37 |             if($root != null){
38 |                 $res[] = $root->val;
39 |             }
40 | 
41 |             foreach ($root->children as $child) {
42 |                 $stack[] = $child;
43 |             }
44 |         }
45 | 
46 |         return array_reverse($res);
47 |     }
48 | }
49 | 
50 | // Accepted
51 | // 37/37 cases passed (12 ms)
52 | // Your runtime beats 92.86 % of php submissions
53 | // Your memory usage beats 100 % of php submissions (18.6 MB)
54 | // @lc code=end
55 | 
56 | 


--------------------------------------------------------------------------------
/06th树、二叉树、二叉搜索树/94.二叉树的中序遍历.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=94 lang=php
 4 |  *
 5 |  * [94] 二叉树的中序遍历
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | /**
10 |  * Definition for a binary tree node.
11 |  * class TreeNode {
12 |  *     public $val = null;
13 |  *     public $left = null;
14 |  *     public $right = null;
15 |  *     function __construct($value) { $this->val = $value; }
16 |  * }
17 |  */
18 | class Solution {
19 | 
20 |     /**
21 |      * @param TreeNode $root
22 |      * @return Integer[]
23 |      */
24 |     function inorderTraversal($root) {
25 |         
26 |         $result = [];
27 |         $this->inorder($root, $result);
28 | 
29 |         return $result;
30 | 
31 |     }
32 | 
33 |     function inorder($root, &$result){
34 | 
35 |         if($root->left != null){
36 |             $this->inorder($root->left, $result);
37 |         }
38 | 
39 |         $result[] = $root->val;
40 | 
41 |         if($root->right != null){
42 |             $this->inorder($root->right, $result);
43 |         }
44 |     }
45 | }
46 | 
47 | // Accepted
48 | // 68/68 cases passed (8 ms)
49 | // Your runtime beats 57.14 % of php submissions
50 | // Your memory usage beats 100 % of php submissions (14.8 MB)
51 | // @lc code=end
52 | 
53 | 


--------------------------------------------------------------------------------
/06th树、二叉树、二叉搜索树/94.二叉树的中序遍历_迭代.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=94 lang=php
 4 |  *
 5 |  * [94] 二叉树的中序遍历
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | /**
10 |  * Definition for a binary tree node.
11 |  * class TreeNode {
12 |  *     public $val = null;
13 |  *     public $left = null;
14 |  *     public $right = null;
15 |  *     function __construct($value) { $this->val = $value; }
16 |  * }
17 |  */
18 | class Solution {
19 | 
20 |     /**
21 |      * @param TreeNode $root
22 |      * @return Integer[]
23 |      */
24 |     function inorderTraversal($root) {
25 |         
26 |         $white = 0;
27 |         $gray = 1;
28 |         $stack[] = [$white, $root];
29 |         $res = [];
30 | 
31 |         while (!empty($stack)) {
32 |             $cur = array_pop($stack);
33 |             
34 |             if($cur[1] == null) continue;
35 |             
36 |             if($cur[0] == 0){
37 |                 $stack[] = [$white, $cur[1]->right];
38 |                 $stack[] = [$gray, $cur[1]];
39 |                 $stack[] = [$white, $cur[1]->left];
40 |             }else{
41 |                 $res[] = $cur[1]->val;
42 |             }
43 |         }
44 | 
45 |         return $res;
46 |     }
47 | }
48 | 
49 | // Accepted
50 | // 68/68 cases passed (4 ms)
51 | // Your runtime beats 90.59 % of php submissions
52 | // Your memory usage beats 100 % of php submissions (14.9 MB)
53 | // @lc code=end
54 | 
55 | 


--------------------------------------------------------------------------------
/06th树、二叉树、二叉搜索树/README.md:
--------------------------------------------------------------------------------
1 | ### 专题知识点


--------------------------------------------------------------------------------
/07th泛型递归、树的递归/104.二叉树的最大深度.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=104 lang=php
 4 |  *
 5 |  * [104] 二叉树的最大深度
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | /**
10 |  * Definition for a binary tree node.
11 |  * class TreeNode {
12 |  *     public $val = null;
13 |  *     public $left = null;
14 |  *     public $right = null;
15 |  *     function __construct($value) { $this->val = $value; }
16 |  * }
17 |  */
18 | class Solution {
19 | 
20 |     /**
21 |      * @param TreeNode $root
22 |      * @return Integer
23 |      */
24 |     function maxDepth($root) {
25 |         
26 |         if($root == null) {
27 |             return 0;
28 |         }
29 | 
30 |         $left = $this->maxDepth($root->left);
31 |         $right = $this->maxDepth($root->right);
32 | 
33 |         return max($left, $right) + 1;
34 |     }
35 | }
36 | 
37 | // Accepted
38 | // 39/39 cases passed (16 ms)
39 | // Your runtime beats 39.45 % of php submissions
40 | // Your memory usage beats 100 % of php submissions (16.9 MB)
41 | // @lc code=end
42 | 
43 | 


--------------------------------------------------------------------------------
/07th泛型递归、树的递归/111.二叉树的最小深度.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=111 lang=php
 4 |  *
 5 |  * [111] 二叉树的最小深度
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | /**
10 |  * Definition for a binary tree node.
11 |  * class TreeNode {
12 |  *     public $val = null;
13 |  *     public $left = null;
14 |  *     public $right = null;
15 |  *     function __construct($value) { $this->val = $value; }
16 |  * }
17 |  */
18 | class Solution {
19 | 
20 |     /**
21 |      * @param TreeNode $root
22 |      * @return Integer
23 |      */
24 |     function minDepth($root) {
25 |         
26 |         if($root == null) return 0;
27 | 
28 |         if($root->left == null && $root->right == null) return 1;
29 | 
30 |         $min_depth  = PHP_INT_MAX;
31 |         if($root->left != null) {
32 |             $min_depth = min($this->minDepth($root->left), $min_depth);
33 |         }
34 |         
35 |         if($root->right != null) {
36 |             $min_depth = min($this->minDepth($root->right), $min_depth);
37 |         }
38 | 
39 |         return $min_depth + 1;
40 |     }
41 | }
42 | 
43 | // Accepted
44 | // 41/41 cases passed (12 ms)
45 | // Your runtime beats 84.21 % of php submissions
46 | // Your memory usage beats 100 % of php submissions (17.2 MB)
47 | // @lc code=end
48 | 
49 | 


--------------------------------------------------------------------------------
/07th泛型递归、树的递归/22.括号生成.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=22 lang=php
 4 |  *
 5 |  * [22] 括号生成
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer $n
13 |      * @return String[]
14 |      */
15 |     function generateParenthesis($n) {
16 | 
17 |         $res = [];
18 | 
19 |         $this->generate(0, 0, $n, "", $res);
20 | 
21 |         return $res;
22 |     }
23 | 
24 |     // 递归生成括号
25 |     function generate($left, $right, $n, $s, &$res) {
26 | 
27 |         // 每次终止条件
28 |         if($left == $n && $right == $n) {
29 |             $res[] = $s;
30 |         }
31 | 
32 |         // 左括号还没用完
33 |         if($left < $n) {
34 |             $this->generate($left+1, $right, $n, $s."(", $res);
35 |         }
36 |         
37 |         // 右括号小于左口号数量时，+1
38 |         if($right < $left) {
39 |             $this->generate($left, $right+1, $n, $s.")", $res);
40 |         }
41 |     }
42 | }
43 | 
44 | // Accepted
45 | // 8/8 cases passed (8 ms)
46 | // Your runtime beats 79.7 % of php submissions
47 | // Your memory usage beats 100 % of php submissions (15.7 MB)
48 | // @lc code=end
49 | 
50 | 


--------------------------------------------------------------------------------
/07th泛型递归、树的递归/226.翻转二叉树.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=226 lang=php
 4 |  *
 5 |  * [226] 翻转二叉树
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | /**
10 |  * Definition for a binary tree node.
11 |  * class TreeNode {
12 |  *     public $val = null;
13 |  *     public $left = null;
14 |  *     public $right = null;
15 |  *     function __construct($value) { $this->val = $value; }
16 |  * }
17 |  */
18 | class Solution {
19 | 
20 |     /**
21 |      * @param TreeNode $root
22 |      * @return TreeNode
23 |      */
24 |     function invertTree($root) {
25 | 
26 |         if($root == null) return null;
27 | 
28 |         $right = $this->invertTree($root->right);
29 |         $left = $this->invertTree($root->left);
30 | 
31 |         $root->right = $left;
32 |         $root->left = $right;
33 | 
34 |         return $root;
35 |     }
36 | }
37 | 
38 | // Accepted
39 | // 68/68 cases passed (4 ms)
40 | // Your runtime beats 91.06 % of php submissions
41 | // Your memory usage beats 100 % of php submissions (15 MB)
42 | // @lc code=end
43 | 
44 | 


--------------------------------------------------------------------------------
/07th泛型递归、树的递归/236.二叉树的最近公共祖先.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=236 lang=php
 4 |  *
 5 |  * [236] 二叉树的最近公共祖先
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | /**
10 |  * Definition for a binary tree node.
11 |  * class TreeNode {
12 |  *     public $val = null;
13 |  *     public $left = null;
14 |  *     public $right = null;
15 |  *     function __construct($value) { $this->val = $value; }
16 |  * }
17 |  */
18 | 
19 | class Solution {
20 |     /**
21 |      * @param TreeNode $root
22 |      * @param TreeNode $p
23 |      * @param TreeNode $q
24 |      * @return TreeNode
25 |      */
26 |     function lowestCommonAncestor($root, $p, $q) {
27 |         
28 |         if($root == null || $root==$p || $root==$q) return $root;
29 | 
30 |         $left = $this->lowestCommonAncestor($root->left, $p, $q);
31 |         $right = $this->lowestCommonAncestor($root->right, $p, $q);
32 | 
33 |         // 左右非空，则返回当前节点
34 |         if($left && $right) return $root;
35 | 
36 |         // 从是否在一颗子树角度想就很好理解，在不同子树时就返回root就好，当p为q的祖先节点时，搜索一侧子树只能返回p，
37 |         // 这时候搜另一边是搜不到q的，但节点又一定在树中，所以一定是p是q的祖先的情况，直接返回p即为答案
38 |         return $left ? $left : $right;
39 |     }
40 | }
41 | 
42 | // Accepted
43 | // 31/31 cases passed (32 ms)
44 | // Your runtime beats 59.68 % of php submissions
45 | // Your memory usage beats 100 % of php submissions (21.4 MB)
46 | // @lc code=end
47 | 
48 | 


--------------------------------------------------------------------------------
/07th泛型递归、树的递归/46.全排列.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=46 lang=php
 4 |  *
 5 |  * [46] 全排列
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 |     
11 |     /**
12 |      * @param Integer[] $nums
13 |      * @return Integer[][]
14 |      */
15 |     function permute($nums) {
16 |         
17 |         $res = [];
18 |         $visited = [];
19 |         $tmp = [];
20 | 
21 |         $this->backtrack($res, $nums, $visited, $tmp);
22 |         return $res;
23 |     }
24 | 
25 |     function backtrack(&$res, $nums, &$visited, &$tmp) {
26 | 
27 |         if(count($tmp) == count($nums)) {
28 |             $res[] = $tmp;
29 |             return true;
30 |         }
31 | 
32 |         for ($i=0; $i < count($nums); $i++) { 
33 |             // 不能重复
34 |             if($visited[$i] == 1) continue;
35 |             $visited[$i]  = 1;
36 |             $tmp[] = $nums[$i];
37 |             $this->backtrack($res, $nums, $visited, $tmp);
38 |             $visited[$i]  = 0;
39 |             array_pop($tmp);
40 |         }
41 |     }
42 | }
43 | 
44 | // Accepted
45 | // 25/25 cases passed (4 ms)
46 | // Your runtime beats 98.8 % of php submissions
47 | // Your memory usage beats 100 % of php submissions (15.4 MB)
48 | // @lc code=end
49 | 
50 | 


--------------------------------------------------------------------------------
/07th泛型递归、树的递归/47.全排列-ii.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=47 lang=php
 4 |  *
 5 |  * [47] 全排列 II
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     protected $in;
12 |     /**
13 |      * @param Integer[] $nums
14 |      * @return Integer[][]
15 |      */
16 |     function permuteUnique($nums) {
17 |         
18 |         $res = [];
19 |         $visited = [];
20 |         $tmp = [];
21 |         $this->in = [];
22 | 
23 |         $this->backtrack($res, $nums, $visited, $tmp);
24 |         return $res;
25 |     }
26 | 
27 |     function backtrack(&$res, $nums, &$visited, &$tmp) {
28 | 
29 |         if(count($tmp) == count($nums)) {
30 | 
31 |             $tmp_in = implode('-', $tmp);
32 |             if(!in_array($tmp_in, $this->in)){
33 |                 $res[] = $tmp;
34 |                 $this->in[] = $tmp_in;
35 |             }
36 |             return true;
37 |         }
38 | 
39 |         for ($i=0; $i < count($nums); $i++) { 
40 |             // 不能重复
41 |             if($visited[$i] == 1) continue;
42 |             $visited[$i]  = 1;
43 |             $tmp[] = $nums[$i];
44 |             $this->backtrack($res, $nums, $visited, $tmp);
45 |             $visited[$i]  = 0;
46 |             array_pop($tmp);
47 |         }
48 |     }
49 | }
50 | 
51 | // 直接模仿了46全排列的解法，低效率的剪枝
52 | // Accepted
53 | // 30/30 cases passed (1040 ms)
54 | // Your runtime beats 5.08 % of php submissions
55 | // Your memory usage beats 100 % of php submissions (15.2 MB)
56 | // @lc code=end
57 | 
58 | 


--------------------------------------------------------------------------------
/07th泛型递归、树的递归/47.全排列-ii_加速.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=47 lang=php
 4 |  *
 5 |  * [47] 全排列 II
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer[] $nums
13 |      * @return Integer[][]
14 |      */
15 |     function permuteUnique($nums) {
16 |         
17 |         $res = [];
18 |         $visited = [];
19 |         $tmp = [];
20 |         sort($nums);
21 | 
22 |         $this->backtrack($res, $nums, $visited, $tmp);
23 |         return $res;
24 |     }
25 | 
26 |     function backtrack(&$res, $nums, &$visited, &$tmp) {
27 | 
28 |         if(count($tmp) == count($nums)) {
29 |             $res[] = $tmp;
30 |             return true;
31 |         }
32 | 
33 |         for ($i=0; $i < count($nums); $i++) { 
34 |             // 不能重复
35 |             if($visited[$i] == 1) continue;
36 | 
37 |             // 剪枝条件：$i > 0 是为了保证 $nums[$i - 1] 有意义
38 |             // 写 !$visited[$i - 1] 是因为 $nums[$i - 1] 在深度优先遍历的过程中刚刚被撤销选择
39 |             if ($i > 0 && $nums[$i] == $nums[$i - 1] && !$visited[$i - 1]) continue;
40 | 
41 |             $visited[$i]  = 1;
42 |             $tmp[] = $nums[$i];
43 | 
44 |             $this->backtrack($res, $nums, $visited, $tmp);
45 | 
46 |             $visited[$i]  = 0;
47 |             array_pop($tmp);
48 |         }
49 |     }
50 | }
51 | 
52 | // Accepted
53 | // 30/30 cases passed (28 ms)
54 | // Your runtime beats 50.85 % of php submissions
55 | // Your memory usage beats 100 % of php submissions (15.5 MB)
56 | // @lc code=end
57 | 
58 | 


--------------------------------------------------------------------------------
/07th泛型递归、树的递归/70.爬楼梯_递归.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=70 lang=php
 4 |  *
 5 |  * [70] 爬楼梯
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     protected $res = 0;
12 | 
13 |     /**
14 |      * @param Integer $n
15 |      * @return Integer
16 |      */
17 |     function climbStairs($n) {
18 |         
19 |         if($n <= 2){
20 |             return $n;
21 |         }
22 | 
23 |         return $this->climbStairs($n-1) + $this->climbStairs($n-2);
24 |     }
25 | }
26 | 
27 | // Time Limit Exceeded 超时
28 | // 21/45 cases passed (N/A)
29 | // @lc code=end
30 | 
31 | 


--------------------------------------------------------------------------------
/07th泛型递归、树的递归/77.组合.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=77 lang=php
 4 |  *
 5 |  * [77] 组合
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     protected $n; 
12 |     protected $k; 
13 | 
14 |     /**
15 |      * @param Integer $n
16 |      * @param Integer $k
17 |      * @return Integer[][]
18 |      */
19 |     function combine($n, $k) {
20 | 
21 |         $this->n = $n;
22 |         $this->k = $k;
23 |         $res = [];
24 |         $tmp = [];
25 |         $this->helper(1, $tmp, $res);
26 |         return $res;
27 |     }
28 | 
29 |     function helper($start, &$tmp, &$res) {
30 | 
31 |         if(count($tmp) == $this->k){
32 |             $res[] = $tmp;
33 |             return true;
34 |         }
35 | 
36 |         // 从 start 到 n
37 |         for ($i = $start; $i <= $this->n; $i++) { 
38 |             $tmp[] = $i;
39 |             $this->helper($i + 1, $tmp, $res);
40 |             array_pop($tmp);
41 |         }
42 |     }
43 | }
44 | 
45 | // Accepted
46 | // 27/27 cases passed (144 ms)
47 | // Your runtime beats 50.98 % of php submissions
48 | // Your memory usage beats 100 % of php submissions (19.5 MB)
49 | // @lc code=end
50 | 
51 | 


--------------------------------------------------------------------------------
/07th泛型递归、树的递归/77.组合_加速.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=77 lang=php
 4 |  *
 5 |  * [77] 组合
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     protected $n; 
12 |     protected $k; 
13 | 
14 |     /**
15 |      * @param Integer $n
16 |      * @param Integer $k
17 |      * @return Integer[][]
18 |      */
19 |     function combine($n, $k) {
20 | 
21 |         $this->n = $n;
22 |         $this->k = $k;
23 |         $res = [];
24 |         $tmp = [];
25 |         $this->helper(1, $tmp, $res);
26 |         return $res;
27 |     }
28 | 
29 |     function helper($start, &$tmp, &$res) {
30 | 
31 |         if(count($tmp) == $this->k){
32 |             $res[] = $tmp;
33 |             return true;
34 |         }
35 | 
36 |         for ($i=$start; $i <= ($this->n - ($this->k - count($tmp)) + 1); $i++) { 
37 |             $tmp[] = $i;
38 |             $this->helper($i + 1, $tmp, $res);
39 |             array_pop($tmp);
40 |         }
41 |     }
42 | }
43 | 
44 | // Accepted
45 | // 27/27 cases passed (32 ms)
46 | // Your runtime beats 80.39 % of php submissions
47 | // Your memory usage beats 100 % of php submissions (19.4 MB)
48 | // @lc code=end
49 | 
50 | 


--------------------------------------------------------------------------------
/07th泛型递归、树的递归/98.验证二叉搜索树.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=98 lang=php
 4 |  *
 5 |  * [98] 验证二叉搜索树
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | /**
10 |  * Definition for a binary tree node.
11 |  * class TreeNode {
12 |  *     public $val = null;
13 |  *     public $left = null;
14 |  *     public $right = null;
15 |  *     function __construct($value) { $this->val = $value; }
16 |  * }
17 |  */
18 | class Solution {
19 | 
20 |     /**
21 |      * @param TreeNode $root
22 |      * @return Boolean
23 |      */
24 |     function isValidBST($root) {
25 | 
26 |         if($root == null) {
27 |             return true;
28 |         }
29 | 
30 |         // 初始标志
31 |         $flag = true;
32 |         // 初始父节点值
33 |         $last = PHP_INT_MIN;
34 |         return $this->helper($root, $flag, $last);
35 |     }
36 | 
37 |     function helper($root, &$flag, &$last) {
38 | 
39 |         if($flag && $root->left) {
40 |             $this->helper($root->left, $flag, $last);
41 |         }
42 | 
43 |         // 遍历完左子树，得到上一个节点
44 |         if($root->val <= $last){
45 |             $flag = false;
46 |         }
47 | 
48 |         // 当前符合条件，更新last
49 |         $last = $root->val;
50 | 
51 |         // 遍历右子树是否符合条件
52 |         if($flag && $root->right) {
53 |             $this->helper($root->right, $flag, $last);
54 |         }
55 | 
56 |         return $flag;
57 |     }
58 | }
59 | 
60 | // Accepted
61 | // 75/75 cases passed (16 ms)
62 | // Your runtime beats 65.8 % of php submissions
63 | // Your memory usage beats 100 % of php submissions (17.7 MB)
64 | // @lc code=end
65 | 
66 | 


--------------------------------------------------------------------------------
/07th泛型递归、树的递归/README.md:
--------------------------------------------------------------------------------
1 | ### 专题知识点


--------------------------------------------------------------------------------
/08th分治、回溯/17.电话号码的字母组合.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=17 lang=php
 4 |  *
 5 |  * [17] 电话号码的字母组合
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param String $digits
13 |      * @return String[]
14 |      */
15 |     function letterCombinations($digits) {
16 | 
17 |         if($digits == null) {
18 |             return [];
19 |         }
20 | 
21 |         $map = [
22 |             '2' => 'abc',
23 |             '3' => 'def',
24 |             '4' => 'ghi',
25 |             '5' => 'jkl',
26 |             '6' => 'mno',
27 |             '7' => 'pqrs',
28 |             '8' => 'tuv',
29 |             '9' => 'wxyz'
30 |         ];
31 | 
32 |         $res = [];
33 |         $this->helper("", $digits, 0, $res, $map);
34 | 
35 |         return $res;
36 |     }
37 | 
38 |     function helper($s, $digits, $i, &$res, $map) {
39 | 
40 |         if(strlen($s) == strlen($digits)) {
41 |             $res[] = $s;
42 |             return true;
43 |         }
44 | 
45 |         $letters = $map[$digits[$i]];
46 |         for ($j=0; $j < strlen($letters); $j++) { 
47 |             
48 |             $this->helper($s.$letters[$j], $digits, $i+1, $res, $map);
49 |         }
50 |     }
51 | }
52 | 
53 | // Accepted
54 | // 25/25 cases passed (4 ms)
55 | // Your runtime beats 91.45 % of php submissions
56 | // Your memory usage beats 100 % of php submissions (14.8 MB)
57 | // @lc code=end
58 | 
59 | 


--------------------------------------------------------------------------------
/08th分治、回溯/50.pow-x-n.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=50 lang=php
 4 |  *
 5 |  * [50] Pow(x, n)
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Float $x
13 |      * @param Integer $n
14 |      * @return Float
15 |      */
16 |     function myPow($x, $n) {
17 |         
18 |         if($x == 0) return 0;
19 |         
20 |         if($n < 0) {
21 |             $x = 1 / $x;
22 |             $n = - $n;
23 |         }
24 | 
25 |         return $this->fastPow($x, $n);
26 |     }
27 | 
28 |     function fastPow($x, $n) {
29 | 
30 |         if($n == 0) {
31 |             return 1.0;
32 |         }elseif($n == 1){
33 |             return $x;
34 |         }
35 | 
36 |         $half = $this->fastPow($x, $n/2);
37 | 
38 |         return $n%2 == 0 ? $half * $half : $half * $half * $x;
39 |     }
40 | }
41 | 
42 | // Accepted
43 | // 304/304 cases passed (16 ms)
44 | // Your runtime beats 25.65 % of php submissions
45 | // Your memory usage beats 100 % of php submissions (15.4 MB)
46 | // @lc code=end
47 | 
48 | 


--------------------------------------------------------------------------------
/08th分治、回溯/78.子集_回溯.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=78 lang=php
 4 |  *
 5 |  * [78] 子集
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer[] $nums
13 |      * @return Integer[][]
14 |      */
15 |     function subsets($nums) {
16 | 
17 |         $res = [];
18 |         for ($i=0; $i <= count($nums); $i++) { 
19 | 
20 |             // i 控制每次终结长度
21 |             $this->backtrack(0, $i, [], $nums, $res);
22 |         }
23 | 
24 |         return $res;
25 |     }
26 | 
27 |     function backtrack($first, $k, $cur, $nums, &$res) {
28 | 
29 |         if(count($cur) == $k) {
30 |             $res[] = $cur;
31 |             return;
32 |         }
33 | 
34 |         for ($i=$first; $i < count($nums); $i++) { 
35 | 
36 |             $cur[] = $nums[$i];
37 | 
38 |             $this->backtrack($i + 1, $k, $cur, $nums, $res);
39 | 
40 |             array_pop($cur);
41 |         }
42 | 
43 |     }
44 | }
45 | 
46 | // Accepted
47 | // 10/10 cases passed (4 ms)
48 | // Your runtime beats 100 % of php submissions
49 | // Your memory usage beats 100 % of php submissions (15.4 MB)
50 | // @lc code=end
51 | 
52 | 


--------------------------------------------------------------------------------
/08th分治、回溯/78.子集_递归.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=78 lang=php
 4 |  *
 5 |  * [78] 子集
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer[] $nums
13 |      * @return Integer[][]
14 |      */
15 |     function subsets($nums) {
16 |         
17 |         // 从空集合开始
18 |         $res = [
19 |             [],
20 |         ];
21 | 
22 |         foreach ($nums as $val) {
23 | 
24 |             $sub = [];
25 |             // 将已有结果取出加入新数
26 |             foreach ($res as $val2) {
27 |                 $val2[] = $val;
28 |                 $sub[] = $val2;
29 |             }
30 | 
31 |             // 把所有新结果推入结果集
32 |             foreach ($sub as $val3) {
33 |                 $res[] = $val3;
34 |             }
35 |         }
36 | 
37 |         return $res;
38 |     }
39 | }
40 | 
41 | // Accepted
42 | // 10/10 cases passed (4 ms)
43 | // Your runtime beats 100 % of php submissions
44 | // Your memory usage beats 100 % of php submissions (15.2 MB)
45 | // @lc code=end
46 | 
47 | 


--------------------------------------------------------------------------------
/08th分治、回溯/README.md:
--------------------------------------------------------------------------------
1 | ### 专题知识点


--------------------------------------------------------------------------------
/09th深度优先搜索和广度优先搜索/102.二叉树的层序遍历_BFS.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=102 lang=php
 4 |  *
 5 |  * [102] 二叉树的层序遍历
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | /**
10 |  * Definition for a binary tree node.
11 |  * class TreeNode {
12 |  *     public $val = null;
13 |  *     public $left = null;
14 |  *     public $right = null;
15 |  *     function __construct($value) { $this->val = $value; }
16 |  * }
17 |  */
18 | class Solution {
19 | 
20 |     /**
21 |      * @param TreeNode $root
22 |      * @return Integer[][]
23 |      */
24 |     function levelOrder($root) {
25 |         
26 |         if($root == null) return [];
27 | 
28 |         $res = [];
29 |         $queue = [];
30 |         array_push($queue, $root);
31 | 
32 |         while ($n = count($queue)) {
33 |             $tmp = [];
34 | 
35 |             for ($i=0; $i < $n; $i++) { 
36 |                 // 先进先出
37 |                 $cur = array_shift($queue);
38 |                 $tmp[] = $cur->val;
39 | 
40 |                 if($cur->left != null) array_push($queue, $cur->left);
41 |                 if($cur->right != null) array_push($queue, $cur->right);
42 |             }
43 |             
44 |             $res[] = $tmp;
45 |         }
46 |         
47 |         return $res;
48 |     }
49 | }
50 | 
51 | // Accepted
52 | // 34/34 cases passed (8 ms)
53 | // Your runtime beats 87.32 % of php submissions
54 | // Your memory usage beats 100 % of php submissions (15.5 MB)
55 | // @lc code=end
56 | 
57 | 


--------------------------------------------------------------------------------
/09th深度优先搜索和广度优先搜索/127.单词接龙_超时.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=127 lang=php
 4 |  *
 5 |  * [127] 单词接龙
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param String $beginWord
13 |      * @param String $endWord
14 |      * @param String[] $wordList
15 |      * @return Integer
16 |      */
17 |     function ladderLength($beginWord, $endWord, $wordList) {
18 |         
19 |         // 初始化
20 |         $queue = [
21 |             [$beginWord, 1],
22 |         ];
23 |         $visited = [$beginWord];
24 |         $gen = 'abcdefghijklmnopqrstuvwxyz'; 
25 | 
26 |         while($n = count($queue)) {
27 |             $cur = array_shift($queue);
28 |             $word = $cur[0];
29 |             $step = $cur[1];
30 | 
31 |             if($word == $endWord){
32 |                 return $step;
33 |             }
34 | 
35 |             for ($i=0; $i < strlen($word); $i++) { 
36 | 
37 |                 $char = $word[$i];
38 | 
39 |                 for ($j=0; $j < 26; $j++) { 
40 | 
41 |                     // 相同跳过
42 |                     if($char == $gen[$j]) continue;
43 | 
44 |                     $word[$i] = $gen[$j];
45 | 
46 |                     if(in_array($word, $wordList)){
47 | 
48 |                         if(!in_array($word, $visited)){
49 |                             
50 |                             array_push($queue, [$word, $step + 1]);
51 |                             $visited[] = $word;
52 |                         }
53 |                     }
54 |                 }
55 | 
56 |                 // 恢复
57 |                 $word[$i] = $char;
58 |             }
59 |         }
60 | 
61 |         return 0;
62 | 
63 |     }
64 | }
65 | 
66 | // Time Limit Exceeded
67 | // 32/43 cases passed (N/A)
68 | // @lc code=end


--------------------------------------------------------------------------------
/09th深度优先搜索和广度优先搜索/200.岛屿数量_DFS.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=200 lang=php
 4 |  *
 5 |  * [200] 岛屿数量
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     protected $row;
12 |     protected $col;
13 | 
14 |     /**
15 |      * @param String[][] $grid
16 |      * @return Integer
17 |      */
18 |     function numIslands($grid) {
19 | 
20 |         if($grid == null || count($grid) == 0) return 0;
21 | 
22 |         $count = 0;
23 | 
24 |         $this->row = count($grid);
25 |         $this->col = count($grid[0]);
26 | 
27 |         for ($i=0; $i < $this->row; $i++) { 
28 |             
29 |             for ($j=0; $j < $this->col; $j++) { 
30 | 
31 |                 if($grid[$i][$j] == '1'){
32 |                     $count++;
33 |                     $this->dfs($grid, $i, $j);
34 |                 }
35 |             }
36 |         }
37 | 
38 |         return $count;
39 |     }
40 | 
41 |     function dfs(&$grid, $i, $j) {
42 | 
43 |         if($i < 0 || $j < 0 || $i >= $this->row || $j >= $this->col || $grid[$i][$j] == '0') {
44 |             return true;
45 |         }
46 | 
47 |         $grid[$i][$j] = '0';
48 |         $this->dfs($grid, $i - 1, $j);
49 |         $this->dfs($grid, $i + 1, $j);
50 |         $this->dfs($grid, $i, $j - 1);
51 |         $this->dfs($grid, $i, $j + 1);
52 |     }
53 | }
54 | 
55 | // Accepted
56 | // 47/47 cases passed (56 ms)
57 | // Your runtime beats 51.2 % of php submissions
58 | // Your memory usage beats 100 % of php submissions (22.6 MB)
59 | // @lc code=end
60 | 
61 | 


--------------------------------------------------------------------------------
/09th深度优先搜索和广度优先搜索/22.括号生成_BFS.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=22 lang=php
 4 |  *
 5 |  * [22] 括号生成
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer $n
13 |      * @return String[]
14 |      */
15 |     function generateParenthesis($n) {
16 |         
17 |         if($n == 0) return [];
18 | 
19 |         $res = [];
20 |         $queue = [];
21 | 
22 |         array_push($queue, ["", $n, $n]);
23 | 
24 |         // BFS 广度优先遍历
25 |         while (!empty($queue)) {
26 |             
27 |             $cur = array_shift($queue);
28 |             $str = $cur[0];
29 |             $left = $cur[1];
30 |             $right = $cur[2];
31 | 
32 |             if($left == 0 && $right == 0) {
33 |                 $res[] = $str;
34 |                 continue;
35 |             }
36 | 
37 |             if($left > 0) {
38 |                 array_push($queue, [$str."(", $left - 1, $right]);
39 |             }
40 | 
41 |             if($right > 0 && $left < $right) {
42 |                 array_push($queue, [$str.")", $left, $right - 1]);
43 |             }
44 | 
45 |         }
46 | 
47 |         return $res;
48 |     }
49 | }
50 | 
51 | // Accepted
52 | // 8/8 cases passed (28 ms)
53 | // Your runtime beats 7.65 % of php submissions
54 | // Your memory usage beats 100 % of php submissions (16.1 MB)
55 | // 效率很低？？
56 | // @lc code=end
57 | 
58 | 


--------------------------------------------------------------------------------
/09th深度优先搜索和广度优先搜索/22.括号生成_DFS.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=22 lang=php
 4 |  *
 5 |  * [22] 括号生成
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer $n
13 |      * @return String[]
14 |      */
15 |     function generateParenthesis($n) {
16 | 
17 |         $res = [];
18 | 
19 |         $this->generate(0, 0, $n, "", $res);
20 | 
21 |         return $res;
22 |     }
23 | 
24 |     // 递归生成括号
25 |     function generate($left, $right, $n, $s, &$res) {
26 | 
27 |         // 每次终止条件
28 |         if($left == $n && $right == $n) {
29 |             $res[] = $s;
30 |         }
31 | 
32 |         // 左括号还没用完
33 |         if($left < $n) {
34 |             $this->generate($left+1, $right, $n, $s."(", $res);
35 |         }
36 |         
37 |         // 右括号小于左口号数量时，+1
38 |         if($right < $left) {
39 |             $this->generate($left, $right+1, $n, $s.")", $res);
40 |         }
41 |     }
42 | }
43 | 
44 | // Accepted
45 | // 8/8 cases passed (8 ms)
46 | // Your runtime beats 79.59 % of php submissions
47 | // Your memory usage beats 100 % of php submissions (15.6 MB)
48 | // @lc code=end
49 | 
50 | 


--------------------------------------------------------------------------------
/09th深度优先搜索和广度优先搜索/433.最小基因变化_BFS.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=433 lang=php
 4 |  *
 5 |  * [433] 最小基因变化
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param String $start
13 |      * @param String $end
14 |      * @param String[] $bank
15 |      * @return Integer
16 |      */
17 |     function minMutation($start, $end, $bank) {
18 | 
19 |         if(!in_array($end, $bank)) return -1;
20 | 
21 |         $change = [
22 |             'A' => "CGT",
23 |             'C' => "AGT",
24 |             'G' => "ACT",
25 |             'T' => "ACG",
26 |         ];
27 | 
28 |         // 初始入队
29 |         $queue = [
30 |             [$start, 0],
31 |         ];
32 | 
33 |         while ($n = count($queue)) {
34 | 
35 |             $cur = array_shift($queue);
36 |             $str = $cur[0];
37 |             $step = $cur[1];
38 | 
39 |             if($str == $end) return $step;
40 | 
41 |             for ($i=0; $i < strlen($str); $i++) {
42 | 
43 |                 $gen = $change[$str[$i]];
44 | 
45 |                 for ($j=0; $j < strlen($gen); $j++) {
46 | 
47 |                     $new = substr($str, 0, $i).$gen[$j].substr($str, $i+1);
48 | 
49 |                     if(in_array($new, $bank)){
50 |                         array_push($queue, [$new, $step + 1]);
51 |                         // 剪枝，避免重复
52 |                         //unset($bank[array_search($bank)]);
53 |                     }
54 |                 }
55 |             }
56 |         }
57 | 
58 |         return -1;
59 |     }
60 | }
61 | 
62 | // Accepted
63 | // 14/14 cases passed (8 ms)
64 | // Your runtime beats 68.75 % of php submissions
65 | // Your memory usage beats 100 % of php submissions (15 MB)
66 | // @lc code=end
67 | 
68 | 


--------------------------------------------------------------------------------
/09th深度优先搜索和广度优先搜索/README.md:
--------------------------------------------------------------------------------
1 | ### 专题知识点


--------------------------------------------------------------------------------
/10th贪心算法/122.买卖股票的最佳时机-ii.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=122 lang=php
 4 |  *
 5 |  * [122] 买卖股票的最佳时机 II
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer[] $prices
13 |      * @return Integer
14 |      */
15 |     function maxProfit($prices) {
16 |         
17 |         $max_profit = 0;
18 | 
19 |         for ($i=1; $i < count($prices); $i++) { 
20 |             // 如果今天比昨天高价，就在昨天买进，今天卖出
21 |             if($prices[$i] > $prices[$i-1]) {
22 |                 $max_profit += $prices[$i] - $prices[$i-1];
23 |             }
24 |         }
25 | 
26 |         return $max_profit;
27 |     }
28 | }
29 | 
30 | // Accepted
31 | // 200/200 cases passed (20 ms)
32 | // Your runtime beats 69.88 % of php submissions
33 | // Your memory usage beats 100 % of php submissions (16.9 MB)
34 | // @lc code=end
35 | 
36 | 


--------------------------------------------------------------------------------
/10th贪心算法/455.分发饼干.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=455 lang=php
 4 |  *
 5 |  * [455] 分发饼干
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer[] $g
13 |      * @param Integer[] $s
14 |      * @return Integer
15 |      */
16 |     function findContentChildren($g, $s) {
17 |         
18 |         sort($g);
19 |         sort($s);
20 | 
21 |         $g_len = count($g);
22 |         $s_len = count($s);
23 |         $i = 0;
24 |         $j = 0;
25 |         $res = 0;
26 | 
27 |         while ($i < $g_len && $j < $s_len) {
28 |             // 排序后，对比最小饼干是否满足当前最小胃口
29 |             if($g[$i] <= $s[$j]) {
30 |                 $i++;
31 |                 $j++;
32 |                 $res++;
33 |             } else{
34 |                 $j++;
35 |             }
36 |         }
37 | 
38 |         return $res;
39 |     }
40 | }
41 | 
42 | // Accepted
43 | // 21/21 cases passed (72 ms)
44 | // Your runtime beats 83.78 % of php submissions
45 | // Your memory usage beats 100 % of php submissions (16.6 MB)
46 | // @lc code=end
47 | 
48 | 


--------------------------------------------------------------------------------
/10th贪心算法/55.跳跃游戏_贪心1.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=55 lang=php
 4 |  *
 5 |  * [55] 跳跃游戏
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer[] $nums
13 |      * @return Boolean
14 |      */
15 |     function canJump($nums) {
16 | 
17 |         if($nums == null || count($nums) == 0) return false;
18 | 
19 |         // 从最后一步开始
20 |         $enableIndex = count($nums) - 1;
21 | 
22 |         for ($i= $enableIndex - 1; $i >= 0; $i--) { 
23 | 
24 |             if($i + $nums[$i] >= $enableIndex) {
25 |                 $enableIndex = $i;
26 |             }
27 |         }
28 | 
29 |         return $enableIndex == 0;
30 |     }
31 | }
32 | 
33 | // Accepted
34 | // 75/75 cases passed (28 ms)
35 | // Your runtime beats 75.43 % of php submissions
36 | // Your memory usage beats 100 % of php submissions (18.4 MB)
37 | // @lc code=end
38 | 
39 | 


--------------------------------------------------------------------------------
/10th贪心算法/55.跳跃游戏_贪心2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=55 lang=php
 4 |  *
 5 |  * [55] 跳跃游戏
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer[] $nums
13 |      * @return Boolean
14 |      */
15 |     function canJump($nums) {
16 | 
17 |         // 初始化当前能到达最远的位置
18 |         $max_i = 0;
19 | 
20 |         // i为当前位置，jump是当前位置的跳数
21 |         foreach($nums as $i => $jump) {
22 | 
23 |             // 如果当前位置能到达，并且当前位置+跳数>最远位置
24 |             if($max_i >= $i && $i + $jump > $max_i) {
25 |                 $max_i = $i + $jump;
26 |             }
27 |         }
28 | 
29 |         return $max_i >= $i;
30 |     }
31 | }
32 | 
33 | // Accepted
34 | // 75/75 cases passed (28 ms)
35 | // Your runtime beats 75.43 % of php submissions
36 | // Your memory usage beats 100 % of php submissions (18.1 MB)
37 | // @lc code=end
38 | 
39 | 


--------------------------------------------------------------------------------
/10th贪心算法/README.md:
--------------------------------------------------------------------------------
1 | ### 专题知识点


--------------------------------------------------------------------------------
/11th二分查找/33.搜索旋转排序数组.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=33 lang=php
 4 |  *
 5 |  * [33] 搜索旋转排序数组
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer[] $nums
13 |      * @param Integer $target
14 |      * @return Integer
15 |      */
16 |     function search($nums, $target) {
17 |         
18 |         $start = 0;
19 |         $end = count($nums) - 1;
20 | 
21 |         while($start <= $end) {
22 |             $mid = $start + (($end - $start) >> 1);
23 | 
24 |             if($nums[$mid] == $target) {
25 |                 return $mid;
26 |             }
27 |             
28 |             if($nums[$start] <= $nums[$mid]) {
29 |                 // 左半边有序
30 |                 if($nums[$start] <= $target && $target < $nums[$mid]){
31 |                     // 目标值落在有序区间时，搜索有序区间，否则搜索无序区间
32 |                     $end = $mid - 1;
33 |                 }else{
34 |                     $start = $mid + 1;
35 |                 }
36 |             }else{
37 |                 // 右半边有序
38 |                 if($nums[$mid] < $target && $target <= $nums[$end]){
39 |                     $start = $mid + 1;
40 |                 }else{
41 |                     $end = $mid - 1;
42 |                 }
43 |             }
44 |         }
45 | 
46 |         return -1;
47 |     }
48 | }
49 | 
50 | // Accepted
51 | // 196/196 cases passed (16 ms)
52 | // Your runtime beats 34.91 % of php submissions
53 | // Your memory usage beats 100 % of php submissions (15 MB)
54 | // @lc code=end
55 | 
56 | 


--------------------------------------------------------------------------------
/11th二分查找/367.有效的完全平方数.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=367 lang=php
 4 |  *
 5 |  * [367] 有效的完全平方数
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer $num
13 |      * @return Boolean
14 |      */
15 |     function isPerfectSquare($num) {
16 | 
17 |         $i = 1;
18 |         while($num > 0) {
19 |             $num -= $i;
20 |             $i += 2;
21 |         }
22 | 
23 |         return $num == 0;
24 |     }
25 | }
26 | 
27 | // 效率低，但是很秀，
28 | // 1 4=1+3 9=1+3+5 16=1+3+5+7以此类推
29 | // Accepted
30 | // 70/70 cases passed (12 ms)
31 | // Your runtime beats 13.21 % of php submissions
32 | // Your memory usage beats 100 % of php submissions (14.8 MB)
33 | // @lc code=end
34 | 
35 | 


--------------------------------------------------------------------------------
/11th二分查找/69.x-的平方根.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=69 lang=php
 4 |  *
 5 |  * [69] x 的平方根
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer $x
13 |      * @return Integer
14 |      */
15 |     function mySqrt($x) {
16 | 
17 |         if($x<2) return $x;
18 | 
19 |         $left = 2;
20 |         $right = floor($x/2);
21 | 
22 |         while($left <= $right){
23 | 
24 |             $mid = floor($left + ($right - $left) / 2);
25 |             $num = $mid * $mid;
26 |             if($num > $x){
27 |                 $right = $mid - 1;
28 |             } else if($num < $x) {
29 |                 $left = $mid + 1;
30 |             } else {
31 |                 return $mid;
32 |             }
33 |         }
34 | 
35 |         return $right;
36 |     }
37 | }
38 | 
39 | // Accepted
40 | // 1017/1017 cases passed (8 ms)
41 | // Your runtime beats 90.3 % of php submissions
42 | // Your memory usage beats 100 % of php submissions (14.7 MB)
43 | // @lc code=end
44 | 
45 | 


--------------------------------------------------------------------------------
/11th二分查找/74.搜索二维矩阵.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=74 lang=php
 4 |  *
 5 |  * [74] 搜索二维矩阵
 6 |  */
 7 | 
 8 | // @lc code=start
 9 | class Solution {
10 | 
11 |     /**
12 |      * @param Integer[][] $matrix
13 |      * @param Integer $target
14 |      * @return Boolean
15 |      */
16 |     function searchMatrix($matrix, $target) {
17 |         
18 |         if(count($matrix) == 0 || count($matrix[0]) == 0) {
19 |             return false;
20 |         }
21 | 
22 |         //从左下角开始搜
23 |         $row = count($matrix) - 1;
24 |         $col = 0;
25 | 
26 |         while($row >= 0 && $col < count($matrix[0])) {
27 |             if($matrix[$row][$col] == $target) {
28 |                 return true;
29 |             }
30 | 
31 |             if($matrix[$row][$col] < $target) {
32 |                 $col++;
33 |             }else {
34 |                 $row--;
35 |             }
36 |         }
37 | 
38 |         return false;
39 |     }
40 | }
41 | 
42 | // Accepted
43 | // 136/136 cases passed (24 ms)
44 | // Your runtime beats 76 % of php submissions
45 | // Your memory usage beats 100 % of php submissions (16.7 MB)
46 | // @lc code=end
47 | 


--------------------------------------------------------------------------------
/11th二分查找/README.md:
--------------------------------------------------------------------------------
1 | ### 专题知识点


--------------------------------------------------------------------------------
/12th动态规划/1143.最长公共子序列.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=1143 lang=php
 4 |  *
 5 |  * [1143] 最长公共子序列
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/longest-common-subsequence/
 8 |  * 视频讲解 https://www.bilibili.com/video/BV1iE411Y7fy?from=search&seid=11907390432490932326
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     /**
15 |      * @param String $text1
16 |      * @param String $text2
17 |      * @return Integer
18 |      */
19 |     function longestCommonSubsequence($text1, $text2) {
20 | 
21 |         $m = strlen($text1);
22 |         $n = strlen($text2);
23 |         $dp[0][0] = 0;
24 | 
25 |         for ($i=1; $i <= $m; $i++) { 
26 |             $dp[0][$i] = 0;
27 |         }
28 | 
29 |         for ($i=1; $i <= $n; $i++) { 
30 |             $dp[$i][0] = 0;
31 |         }
32 | 
33 |         for ($i=0; $i < $m; $i++) { 
34 |             for ($j=0; $j < $n; $j++) { 
35 |                 if($text1[$i] == $text2[$j]) {
36 |                     $dp[$i + 1][$j + 1] = $dp[$i][$j] + 1;
37 |                 }else{
38 |                     $dp[$i + 1][$j + 1] = max($dp[$i + 1][$j], $dp[$i][$j + 1]);
39 |                 }
40 |             }
41 |         }
42 | 
43 |         return $dp[$m][$n];
44 |     }
45 | }
46 | 
47 | // Accepted
48 | // 43/43 cases passed (128 ms)
49 | // Your runtime beats 51.32 % of php submissions
50 | // Your memory usage beats 100 % of php submissions (47.3 MB)
51 | // @lc code=end
52 | 
53 | 


--------------------------------------------------------------------------------
/12th动态规划/120.三角形最小路径和.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=120 lang=php
 4 |  *
 5 |  * [120] 三角形最小路径和
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/triangle/description/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[][] $triangle
15 |      * @return Integer
16 |      */
17 |     function minimumTotal($triangle) {
18 | 
19 |         // 三角形的层高/二维数组的行数
20 |         $n = count($triangle);
21 |         // 初始化二维数组
22 |         $dp = array_fill(0, $n+1, array_fill(0, $n+1, 0));
23 | 
24 |         for ($i=$n - 1; $i >= 0; $i--) { 
25 |             for ($j=0; $j <= $i; $j++) {
26 |                 // 当前坐标的最小路径和 = 下一层的同坐标和相邻坐标（较小值） + 当前坐标值
27 |                 $dp[$i][$j] = min($dp[$i + 1][$j], $dp[$i + 1][$j + 1]) + $triangle[$i][$j];
28 |             }
29 |         }
30 |         
31 |         return $dp[0][0];
32 |     }
33 | }
34 | 
35 | // Accepted
36 | // 43/43 cases passed (16 ms)
37 | // Your runtime beats 91.3 % of php submissions
38 | // Your memory usage beats 100 % of php submissions (17.6 MB)
39 | // @lc code=end
40 | 
41 | 


--------------------------------------------------------------------------------
/12th动态规划/120.三角形最小路径和_优化内存.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=120 lang=php
 4 |  *
 5 |  * [120] 三角形最小路径和
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/triangle/description/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[][] $triangle
15 |      * @return Integer
16 |      */
17 |     function minimumTotal($triangle) {
18 | 
19 |         // 三角形的层高
20 |         $n = count($triangle);
21 |         // 初始化数组
22 |         $dp = array_fill(0, $n+1, 0);
23 | 
24 |         for ($i=$n - 1; $i >= 0; $i--) { 
25 |             for ($j=0; $j <= $i; $j++) {
26 |                 $dp[$j] = min($dp[$j], $dp[$j + 1]) + $triangle[$i][$j];
27 |             }
28 |         }
29 |         
30 |         return $dp[0];
31 |     }
32 | }
33 | 
34 | // Accepted
35 | // 43/43 cases passed (12 ms)
36 | // Your runtime beats 99.03 % of php submissions
37 | // Your memory usage beats 100 % of php submissions (16.2 MB)
38 | // @lc code=end
39 | 
40 | 


--------------------------------------------------------------------------------
/12th动态规划/121.买卖股票的最佳时机.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=121 lang=php
 4 |  *
 5 |  * [121] 买卖股票的最佳时机
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/
 8 |  * 
 9 |  * 通用状态转移方程：
10 |  * i 代表第几天，k 代表交易次数， 0、1代表没有股票、持有股票
11 |  * 当前没有股票，可能是前一天没有股票，或者前一天有股票，但是今天卖出
12 |  * 当前有股票，可能是前一天持有股票，或者前一天没有股票，但是今天买入
13 |  * dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
14 |  * dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
15 |  */
16 | 
17 | // @lc code=start
18 | class Solution {
19 | 
20 |     /**
21 |      * @param Integer[] $prices
22 |      * @return Integer
23 |      */
24 |     function maxProfit($prices) {
25 | 
26 |         $n = count($prices);
27 |         if($n == 0) return 0;
28 | 
29 |         $dp = [];
30 |         $dp[0][0] = 0;//没有股票，也没有利润
31 |         $dp[0][1] = -$prices[0];//买入股票，负利润
32 | 
33 |         for ($i=1; $i < $n; $i++) { 
34 |             $dp[$i][0] = max($dp[$i - 1][0], $dp[$i - 1][1] + $prices[$i]);
35 |             $dp[$i][1] = max($dp[$i - 1][1], -$prices[$i]);
36 |         }
37 | 
38 |         return $dp[$n - 1][0];
39 |     }
40 | }
41 | 
42 | // Accepted
43 | // 200/200 cases passed (12 ms)
44 | // Your runtime beats 98.95 % of php submissions
45 | // Your memory usage beats 33.33 % of php submissions (25.8 MB)
46 | // @lc code=end
47 | 
48 | 


--------------------------------------------------------------------------------
/12th动态规划/152.乘积最大子数组.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=152 lang=php
 4 |  *
 5 |  * [152] 乘积最大子数组
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/maximum-product-subarray/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $nums
15 |      * @return Integer
16 |      */
17 |     function maxProduct($nums) {
18 | 
19 |         $max_f = $nums[0];
20 |         $min_f = $nums[0];
21 |         $ans = $nums[0];
22 | 
23 |         for ($i=1; $i < count($nums); $i++) { 
24 |             $mx = $max_f;
25 |             $mn = $min_f;
26 | 
27 |             // 遇到相隔的负数，相乘后可以反转最小为最大
28 |             $max_f = max($mx * $nums[$i], max($nums[$i], $mn * $nums[$i]));
29 |             $min_f = min($mn * $nums[$i], min($nums[$i], $mx * $nums[$i]));
30 | 
31 |             $ans = max($max_f, $ans);
32 |         }
33 | 
34 |         return $ans;
35 |     }
36 | }
37 | 
38 | // Accepted
39 | // 187/187 cases passed (20 ms)
40 | // Your runtime beats 53.64 % of php submissions
41 | // Your memory usage beats 100 % of php submissions (15.7 MB)
42 | // @lc code=end
43 | 
44 | 


--------------------------------------------------------------------------------
/12th动态规划/198.打家劫舍_DP.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=198 lang=php
 4 |  *
 5 |  * [198] 打家劫舍
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/house-robber/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $nums
15 |      * @return Integer
16 |      */
17 |     function rob($nums) {
18 | 
19 |         if ($nums == null || count($nums) == 0) {
20 |             return 0;
21 |         }
22 | 
23 |         $n = count($nums);
24 |         $a = array_fill(0, $n, array_fill(0, 2, 0));
25 |         //$a[0][0] = 0;
26 |         $a[0][1] = $nums[0];
27 | 
28 | 
29 |         for ($i=1; $i < $n; $i++) { 
30 |             // 当前一天不偷
31 |             $a[$i][0] = max($a[$i - 1][0], $a[$i - 1][1]);
32 |             // 当前一天偷盗
33 |             $a[$i][1] = $a[$i - 1][0] + $nums[$i];
34 |         }
35 | 
36 |         return max($a[$n - 1][0], $a[$n - 1][1]);
37 |     }
38 | }
39 | 
40 | // Accepted
41 | // 69/69 cases passed (8 ms)
42 | // Your runtime beats 68.56 % of php submissions
43 | // Your memory usage beats 100 % of php submissions (14.8 MB)
44 | // @lc code=end
45 | 
46 | 


--------------------------------------------------------------------------------
/12th动态规划/198.打家劫舍_优化内存.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=198 lang=php
 4 |  *
 5 |  * [198] 打家劫舍
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/house-robber/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $nums
15 |      * @return Integer
16 |      */
17 |     function rob($nums) {
18 |         
19 |         if ($nums == null || count($nums) == 0) {
20 |             return 0;
21 |         }
22 | 
23 |         $n = count($nums);
24 |         if ($n == 1) {
25 |             return $nums[0];
26 |         }
27 | 
28 |         $a[0] = $nums[0];
29 |         $a[1] = max($nums[0], $nums[1]);
30 |         $res = max($a[0], $a[1]);
31 | 
32 |         // a[i] 表示 0 到 i 天，且第 i 天必偷的最大值
33 |         for ($i=2; $i < $n; $i++) { 
34 |             // i 偷得话，i - 2必偷
35 |             $a[$i] = max($a[$i - 1], $a[$i - 2] + $nums[$i]);
36 |             $res = max($res, $a[$i]);
37 |         }
38 | 
39 |         return $res;
40 |     }
41 | }
42 | 
43 | // Accepted
44 | // 69/69 cases passed (4 ms)
45 | // Your runtime beats 89.96 % of php submissions
46 | // Your memory usage beats 100 % of php submissions (14.8 MB)
47 | // @lc code=end
48 | 
49 | 


--------------------------------------------------------------------------------
/12th动态规划/312.戳气球_DP.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=312 lang=php
 4 |  *
 5 |  * [312] 戳气球
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/burst-balloons/
 8 |  * 视频讲解 https://www.bilibili.com/video/av45180542
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     protected $dp;
15 |     /**
16 |      * @param Integer[] $nums
17 |      * @return Integer
18 |      */
19 |     function maxCoins($nums) {
20 | 
21 |         $n = count($nums);
22 |         // 根据题目说明，首尾推入1，保证递归有效
23 |         $nums = array_merge([1], $nums);
24 |         $nums[] = 1;
25 |         // 填充二维数组
26 |         $this->dp = array_fill(0, $n+2, array_fill(0, $n+2, 0));
27 |         $res = $this->helper($nums, 1, $n);
28 |         return $res;
29 |     }
30 | 
31 |     function helper(&$nums, $i, $j) {
32 |         // boundary
33 |         if($i > $j) return 0;
34 |         if($this->dp[$i][$j] > 0) return $this->dp[$i][$j];
35 | 
36 |         // search
37 |         // 优先戳破左边和右边的气球，再戳破当前气球，可以看出左右两个子问题是独立的，并且只和当前气球关联
38 |         // 每个子问题里，k 的范围是 i => j
39 |         // 定义状态转移方程：dp[i][j] = dp[i][k-1] + dp[k+1][j] + nums[k] * nums[i-1] * nums[j+1]
40 |         for ($k=$i; $k <= $j; $k++) { 
41 |             $left = $this->helper($nums, $i, $k - 1);
42 |             $right = $this->helper($nums, $k + 1, $j);
43 |             $delta = $nums[$k] * $nums[$i - 1] * $nums[$j + 1];
44 |             
45 |             $this->dp[$i][$j] = max($this->dp[$i][$j], $left + $right + $delta);
46 |         }
47 | 
48 |         return $this->dp[$i][$j];
49 |     }
50 | }
51 | 
52 | // Accepted
53 | // 70/70 cases passed (288 ms)
54 | // Your runtime beats 84.62 % of php submissions
55 | // Your memory usage beats 100 % of php submissions (16.5 MB)
56 | // @lc code=end


--------------------------------------------------------------------------------
/12th动态规划/32.最长有效括号.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=32 lang=php
 4 |  *
 5 |  * [32] 最长有效括号
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/longest-valid-parentheses/
 8 |  * 视频讲解 https://www.bilibili.com/video/BV1Ct4y197M3?from=search&seid=7250467796583559575
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     /**
15 |      * @param String $s
16 |      * @return Integer
17 |      */
18 |     function longestValidParentheses($s) {
19 |         
20 |         $n = strlen($s);
21 |         // dp[i] 代表以当前字符结尾构成有效括号子串的长度是多少
22 |         $dp = array_fill(0, $n, 0);
23 |         $max = 0;
24 | 
25 |         for ($i=1; $i < $n; $i++) { 
26 |             // 以左括号结尾肯定不是有效子串，跳过
27 |             if ($s[$i] == ')') {
28 |                 // 前一个子串有效的条件
29 |                 if ($i - $dp[$i - 1] > 0 && $s[$i - $dp[$i - 1] - 1] == '(') {
30 |                     // 当前有效长度 + 前一个有效长度 + 前前一个有效长度
31 |                     $dp[$i] = 2 + $dp[$i - 1] + ($i - $dp[$i - 1] - 2 > -1 ? $dp[$i - $dp[$i - 1] - 2] : 0);
32 |                 }
33 |             }
34 | 
35 |             $max = max($max, $dp[$i]);
36 |         }
37 | 
38 |         return $max;
39 |     }
40 | }
41 | 
42 | // Accepted
43 | // 230/230 cases passed (12 ms)
44 | // Your runtime beats 87.5 % of php submissions
45 | // Your memory usage beats 100 % of php submissions (15.3 MB)
46 | // @lc code=end
47 | 
48 | 


--------------------------------------------------------------------------------
/12th动态规划/322.零钱兑换_自底向上DP.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=322 lang=php
 4 |  *
 5 |  * [322] 零钱兑换
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/coin-change/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $coins
15 |      * @param Integer $amount
16 |      * @return Integer
17 |      */
18 |     function coinChange($coins, $amount) {
19 | 
20 |         // 最大值
21 |         $max = $amount + 1;
22 |         // 初始化
23 |         $dp = array_fill(0, $amount + 1, $max);
24 |         // 走到第0级台阶需要0步
25 |         $dp[0] = 0;
26 |         for ($i=0; $i <= $amount; $i++) { 
27 |             for ($j=0; $j < count($coins); $j++) { 
28 |                 // i 表示要凑到的面值数
29 |                 if($coins[$j] <= $i) {
30 |                     // coins[j] 可用情况下
31 |                     $dp[$i] = min($dp[$i], $dp[$i - $coins[$j]] + 1);
32 |                 }
33 |             }
34 |         }
35 | 
36 |         return $dp[$amount] > $amount ? -1 : $dp[$amount];
37 |     }
38 | }
39 | 
40 | // 1. 暴力：递归、指数级
41 | // 2. BFS
42 | // 3. DP array: f(n) = min{f(n - k), for k in [1, 2, 5]} + 1
43 | 
44 | // Accepted
45 | // 182/182 cases passed (368 ms)
46 | // Your runtime beats 42.31 % of php submissions
47 | // Your memory usage beats 100 % of php submissions (14.8 MB)
48 | // @lc code=end


--------------------------------------------------------------------------------
/12th动态规划/53.最大子序和.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=53 lang=php
 4 |  *
 5 |  * [53] 最大子序和
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/maximum-subarray/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $nums
15 |      * @return Integer
16 |      */
17 |     function maxSubArray($nums) {
18 |         
19 |         $ans = $nums[0];
20 |         $sum = 0;
21 | 
22 |         foreach ($nums as $num) {
23 | 
24 |             // 正数有增益效果，负数的话直接舍弃
25 |             $sum = $sum > 0 ? $sum + $num : $num;
26 |             $ans = max($ans, $sum);
27 |         }
28 | 
29 |         return $ans;
30 |     }
31 | }
32 | 
33 | // Accepted
34 | // 202/202 cases passed (24 ms)
35 | // Your runtime beats 43.03 % of php submissions
36 | // Your memory usage beats 100 % of php submissions (16.2 MB)
37 | // @lc code=end
38 | 
39 | 


--------------------------------------------------------------------------------
/12th动态规划/53.最大子序和_DP.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=53 lang=php
 4 |  *
 5 |  * [53] 最大子序和
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/coin-change/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $nums
15 |      * @return Integer
16 |      */
17 |     function maxSubArray($nums) {
18 |         
19 |         // dp问题
20 |         // 1. 列出方程，dp[i] = max(nums[i], $nums + dp[i - 1])
21 |         // 2. 最大子序列和 = 当前元素最大，或者 包含之前 后最大
22 |         $dp = $nums;
23 |         for ($i=1; $i < count($nums); $i++) { 
24 |             $dp[$i] = max(0, $dp[$i - 1]) + $nums[$i];
25 |         }
26 | 
27 |         rsort($dp);
28 |         return $dp[0];
29 |     }
30 | }
31 | 
32 | // Accepted
33 | // 202/202 cases passed (28 ms)
34 | // Your runtime beats 20.06 % of php submissions
35 | // Your memory usage beats 100 % of php submissions (16 MB)
36 | // @lc code=end
37 | 
38 | 


--------------------------------------------------------------------------------
/12th动态规划/62.不同路径.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=62 lang=php
 4 |  *
 5 |  * [62] 不同路径
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/unique-paths/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer $m
15 |      * @param Integer $n
16 |      * @return Integer
17 |      */
18 |     function uniquePaths($m, $n) {
19 |         
20 |         $dp[0][0] = 0;//起点无意义
21 | 
22 |         for ($i=0; $i < $m; $i++) { 
23 |             $dp[0][$i] = 1;
24 |         }
25 | 
26 |         for ($i=0; $i < $n; $i++) { 
27 |             $dp[$i][0] = 1;
28 |         }
29 | 
30 |         // 假设 dp[i][j] 是到达 i, j 最多路径，则 dp[i][j] 等于它当前坐标的向左一位（的路径和） + 向上一位（的路径和）
31 |         for ($i=1; $i < $n; $i++) { 
32 |             for ($j=1; $j < $m; $j++) { 
33 |                 $dp[$i][$j] = $dp[$i - 1][$j] + $dp[$i][$j - 1];
34 |             }
35 |         }
36 | 
37 |         return $dp[$n-1][$m-1];
38 |     }
39 | }
40 | 
41 | // Accepted
42 | // 62/62 cases passed (4 ms)
43 | // Your runtime beats 88.76 % of php submissions
44 | // Your memory usage beats 100 % of php submissions (14.8 MB)
45 | // @lc code=end
46 | 
47 | 


--------------------------------------------------------------------------------
/12th动态规划/62.不同路径_优化内存.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=62 lang=php
 4 |  *
 5 |  * [62] 不同路径
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/unique-paths/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer $m
15 |      * @param Integer $n
16 |      * @return Integer
17 |      */
18 |     function uniquePaths($m, $n) {
19 |         
20 |         // m 为列长
21 |         // 初始化第一行的路径数
22 |         $cur = array_fill(0, $m, 1);
23 | 
24 |         // 从第二行开始计算
25 |         for ($i=1; $i < $n; $i++) { 
26 |             for ($j=1; $j < $m; $j++) { 
27 |                 // 当前 $cur[$j] 实际上就是二维解法时的 $dp[$i - 1][$j]
28 |                 // 当前 $cur[$j - 1] 则是 $dp[$i][$j - 1]
29 |                 $cur[$j] = $cur[$j] + $cur[$j - 1];
30 |             }
31 |         }
32 | 
33 |         return $cur[$m - 1];
34 |     }
35 | }
36 | 
37 | // 不太靠谱的运行结果，有时候比正常DP的解法还慢
38 | // Accepted
39 | // 62/62 cases passed (4 ms)
40 | // Your runtime beats 88.76 % of php submissions
41 | // Your memory usage beats 100 % of php submissions (14.7 MB)
42 | // @lc code=end
43 | 
44 | 


--------------------------------------------------------------------------------
/12th动态规划/621.任务调度器.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=621 lang=php
 4 |  *
 5 |  * [621] 任务调度器
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/task-scheduler/
 8 |  * 视频讲解 https://www.bilibili.com/video/BV11t411V7h3?from=search&seid=15024347809109592064
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     /**
15 |      * @param String[] $tasks
16 |      * @param Integer $n
17 |      * @return Integer
18 |      */
19 |     function leastInterval($tasks, $n) {
20 |         // 题目要求，每个相同任务都要冷却 n 单位的时间
21 | 
22 |         $record = [];
23 |         foreach ($tasks as $task) {
24 |             $record[$task] = isset($record[$task]) ? $record[$task] + 1 : 1;
25 |         }
26 | 
27 |         // 排序后，想象由高到底低覆盖一个矩形
28 |         sort($record);
29 | 
30 |         $len = count($record);// kind of tasks
31 |         $max_n = $record[$len - 1] - 1; // 最后一行执行结束退出，不需要等待时间
32 |         $space = $max_n * $n; // 从倒数第二行形成矩形，覆盖任务执行时间和等待时间
33 | 
34 |         for ($i=$len - 2; $i >= 0; $i--) { 
35 |             // 逐步减去矩形中任务的执行时间，剩下就是所需的等待时间
36 |             $space = $space - min($max_n, $record[$i]);
37 |         }
38 | 
39 |         return $space > 0 ? count($tasks) + $space : count($tasks);
40 |     }
41 | }
42 | 
43 | // Accepted
44 | // 69/69 cases passed (140 ms)
45 | // Your runtime beats 66.67 % of php submissions
46 | // Your memory usage beats 100 % of php submissions (16.7 MB)
47 | // @lc code=end
48 | 
49 | 


--------------------------------------------------------------------------------
/12th动态规划/64.最小路径和.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=64 lang=php
 4 |  *
 5 |  * [64] 最小路径和
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/minimum-path-sum/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[][] $grid
15 |      * @return Integer
16 |      */
17 |     function minPathSum($grid) {
18 |         
19 |         $m = count($grid);
20 |         $n = count($grid[0]);
21 |         if($grid == null || $m == 0 || $n ==0) {
22 |             return 0;
23 |         }
24 | 
25 |         $dp[0][0] = $grid[0][0];
26 | 
27 |         // 初始化边界
28 |         for ($i=1; $i < $m; $i++) { 
29 |             $dp[$i][0]  = $dp[$i - 1][0] + $grid[$i][0];
30 |         }
31 | 
32 |         for ($j=1; $j < $n; $j++) { 
33 |             $dp[0][$j]  = $dp[0][$j - 1] + $grid[0][$j];
34 |         }
35 | 
36 |         // 状态转移方程
37 |         for ($i=1; $i < $m; $i++) { 
38 |             for ($j=1; $j < $n; $j++) {
39 |                 // 从上往下走或者从左往右走，选出较小的一条路径
40 |                 $dp[$i][$j] = min($dp[$i - 1][$j], $dp[$i][$j - 1]) + $grid[$i][$j];
41 |             }
42 |         }
43 | 
44 |         return $dp[$m-1][$n-1];
45 |     }
46 | }
47 | 
48 | // Accepted
49 | // 61/61 cases passed (28 ms)
50 | // Your runtime beats 96.05 % of php submissions
51 | // Your memory usage beats 100 % of php submissions (18.6 MB)
52 | // @lc code=end
53 | 
54 | 


--------------------------------------------------------------------------------
/12th动态规划/647.回文子串.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=647 lang=php
 4 |  *
 5 |  * [647] 回文子串
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/palindromic-substrings/
 8 |  * 视频讲解 https://www.bilibili.com/video/BV17J411y7Xx?from=search&seid=5290369526891570764
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     /**
15 |      * @param String $s
16 |      * @return Integer
17 |      */
18 |     function countSubstrings($s) {
19 |         
20 |         $n = strlen($s);
21 |         $res = 0;
22 | 
23 |         // dp[i][j] 代表第 i 个字符到第 j 个字符是不是回文串
24 |         $dp = [];
25 | 
26 |         // 单字符
27 |         for ($i=0; $i < $n; $i++) { 
28 |             $dp[$i][$i] = true;
29 |             $res++;
30 |         }
31 | 
32 |         // 题目要求，相邻两数相同可计为一个子串
33 |         for ($i=0; $i < $n - 1; $i++) {
34 |             if($s[$i] == $s[$i + 1]){
35 |                 $dp[$i][$i+1] = true;
36 |                 $res++;
37 |             }
38 |         }
39 | 
40 |         // 从长度为3开始判断“常规的回文串”
41 |         for ($len=3; $len <= $n; $len++) { 
42 |             for ($i=0; $i + $len <= $n; $i++) { 
43 |                 // 当前长度的最后一位数的索引
44 |                 $j = $i + $len - 1;
45 |                 if ($s[$i] == $s[$j]) {
46 |                     // i == j 时，取决于中间部分 [i+1][j-1] 是否为回文串
47 |                     $dp[$i][$j] = $dp[$i + 1][$j - 1];
48 |                     if($dp[$i][$j]){
49 |                         $res++;
50 |                     }
51 |                 }
52 |             }
53 |         }
54 | 
55 |         return $res;
56 |     }
57 | }
58 | 
59 | // Accepted
60 | // 130/130 cases passed (216 ms)
61 | // Your runtime beats 47.83 % of php submissions
62 | // Your memory usage beats 100 % of php submissions (42.4 MB)
63 | // @lc code=end
64 | 
65 | 


--------------------------------------------------------------------------------
/12th动态规划/70.爬楼梯.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=70 lang=php
 4 |  *
 5 |  * [70] 爬楼梯
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/climbing-stairs/description/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer $n
15 |      * @return Integer
16 |      */
17 |     function climbStairs($n) {
18 | 
19 |         if($n <= 2){
20 |             return $n;
21 |         }
22 | 
23 |         $f1 = 1;
24 |         $f2 = 2;
25 |         for ($i=3; $i <= $n; $i++) { 
26 |             $f3 = $f2 + $f1;
27 |             $f1 = $f2;
28 |             $f2 = $f3;
29 |         }
30 | 
31 |         return $f3;
32 |     }
33 | }
34 | 
35 | // Accepted
36 | // 45/45 cases passed (8 ms)
37 | // Your runtime beats 59.76 % of php submissions
38 | // Your memory usage beats 100 % of php submissions (14.5 MB)
39 | // @lc code=end
40 | 
41 | 


--------------------------------------------------------------------------------
/12th动态规划/91.解码方法.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=91 lang=php
 4 |  *
 5 |  * [91] 解码方法
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/decode-ways/
 8 |  * 视频讲解 https://www.bilibili.com/video/BV17J411X76J?from=search&seid=13846823344681142254
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     /**
15 |      * @param String $s
16 |      * @return Integer
17 |      */
18 |     function numDecodings($s) {
19 |         
20 |         $n = strlen($s);
21 |         $dp = array_fill(0, $n, 0);
22 | 
23 |         if ($s[0] == '0') return 0;
24 |         $dp[0] = 1;//一个有效数只有一种解法
25 |         for ($i=1; $i < $n; $i++) { 
26 |             if ($s[$i] != '0') $dp[$i] = $dp[$i - 1];
27 |             if ($s[$i - 1] == '1' || ($s[$i - 1] == '2' && $s[$i] <= '6')) {
28 |                 // 有效范围内
29 |                 if ($i - 2 >= 0) {
30 |                     $dp[$i] = $dp[$i] + $dp[$i - 2];
31 |                 }else {
32 |                     $dp[$i] = $dp[$i] + 1;
33 |                 }
34 |             }
35 |         }
36 | 
37 |         return $dp[$n - 1];
38 |     }
39 | }
40 | 
41 | // Accepted
42 | // 258/258 cases passed (4 ms)
43 | // Your runtime beats 90.32 % of php submissions
44 | // Your memory usage beats 100 % of php submissions (14.9 MB)
45 | // @lc code=end
46 | 
47 | 


--------------------------------------------------------------------------------
/12th动态规划/README.md:
--------------------------------------------------------------------------------
1 | ### 专题知识点


--------------------------------------------------------------------------------
/13th字典树和并查集/200.岛屿数量.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=200 lang=php
 4 |  *
 5 |  * [200] 岛屿数量
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/number-of-islands/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 |     protected $m;
13 |     protected $n;
14 | 
15 |     /**
16 |      * @param String[][] $grid
17 |      * @return Integer
18 |      */
19 |     function numIslands($grid) {
20 | 
21 |         if (count($grid) == 0 || count($grid[0]) == 0) {
22 |             return 0;
23 |         }
24 | 
25 |         $this->m = count($grid);
26 |         $this->n = count($grid[0]);
27 |         $count = 0;
28 | 
29 |         for ($i=0; $i < $this->m; $i++) { 
30 |             for ($j=0; $j < $this->n; $j++) { 
31 |                 if ($grid[$i][$j] == '1') { // 当前为1的话，将其改为0，遍历相邻的四个点，遇到0退出，遇到1，dfs重复前面过程
32 |                     $count++;
33 |                     $this->dfs($grid, $i, $j);
34 |                 }
35 |             }
36 |         }
37 | 
38 |         return $count;
39 |     }
40 | 
41 |     function dfs(&$grid, $i, $j) {
42 | 
43 |         if ($i < 0 || $i >= $this->m || $j < 0 || $j >= $this->n || $grid[$i][$j] == '0') {
44 |             return true;
45 |         }
46 | 
47 |         $grid[$i][$j] = '0';
48 |         $this->dfs($grid, $i + 1, $j);
49 |         $this->dfs($grid, $i - 1, $j);
50 |         $this->dfs($grid, $i, $j - 1);
51 |         $this->dfs($grid, $i, $j + 1);
52 |     }
53 | }
54 | 
55 | // Accepted
56 | // 47/47 cases passed (52 ms)
57 | // Your runtime beats 58.33 % of php submissions
58 | // Your memory usage beats 88.89 % of php submissions (22.2 MB)
59 | // @lc code=end
60 | 
61 | 


--------------------------------------------------------------------------------
/13th字典树和并查集/547.朋友圈_BFS.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=547 lang=php
 4 |  *
 5 |  * [547] 朋友圈
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/friend-circles/
 8 |  * 参考 https://www.cnblogs.com/grandyang/p/6686983.html
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     /**
15 |      * @param Integer[][] $M
16 |      * @return Integer
17 |      */
18 |     function findCircleNum($M) {
19 | 
20 |         $n = count($M);
21 |         $res = 0;
22 | 
23 |         $visited = array_fill(0, $n, 0);
24 |         $queue = [];
25 | 
26 |         for ($i=0; $i < $n; $i++) { 
27 |             if ($visited[$i]) continue;
28 | 
29 |             array_push($queue, $i);
30 |             while (!empty($queue)) {
31 |                 $t = array_shift($queue);
32 |                 $visited[$t] = 1;
33 | 
34 |                 for ($j=0; $j < $n; $j++) { 
35 |                     if ($M[$t][$j] == 0 || $visited[$j]) continue;
36 | 
37 |                     array_push($queue, $j);
38 |                 }
39 |             }
40 | 
41 |             $res++;
42 |         }
43 | 
44 |         return $res;
45 |     }
46 | }
47 | 
48 | // Accepted
49 | // 113/113 cases passed (176 ms)
50 | // Your runtime beats 11.76 % of php submissions
51 | // Your memory usage beats 100 % of php submissions (17.1 MB)
52 | // @lc code=end


--------------------------------------------------------------------------------
/13th字典树和并查集/547.朋友圈_DFS.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=547 lang=php
 4 |  *
 5 |  * [547] 朋友圈
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/friend-circles/
 8 |  * 参考 https://www.cnblogs.com/grandyang/p/6686983.html
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     /**
15 |      * @param Integer[][] $M
16 |      * @return Integer
17 |      */
18 |     function findCircleNum($M) {
19 |         
20 |         $n = count($M);
21 |         $res = 0;
22 | 
23 |         $visited = array_fill(0, $n, 0);
24 | 
25 |         for ($i=0; $i < $n; $i++) { 
26 |             if ($visited[$i]) continue;
27 | 
28 |             $this->dfs($M, $i, $visited);
29 |             $res++;
30 |         }
31 | 
32 |         return $res;
33 |     }
34 | 
35 |     function dfs(&$M, $k, &$visited) {
36 | 
37 |         $visited[$k] = 1;
38 |         for ($i=0; $i < count($M); $i++) { 
39 |             if($M[$k][$i] == 0 || $visited[$i]) continue;
40 |             $this->dfs($M, $i, $visited);
41 |         }
42 |     }
43 | }
44 | 
45 | // Accepted
46 | // 113/113 cases passed (72 ms)
47 | // Your runtime beats 91.18 % of php submissions
48 | // Your memory usage beats 100 % of php submissions (17.2 MB)
49 | // @lc code=end
50 | 
51 | 


--------------------------------------------------------------------------------
/13th字典树和并查集/547.朋友圈_UnionFind.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=547 lang=php
 4 |  *
 5 |  * [547] 朋友圈
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/friend-circles/
 8 |  * 参考 https://www.cnblogs.com/grandyang/p/6686983.html
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     /**
15 |      * @param Integer[][] $M
16 |      * @return Integer
17 |      */
18 |     function findCircleNum($M) {
19 | 
20 |         $n = count($M);
21 |         $res = $n;
22 |         $root = array_fill(0, $n, 0);
23 |         for ($i=0; $i < $n; $i++) { 
24 |             $root[$i] = $i;
25 |         }
26 | 
27 |         for ($i=0; $i < $n; $i++) { 
28 |             for ($j=$i+1; $j < $n; $j++) { 
29 |                 if ($M[$i][$j] == 1) {
30 |                     $p1 = $this->getRoot($root, $i);
31 |                     $p2 = $this->getRoot($root, $j);
32 |                     if ($p1 != $p2) {
33 |                         $res--;
34 |                         $root[$p2] = $p1;
35 |                     }
36 |                 }
37 |             }
38 |         }
39 | 
40 |         return $res;
41 |     }
42 | 
43 |     function getRoot(&$root, $i) {
44 |         while ($i != $root[$i]) {
45 |             $root[$i] = $root[$root[$i]];
46 |             $i = $root[$i];
47 |         }
48 | 
49 |         return $i;
50 |     }
51 | }
52 | 
53 | // Accepted
54 | // 113/113 cases passed (80 ms)
55 | // Your runtime beats 64.71 % of php submissions
56 | // Your memory usage beats 100 % of php submissions (17.1 MB)
57 | // @lc code=end
58 | 
59 | 


--------------------------------------------------------------------------------
/13th字典树和并查集/README.md:
--------------------------------------------------------------------------------
1 | ### 专题知识点


--------------------------------------------------------------------------------
/14th高级搜索/22.括号生成.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=22 lang=php
 4 |  *
 5 |  * [22] 括号生成
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/generate-parentheses/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     protected $res;
14 | 
15 |     /**
16 |      * @param Integer $n
17 |      * @return String[]
18 |      */
19 |     function generateParenthesis($n) {
20 | 
21 |         $this->res = [];
22 | 
23 |         $this->dfs(0, 0, $n, "");
24 |         return $this->res;
25 |     }
26 | 
27 |     function dfs ($left, $right, $n, $s) {
28 | 
29 |         if ($left == $n && $right == $n) {
30 |             $this->res[] = $s;
31 |         }
32 | 
33 |         if ($left < $n) {
34 |             $this->dfs($left + 1, $right, $n, $s."(");
35 |         }
36 | 
37 |         if ($right < $left) {
38 |             $this->dfs($left, $right + 1, $n, $s.")");
39 |         }
40 |     }
41 | }
42 | 
43 | // Accepted
44 | // 8/8 cases passed (4 ms)
45 | // Your runtime beats 99.3 % of php submissions
46 | // Your memory usage beats 25 % of php submissions (15.5 MB)
47 | // @lc code=end
48 | 
49 | 


--------------------------------------------------------------------------------
/14th高级搜索/70.爬楼梯.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=70 lang=php
 4 |  *
 5 |  * [70] 爬楼梯
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/climbing-stairs/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer $n
15 |      * @return Integer
16 |      */
17 |     function climbStairs($n) {
18 |         // 想要到达第 n 级台阶，可以 n - 1 时走一步，或者 n - 2 时走两步
19 |         // 即第 n 级台阶的走法 为前两者之和
20 |         // 数学归纳为，非波那契数列
21 |         // f(n) = f(n - 1) +f(n - 2)
22 |         if ($n <= 2) {
23 |             return $n;
24 |         }
25 | 
26 |         $f1 = 1;
27 |         $f2 = 2;
28 |         for ($i=3; $i <= $n; $i++) { 
29 |             $f3 = $f1 + $f2;
30 |             $f1 = $f2;
31 |             $f2 = $f3;
32 |         }
33 | 
34 |         return $f3;
35 |     }
36 | }
37 | 
38 | // Accepted
39 | // 45/45 cases passed (8 ms)
40 | // Your runtime beats 59.4 % of php submissions
41 | // Your memory usage beats 25.81 % of php submissions (14.9 MB)
42 | // @lc code=end
43 | 
44 | 


--------------------------------------------------------------------------------
/14th高级搜索/README.md:
--------------------------------------------------------------------------------
1 | ### 专题知识点


--------------------------------------------------------------------------------
/15th红黑树和AVL树/README.md:
--------------------------------------------------------------------------------
1 | ### 专题知识点


--------------------------------------------------------------------------------
/16th位运算/190.颠倒二进制位.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=190 lang=php
 4 |  *
 5 |  * [190] 颠倒二进制位
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/reverse-bits/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 |     /**
13 |      * @param Integer $n
14 |      * @return Integer
15 |      */
16 |     function reverseBits($n) {
17 | 
18 |         $ans = 0;
19 |         $i = 32;
20 |         while ($i--) {
21 |             $ans = ($ans << 1) + ($n & 1);
22 |             $n = $n >> 1;
23 |         }
24 | 
25 |         return $ans;
26 |     }
27 | }
28 | 
29 | // Accepted
30 | // 600/600 cases passed (4 ms)
31 | // Your runtime beats 98.21 % of php submissions
32 | // Your memory usage beats 57.14 % of php submissions (14.7 MB)
33 | // @lc code=end
34 | 
35 | 


--------------------------------------------------------------------------------
/16th位运算/191.位-1-的个数.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=191 lang=php
 4 |  *
 5 |  * [191] 位1的个数
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/number-of-1-bits/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 |     /**
13 |      * @param Integer $n
14 |      * @return Integer
15 |      */
16 |     function hammingWeight($n) {
17 | 
18 |         // 模拟转二进制
19 |         $count = 0;
20 |         
21 |         while (0 < $n) {
22 |             if($n % 2 == 1){
23 |                 $count++;
24 |             }
25 |             $n = $n / 2;
26 |         }
27 | 
28 |         return $count;
29 |     }
30 | }
31 | 
32 | // Accepted
33 | // 601/601 cases passed (28 ms)
34 | // Your runtime beats 7.41 % of php submissions
35 | // Your memory usage beats 47.62 % of php submissions (14.8 MB)
36 | // @lc code=end
37 | 
38 | 


--------------------------------------------------------------------------------
/16th位运算/231.2-的幂.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=231 lang=php
 4 |  *
 5 |  * [231] 2的幂
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/power-of-two/
 8 |  * 参考 https://leetcode-cn.com/problems/power-of-two/solution/power-of-two-er-jin-zhi-ji-jian-by-jyd/
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     /**
15 |      * @param Integer $n
16 |      * @return Boolean
17 |      */
18 |     function isPowerOfTwo($n) {
19 | 
20 |         return $n > 0 && ($n & $n - 1) == 0;
21 |     }
22 | }
23 | 
24 | // Accepted
25 | // 1108/1108 cases passed (24 ms)
26 | // Your runtime beats 7.78 % of php submissions
27 | // Your memory usage beats 88.24 % of php submissions (14.7 MB)
28 | // @lc code=end
29 | 
30 | 


--------------------------------------------------------------------------------
/16th位运算/README.md:
--------------------------------------------------------------------------------
1 | ### 专题知识点


--------------------------------------------------------------------------------
/17th布隆过滤器和 LRU 缓存/README.md:
--------------------------------------------------------------------------------
1 | ### 专题知识点


--------------------------------------------------------------------------------
/18th排序算法/1122.数组的相对排序.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=1122 lang=php
 4 |  *
 5 |  * [1122] 数组的相对排序
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/relative-sort-array/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $arr1
15 |      * @param Integer[] $arr2
16 |      * @return Integer[]
17 |      */
18 |     function relativeSortArray($arr1, $arr2) {
19 |         // 哈希 + 排序
20 |         $count = [];
21 | 
22 |         foreach ($arr1 as $num1) { // 统计 arr1 数字出现的次数
23 |             $count[$num1] = isset($count[$num1]) ? $count[$num1] + 1 : 1;    
24 |         }
25 | 
26 |         $i = 0;
27 |         foreach ($arr2 as $num2) { // 将 arr2 先插入 arr1
28 |             if (isset($count[$num2])) {
29 |                 while($count[$num2] > 0) {
30 |                     $arr1[$i++] = $num2;
31 |                     $count[$num2] -= 1;
32 |                 }
33 |             }
34 |         }
35 | 
36 |         ksort($count); // 剩下的数排好序
37 |         foreach ($count as $num1 => $n) { // 顺序插入 arr1 
38 |             while ($n > 0) {
39 |                 $arr1[$i++] = $num1;
40 |                 $n--;
41 |             }
42 |         }
43 | 
44 |         return $arr1;
45 |     }
46 | }
47 | 
48 | // Accepted
49 | // 16/16 cases passed (8 ms)
50 | // Your runtime beats 78.57 % of php submissions
51 | // Your memory usage beats 14.29 % of php submissions (15.1 MB)
52 | // @lc code=end
53 | 
54 | 


--------------------------------------------------------------------------------
/18th排序算法/242.有效的字母异位词.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=242 lang=php
 4 |  *
 5 |  * [242] 有效的字母异位词
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/valid-anagram/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param String $s
15 |      * @param String $t
16 |      * @return Boolean
17 |      */
18 |     function isAnagram($s, $t) {
19 | 
20 |         if (strlen($s) != strlen($t)) return false;
21 | 
22 |         $wd = array_fill(0, 26, 0);
23 | 
24 |         // 先存入 s 各字母出现的次数
25 |         for ($i=0; $i < strlen($s); $i++) { 
26 |             $k = ord($s[$i]) - ord('a');
27 |             $wd[$k] = $wd[$k] + 1;
28 |         }
29 | 
30 |         // 如果 t 出现不存在或者数量不匹配的字母，长度相同的情况下则会减为负数，直接退出
31 |         for ($i=0; $i < strlen($t); $i++) { 
32 | 
33 |             if(--$wd[ord($t[$i]) - ord('a')] < 0) return false;
34 |         }
35 | 
36 |         return true;
37 |     }
38 | }
39 | 
40 | // Accepted
41 | // 34/34 cases passed (12 ms)
42 | // Your runtime beats 85.45 % of php submissions
43 | // Your memory usage beats 100 % of php submissions (14.9 MB)
44 | // @lc code=end
45 | 
46 | 


--------------------------------------------------------------------------------
/18th排序算法/56.合并区间.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=56 lang=php
 4 |  *
 5 |  * [56] 合并区间
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/merge-intervals/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[][] $intervals
15 |      * @return Integer[][]
16 |      */
17 |     function merge($intervals) {
18 | 
19 |         $res = [];
20 |         // 先排序二维数组的第一位
21 |         sort($intervals);
22 |         
23 |         $i = 0;
24 |         $len = count($intervals);
25 |         // 双指针
26 |         while ($i < $len) {
27 |             $t = $intervals[$i][1];
28 |             $j = $i + 1;
29 | 
30 |             // 当前区间重点大于等于后面区间起点，即可合并
31 |             while ($j < $len && $intervals[$j][0] <= $t) {
32 |                 $t = max($t, $intervals[$j][1]);
33 |                 $j++;
34 |             }
35 | 
36 |             $res[] = [$intervals[$i][0], $t];
37 |             $i = $j;
38 |         }
39 | 
40 |         return $res;
41 |     }
42 | }
43 | 
44 | // Accepted
45 | // 169/169 cases passed (40 ms)
46 | // Your runtime beats 70.72 % of php submissions
47 | // Your memory usage beats 47.83 % of php submissions (23.6 MB)
48 | // @lc code=end
49 | 
50 | 


--------------------------------------------------------------------------------
/18th排序算法/README.md:
--------------------------------------------------------------------------------
1 | ### 专题知识点


--------------------------------------------------------------------------------
/19th高级动态规划/115.不同的子序列.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=115 lang=php
 4 |  *
 5 |  * [115] 不同的子序列
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/distinct-subsequences/
 8 |  * 视频讲解 https://www.bilibili.com/video/BV1EW411d7PC?from=search&seid=14147502338216644722
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     /**
15 |      * @param String $s
16 |      * @param String $t
17 |      * @return Integer
18 |      */
19 |     function numDistinct($s, $t) {
20 |         
21 |         $lt = strlen($t); // 短串
22 |         $ls = strlen($s); // 长串
23 | 
24 |         // 加一位，方便递推输出结果
25 |         $dp = array_fill(0, $lt + 1, array_fill(0, $ls + 1, 0));
26 | 
27 |         // 初始化
28 |         for ($i=0; $i < $ls + 1; $i++) { 
29 |             $dp[0][$i] = 1; // 表示当 T 为空字符串时，无论 S 长度多少，构成 T 都只有一种情况
30 |         }
31 | 
32 |         for ($i=1; $i < $lt + 1; $i++) { 
33 |             for ($j=1; $j < $ls + 1; $j++) { 
34 |                 if ($t[$i - 1] == $s[$j - 1]) {
35 |                     // 当前两个字符相等时，可以选择使用第 j 位字符去匹配 i, 那么接下来就需要 S 的前 j - 1 位去匹配 T 的前 i - 1 位
36 |                     // 也可以选择不使用第 j 位字符去匹配 i，那么它只能用S 的前 j - 1 位去匹配 T 的前 i 位
37 |                     $dp[$i][$j] = $dp[$i - 1][$j - 1] + $dp[$i][$j - 1];
38 |                 } else {
39 |                     // 当前两个字符不等时，只能是舍弃 S 的第 j 位，使用前 j - 1位去匹配 T 的前 i 位
40 |                     $dp[$i][$j] = $dp[$i][$j - 1];
41 |                 }
42 |             }
43 |         }
44 | 
45 |         return $dp[$lt][$ls];
46 |     }
47 | }
48 | 
49 | // Accepted
50 | // 63/63 cases passed (48 ms)
51 | // Your runtime beats 80 % of php submissions
52 | // Your memory usage beats 100 % of php submissions (31.9 MB)
53 | // @lc code=end
54 | 
55 | 


--------------------------------------------------------------------------------
/19th高级动态规划/300.最长上升子序列.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=300 lang=php
 4 |  *
 5 |  * [300] 最长上升子序列
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/longest-increasing-subsequence/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $nums
15 |      * @return Integer
16 |      */
17 |     function lengthOfLIS($nums) {
18 | 
19 |         $len = count($nums);
20 |         if ($len < 2) {
21 |             return $len;
22 |         }
23 | 
24 |         $dp = array_fill(0, $len, 1);
25 |         for ($i=1; $i < $len; $i++) { 
26 |             for ($j=0; $j < $i; $j++) { 
27 |                 if ($nums[$j] < $nums[$i]) {
28 |                     $dp[$i] = max($dp[$i], $dp[$j] + 1);
29 |                 }
30 |             }
31 |         }
32 | 
33 |         // $res = 0;
34 |         // for ($i=0; $i < $len; $i++) { 
35 |         //     $res = max($dp[$i], $res);
36 |         // }
37 |         // return $res;
38 | 
39 |         sort($dp);
40 |         return $dp[$len - 1];
41 |     }
42 | }
43 | 
44 | // Accepted
45 | // 24/24 cases passed (416 ms)
46 | // Your runtime beats 6.25 % of php submissions
47 | // Your memory usage beats 71.43 % of php submissions (15.2 MB)
48 | // @lc code=end
49 | 
50 | 


--------------------------------------------------------------------------------
/19th高级动态规划/32.最长有效括号.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=32 lang=php
 4 |  *
 5 |  * [32] 最长有效括号
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/longest-valid-parentheses/
 8 |  * 视频讲解 https://www.bilibili.com/video/BV1Ct4y197M3?from=search&seid=7250467796583559575
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     /**
15 |      * @param String $s
16 |      * @return Integer
17 |      */
18 |     function longestValidParentheses($s) {
19 |         
20 |         $n = strlen($s);
21 |         // dp[i] 代表以当前字符结尾构成有效括号子串的长度是多少
22 |         $dp = array_fill(0, $n, 0);
23 |         $max = 0;
24 | 
25 |         for ($i=1; $i < $n; $i++) { 
26 |             // 以左括号结尾肯定不是有效子串，跳过
27 |             if ($s[$i] == ')') {
28 |                 // 前一个子串有效的条件
29 |                 if ($i - $dp[$i - 1] > 0 && $s[$i - $dp[$i - 1] - 1] == '(') {
30 |                     // 当前有效长度 + 前一个有效长度 + 前前一个有效长度
31 |                     $dp[$i] = 2 + $dp[$i - 1] + ($i - $dp[$i - 1] - 2 > -1 ? $dp[$i - $dp[$i - 1] - 2] : 0);
32 |                 }
33 |             }
34 | 
35 |             $max = max($max, $dp[$i]);
36 |         }
37 | 
38 |         return $max;
39 |     }
40 | }
41 | 
42 | // Accepted
43 | // 230/230 cases passed (12 ms)
44 | // Your runtime beats 88.7 % of php submissions
45 | // Your memory usage beats 17.39 % of php submissions (15.7 MB)
46 | // @lc code=end
47 | 
48 | 


--------------------------------------------------------------------------------
/19th高级动态规划/818.赛车_超时.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=818 lang=php
 4 |  *
 5 |  * [818] 赛车
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/race-car/
 8 |  * 视频讲解 https://www.bilibili.com/video/BV1cW411o7Tb?from=search&seid=13287282426872130045
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     /**
15 |      * @param Integer $target
16 |      * @return Integer
17 |      */
18 |     function racecar($target) {
19 |         // BFS
20 |         $q = [];
21 |         array_push($q, [0, 1]);
22 | 
23 |         $v = [
24 |             "0_1"  => 1,
25 |             "0_-1" => 1
26 |         ];
27 |         $steps = 0;
28 |         while (!empty($q)) {
29 |             $size = count($q);
30 |             while ($size--) {
31 |                 $p = array_shift($q);
32 |                 $pos = $p[0];
33 |                 $speed = $p[1];
34 | 
35 |                 $pos1 = $pos + $speed;
36 |                 $speed1 = $speed * 2;
37 |                 $p1 = [$pos1, $speed1];
38 |                 if ($pos1 == $target) return $steps + 1;
39 |                 if ($p1[0] > 0 && $p1[0] < 2 * $target) { // 剪枝
40 |                     array_push($q, $p1);
41 |                 }
42 | 
43 |                 $speed2 = $speed > 0 ? -1 : 1;
44 |                 $p2 = [$pos, $speed2];
45 |                 $key2 = (string)($pos."_".$speed2);
46 |                 if (!array_key_exists($key2, $v)) {
47 |                     array_push($q, $p2);
48 |                     $v[$key2] = 1;
49 |                 }
50 |             }
51 |             $steps++;
52 |         }
53 | 
54 |         return -1;
55 |     }
56 | }
57 | // @lc code=end
58 | 
59 | 


--------------------------------------------------------------------------------
/19th高级动态规划/README.md:
--------------------------------------------------------------------------------
1 | ### 专题知识点


--------------------------------------------------------------------------------
/20th字符串算法/151.翻转字符串里的单词.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=151 lang=php
 4 |  *
 5 |  * [151] 翻转字符串里的单词
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/reverse-words-in-a-string/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param String $s
15 |      * @return String
16 |      */
17 |     function reverseWords($s) {
18 | 
19 |         if(trim($s) === "") return "";
20 | 
21 |         $str_arr = explode(" ", trim($s));
22 |         $str = "";
23 | 
24 |         for ($i=count($str_arr) - 1; $i >= 0; $i--) {
25 |             if(trim($str_arr[$i]) == "") continue;
26 |             $str .= trim($str_arr[$i])." ";
27 |         }
28 | 
29 |         return substr($str, 0, -1);
30 |     }
31 | }
32 | 
33 | // Accepted
34 | // 25/25 cases passed (8 ms)
35 | // Your runtime beats 88.46 % of php submissions
36 | // Your memory usage beats 100 % of php submissions (15.1 MB)
37 | // @lc code=end
38 | 
39 | 


--------------------------------------------------------------------------------
/20th字符串算法/205.同构字符串.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=205 lang=php
 4 |  *
 5 |  * [205] 同构字符串
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/isomorphic-strings/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param String $s
15 |      * @param String $t
16 |      * @return Boolean
17 |      */
18 |     function isIsomorphic($s, $t) {
19 | 
20 |         // 验证 s -> t 、t -> s 两个方向，均为同构才为真
21 |         // 例如 s = "ab"、t = "aa"
22 |         return $this->helper($s, $t) && $this->helper($t, $s);
23 |     }
24 | 
25 |     function helper($s, $t) {
26 | 
27 |         $len = strlen($s);
28 |         $map = [];
29 |         for ($i=0; $i < $len; $i++) { 
30 |             if (array_key_exists($s[$i], $map)) {
31 |                 if ($map[$s[$i]] != $t[$i]) return false;
32 |             } else {
33 |                 $map[$s[$i]] = $t[$i];
34 |             }
35 |         }
36 | 
37 |         return true;
38 |     }
39 | }
40 | 
41 | // Accepted
42 | // 32/32 cases passed (12 ms)
43 | // Your runtime beats 68 % of php submissions
44 | // Your memory usage beats 87.5 % of php submissions (14.8 MB)
45 | // @lc code=end
46 | 
47 | 


--------------------------------------------------------------------------------
/20th字符串算法/387.字符串中的第一个唯一字符.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=387 lang=php
 4 |  *
 5 |  * [387] 字符串中的第一个唯一字符
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/first-unique-character-in-a-string/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param String $s
15 |      * @return Integer
16 |      */
17 |     function firstUniqChar($s) {
18 | 
19 |         $n = strlen($s);
20 |         $ss = [];
21 | 
22 |         // 先统计个数
23 |         for ($i=0; $i < $n; $i++) {
24 |             if (!array_key_exists($s[$i], $ss)) {
25 |                 $ss[$s[$i]] = 1;
26 |             } else {
27 |                 $ss[$s[$i]] += 1;
28 |             }
29 |         }
30 | 
31 |         // 遍历查找索引位置
32 |         for ($i=0; $i < $n; $i++) { 
33 |             if ($ss[$s[$i]] == 1) {
34 |                 return $i;
35 |             }
36 |         }
37 | 
38 |         return -1;
39 |     }
40 | }
41 | 
42 | // Accepted
43 | // 104/104 cases passed (56 ms)
44 | // Your runtime beats 45.45 % of php submissions
45 | // Your memory usage beats 63.64 % of php submissions (15.2 MB)
46 | // @lc code=end
47 | 
48 | 


--------------------------------------------------------------------------------
/20th字符串算法/438.找到字符串中所有字母异位词.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=438 lang=php
 4 |  *
 5 |  * [438] 找到字符串中所有字母异位词
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/find-all-anagrams-in-a-string/
 8 |  * 视频讲解 https://www.bilibili.com/video/BV1iW411d7Nb?from=search&seid=17366439816996839570
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     /**
15 |      * @param String $s
16 |      * @param String $p
17 |      * @return Integer[]
18 |      */
19 |     function findAnagrams($s, $p) {
20 |         
21 |         $s_len = strlen($s);
22 |         $p_len = strlen($p);
23 |         
24 |         $ans = [];
25 |         $vp = array_fill(0, 26, 0);
26 |         $vs = array_fill(0, 26, 0);
27 | 
28 |         $idx = 0;
29 |         while ($idx < $p_len) {
30 |             ++$vp[ord($p[$idx]) - ord('a')];
31 |             $idx++;
32 |         }
33 | 
34 |         for ($i=0; $i < $s_len; $i++) { 
35 |             if ($i >= $p_len) --$vs[ord($s[$i - $p_len]) - ord('a')];
36 |             ++$vs[ord($s[$i]) - ord('a')];
37 |             if ($vs == $vp) $ans[] =  $i + 1 - $p_len;
38 |         }
39 | 
40 |         return $ans;
41 |     }
42 | }
43 | 
44 | // Accepted
45 | // 36/36 cases passed (40 ms)
46 | // Your runtime beats 33.33 % of php submissions
47 | // Your memory usage beats 100 % of php submissions (15.8 MB)
48 | // @lc code=end
49 | 
50 | 


--------------------------------------------------------------------------------
/20th字符串算法/541.反转字符串-ii.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=541 lang=php
 4 |  *
 5 |  * [541] 反转字符串 II
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/reverse-string-ii/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param String $s
15 |      * @param Integer $k
16 |      * @return String
17 |      */
18 |     function reverseStr($s, $k) {
19 |         
20 |         $n = strlen($s);
21 |         $i = 0;
22 |         $ss = [];
23 | 
24 |         while ($i < $n) {
25 |             if ($n - $i < 2 * $k) {
26 |                 if ($n - $i < $k) { // 剩余字符长度不足 k，全部翻转
27 |                     $ss[] = strrev(substr($s, $i));
28 |                 } else { // 剩余字符长度大于 k，小于 2k，仅翻转前 k 个
29 |                     $ss[] = strrev(substr($s, $i, $k));
30 |                     $ss[] = substr($s, $i + $k);
31 |                 }
32 |             } else { // 普通情况，仅翻转前 k 个
33 |                 $ss[] = strrev(substr($s, $i, $k));
34 |                 $ss[] = substr($s, $i + $k, $k);
35 |             }
36 |             
37 |             $i = $i + 2 * $k;
38 |         }
39 | 
40 |         return implode("", $ss);
41 |     }
42 | }
43 | 
44 | // Accepted
45 | // 60/60 cases passed (8 ms)
46 | // Your runtime beats 86.36 % of php submissions
47 | // Your memory usage beats 35.71 % of php submissions (15.1 MB)
48 | // @lc code=end
49 | 
50 | 


--------------------------------------------------------------------------------
/20th字符串算法/557.反转字符串中的单词-iii.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=557 lang=php
 4 |  *
 5 |  * [557] 反转字符串中的单词 III
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/reverse-words-in-a-string-iii/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param String $s
15 |      * @return String
16 |      */
17 |     function reverseWords($s) {
18 |         
19 |         if(trim($s) == "") return "";
20 | 
21 |         $str_arr = explode(" ", $s);
22 |         $str = "";
23 | 
24 |         for ($i=0; $i < count($str_arr); $i++) { 
25 |             $str .= strrev($str_arr[$i])." ";
26 |         }
27 | 
28 |         return substr($str, 0, -1);
29 |     }
30 | }
31 | 
32 | // Accepted
33 | // 30/30 cases passed (8 ms)
34 | // Your runtime beats 96.08 % of php submissions
35 | // Your memory usage beats 90.91 % of php submissions (15 MB)
36 | // @lc code=end
37 | 
38 | 


--------------------------------------------------------------------------------
/20th字符串算法/8.字符串转换整数-atoi.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=8 lang=php
 4 |  *
 5 |  * [8] 字符串转换整数 (atoi)
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/string-to-integer-atoi/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param String $str
15 |      * @return Integer
16 |      */
17 |     function myAtoi($str) {
18 |         $str = ltrim($str);
19 |         $stra = str_split($str);
20 |         $i = 0;
21 |         while ($i<count($stra)) {
22 |             if (preg_match ("/^[a-z]/", $stra[$i])) {
23 |                 $stra = array_slice($stra,0,$i);
24 |                 break;
25 |             }
26 |             $i++;
27 |         }
28 |         if (count($stra) == 0) {
29 |             return 0;
30 |         }else {
31 |             $str = implode($stra);
32 |             if ($str>=pow(2, 31)) {
33 |                 return pow(2, 31)-1;
34 |             }elseif($str< -pow(2, 31)){
35 |                 return -pow(2, 31);
36 |             }
37 |             return intval($str);
38 |         }
39 |     }
40 | }
41 | 
42 | // Accepted
43 | // 1079/1079 cases passed (8 ms)
44 | // Your runtime beats 83.33 % of php submissions
45 | // Your memory usage beats 33.33 % of php submissions (15 MB)
46 | // @lc code=end
47 | 
48 | 


--------------------------------------------------------------------------------
/20th字符串算法/README.md:
--------------------------------------------------------------------------------
1 | ### 专题知识点


--------------------------------------------------------------------------------
/21剑指offer系列/README.md:
--------------------------------------------------------------------------------
1 | ### 剑指offer系列
2 | 
3 | https://leetcode-cn.com/problemset/lcof/
4 | 


--------------------------------------------------------------------------------
/22程序员面试经典/README.md:
--------------------------------------------------------------------------------
1 | ### 程序员面试经典
2 | 
3 | https://leetcode-cn.com/problemset/lcci/
4 | 


--------------------------------------------------------------------------------
/23刷题路线/128.最长连续序列.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=128 lang=php
 4 |  *
 5 |  * [128] 最长连续序列
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/longest-consecutive-sequence/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $nums
15 |      * @return Integer
16 |      */
17 |     function longestConsecutive($nums) {
18 |     
19 |         $nums = array_unique($nums); // 去重
20 |         $longestStreak = 0; // 初始长度
21 | 
22 |         foreach ($nums as $val) {
23 |             // 剪掉 x - 1 的无意义查询
24 |             if (!in_array($val - 1, $nums)) { // 值查询
25 |                 $currentNum = $val;
26 |                 $currentStreak = 1;
27 | 
28 |                 while (in_array($currentNum + 1, $nums)) {
29 |                     $currentNum += 1;
30 |                     $currentStreak += 1;
31 |                 }
32 | 
33 |                 $longestStreak = max($longestStreak, $currentStreak);
34 |             }
35 |         }
36 | 
37 |         return $longestStreak;
38 |     }
39 | }
40 | 
41 | // Accepted
42 | // 68/68 cases passed (124 ms)
43 | // Your runtime beats 10.87 % of php submissions
44 | // Your memory usage beats 14.29 % of php submissions (16.6 MB)
45 | // 比键查询慢很多
46 | // @lc code=end
47 | 
48 | 
49 | 
50 | 


--------------------------------------------------------------------------------
/23刷题路线/128.最长连续序列_加速.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=128 lang=php
 4 |  *
 5 |  * [128] 最长连续序列
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/longest-consecutive-sequence/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $nums
15 |      * @return Integer
16 |      */
17 |     function longestConsecutive($nums) {
18 |     
19 |         $num_set = [];
20 |         foreach ($nums as $val) { // 去重
21 |             $num_set[$val] = 1;
22 |         }
23 | 
24 |         $longestStreak = 0; // 初始长度
25 | 
26 |         foreach ($num_set as $key => $val) {
27 |             // 剪掉 x - 1 的无意义查询
28 |             if (!array_key_exists($key - 1, $num_set)) { // 键查询更快
29 |                 $currentNum = $key;
30 |                 $currentStreak = 1;
31 | 
32 |                 while (array_key_exists($currentNum + 1, $num_set)) {
33 |                     $currentNum += 1;
34 |                     $currentStreak += 1;
35 |                 }
36 | 
37 |                 $longestStreak = max($longestStreak, $currentStreak);
38 |             }
39 |         }
40 | 
41 |         return $longestStreak;
42 |     }
43 | }
44 | 
45 | // Accepted
46 | // 68/68 cases passed (24 ms)
47 | // Your runtime beats 22.46 % of php submissions
48 | // Your memory usage beats 57.14 % of php submissions (15.9 MB)
49 | // @lc code=end
50 | 
51 | 


--------------------------------------------------------------------------------
/23刷题路线/[基础]1.两数之和.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=1 lang=php
 4 |  *
 5 |  * [1] 两数之和
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/two-sum/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $nums
15 |      * @param Integer $target
16 |      * @return Integer[]
17 |      */
18 |     function twoSum($nums, $target) {
19 |         
20 |         $tmp = [];
21 |         foreach ($nums as $k => $num) {
22 |             
23 |             if (array_key_exists($target - $num, $tmp)) {
24 |                 if ($nums[$tmp[$target - $num]] + $num === $target) {
25 |                     return [$tmp[$target - $num], $k];
26 |                 }
27 |             } 
28 | 
29 |             $tmp[$num] = $k;
30 |         }
31 | 
32 |         return [];
33 |     }
34 | }
35 | 
36 | // Accepted
37 | // 29/29 cases passed (16 ms)
38 | // Your runtime beats 80.43 % of php submissions
39 | // Your memory usage beats 22.89 % of php submissions (16 MB)
40 | // @lc code=end
41 | 
42 | 


--------------------------------------------------------------------------------
/23刷题路线/[基础]20.有效的括号.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=20 lang=php
 4 |  *
 5 |  * [20] 有效的括号
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/valid-parentheses/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param String $s
15 |      * @return Boolean
16 |      */
17 |     function isValid($s) {
18 |         
19 |         $map = [
20 |             "[" => "]",
21 |             "{" => "}",
22 |             "(" => ")",
23 |             "?" => "?"
24 |         ];
25 | 
26 |         $stack = ["?"];
27 | 
28 |         for ($i=0; $i < strlen($s); $i++) { 
29 | 
30 |             if (array_key_exists($s[$i], $map)) { // 左括号入栈
31 |                 $stack[] = $s[$i];
32 |             } elseif ($map[array_pop($stack)] != $s[$i]) { // 非左括号出栈判断是否右括号
33 |                 return false;
34 |             }
35 |         }
36 | 
37 |         return count($stack) == 1;
38 |     }
39 | }
40 | 
41 | // Accepted
42 | // 91/91 cases passed (8 ms)
43 | // Your runtime beats 77.9 % of php submissions
44 | // Your memory usage beats 40.68 % of php submissions (15.1 MB)
45 | // @lc code=end
46 | 
47 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # leetcode 精选题目&题解
 2 | 
 3 | ### 如何做题？
 4 | 
 5 | - https://leetcode-cn.com/problemset/all/ 搜索对应题号即可
 6 | 
 7 | - https://www.cnblogs.com/gl1573/p/11262333.html 如何在 vscode 上做题并测试、提交
 8 | 
 9 | ### 刷题技巧
10 | 
11 | 误区：一道题只做一遍
12 | 
13 | 建议：一道题最好独立做五遍以上，第一遍如果没有思路，可以借鉴题解区或者评论区的优秀解法，切忌死磕，保证测试用例完全通过；第二遍整理思路，靠自己手写；隔一段时间做第三遍、第四遍、第五遍；坚持刻意练习，以达到强化算法思维训练的目的。
14 | 
15 | ### 文章
16 | 
17 | [算法学习之旅，终点亦是起点](https://learnku.com/articles/49105)
18 | 


--------------------------------------------------------------------------------
/每日1题202007/README.md:
--------------------------------------------------------------------------------
1 | # leetcode 每日1题


--------------------------------------------------------------------------------
/每日1题202007/[0713]350.两个数组的交集-ii.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=350 lang=php
 4 |  *
 5 |  * [350] 两个数组的交集 II
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/intersection-of-two-arrays-ii/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $nums1
15 |      * @param Integer[] $nums2
16 |      * @return Integer[]
17 |      */
18 |     function intersect($nums1, $nums2) {
19 |         
20 |         sort($nums1);
21 |         sort($nums2);
22 | 
23 |         $idx1 = 0;
24 |         $idx2 = 0;
25 |         $res = [];
26 | 
27 |         while($idx1 < count($nums1) && $idx2 < count($nums2)) {
28 | 
29 |             if($nums1[$idx1] == $nums2[$idx2]) {
30 |                 $res[] = $nums1[$idx1];
31 |                 $idx1++;
32 |                 $idx2++;
33 |                 continue;
34 |             }
35 | 
36 |             if($nums1[$idx1] > $nums2[$idx2]) {
37 |                 $idx2++;
38 |             }else{
39 |                 $idx1++;
40 |             }
41 |         }
42 | 
43 |         return $res;
44 |     }
45 | }
46 | 
47 | // Accepted
48 | // 61/61 cases passed (16 ms)
49 | // Your runtime beats 74.03 % of php submissions
50 | // Your memory usage beats 50 % of php submissions (15.3 MB)
51 | // @lc code=end
52 | 
53 | 


--------------------------------------------------------------------------------
/每日1题202007/[0715]96.不同的二叉搜索树.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=96 lang=php
 4 |  *
 5 |  * [96] 不同的二叉搜索树
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/unique-binary-search-trees/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer $n
15 |      * @return Integer
16 |      */
17 |     function numTrees($n) {
18 | 
19 |         $dp = [];
20 |         $dp[0] = 1;// 空子树
21 |         $dp[1] = 1;
22 | 
23 |         // 状态转移方程
24 |         for ($i=2; $i <= $n; $i++) {
25 |             $dp[$i] = 0;
26 |             for ($j=1; $j <= $i; $j++) { 
27 |                 // BST，左子树的值小于根节点，右子树的值大于根节点
28 |                 // 尝试将 $i 范围内每个数都作为根节点，
29 |                 // 当前根节点能组成的 BST 数 = 左子树个数 * 右子树个数
30 |                 // 将这些结果累加，就得到 $dp[$i] 的结果
31 |                 $dp[$i] += $dp[$j - 1] * $dp[$i - $j];
32 |             }
33 |         }
34 |         
35 |         return $dp[$n];
36 |     }
37 | }
38 | 
39 | // Accepted
40 | // 19/19 cases passed (8 ms)
41 | // Your runtime beats 66.28 % of php submissions
42 | // Your memory usage beats 100 % of php submissions (14.9 MB)
43 | // @lc code=end
44 | 
45 | 


--------------------------------------------------------------------------------
/每日1题202007/[0717]35.搜索插入位置.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=35 lang=php
 4 |  *
 5 |  * [35] 搜索插入位置
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/search-insert-position/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $nums
15 |      * @param Integer $target
16 |      * @return Integer
17 |      */
18 |     function searchInsert($nums, $target) {
19 |         
20 |         $start = 0;
21 |         $end = count($nums) - 1;
22 | 
23 |         if($end < 0) {
24 |             return 0;
25 |         }
26 | 
27 |         if($nums[$end] < $target){
28 |             return $end + 1;
29 |         }
30 | 
31 |         while($start < $end) {
32 | 
33 |             $mid = $start + floor(($end - $start) >> 1);
34 | 
35 |             // 严格小于 target 的元素一定不是解
36 |             if($nums[$mid] < $target){
37 |                 $start = $mid + 1;
38 |             }else{
39 |                 $end = $mid;
40 |             }
41 |         }
42 | 
43 |         return $start;
44 |     }
45 | }
46 | 
47 | // Accepted
48 | // 62/62 cases passed (16 ms)
49 | // Your runtime beats 60.71 % of php submissions
50 | // Your memory usage beats 100 % of php submissions (15.6 MB)
51 | // @lc code=end
52 | 
53 | 


--------------------------------------------------------------------------------
/每日1题202007/[0719]312.戳气球_动态规划DP.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=312 lang=php
 4 |  *
 5 |  * [312] 戳气球
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/burst-balloons/
 8 |  * 视频讲解 https://www.bilibili.com/video/av45180542
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     protected $dp;
15 |     /**
16 |      * @param Integer[] $nums
17 |      * @return Integer
18 |      */
19 |     function maxCoins($nums) {
20 | 
21 |         $n = count($nums);
22 |         // 根据题目说明，首尾推入1，保证递归有效
23 |         $nums = array_merge([1], $nums);
24 |         $nums[] = 1;
25 |         // 填充二维数组
26 |         $this->dp = array_fill(0, $n+2, array_fill(0, $n+2, 0));
27 |         $res = $this->helper($nums, 1, $n);
28 |         return $res;
29 |     }
30 | 
31 |     function helper(&$nums, $i, $j) {
32 |         // boundary
33 |         if($i > $j) return 0;
34 |         if($this->dp[$i][$j] > 0) return $this->dp[$i][$j];
35 | 
36 |         // search
37 |         // 优先戳破左边和右边的气球，再戳破当前气球，可以看出左右两个子问题是独立的，并且只和当前气球关联
38 |         // 每个子问题里，k 的范围是 i => j
39 |         // 定义状态转移方程：dp[i][j] = dp[i][k-1] + dp[k+1][j] + nums[k] * nums[i-1] * nums[j+1]
40 |         for ($k=$i; $k <= $j; $k++) { 
41 |             $left = $this->helper($nums, $i, $k - 1);
42 |             $right = $this->helper($nums, $k + 1, $j);
43 |             $delta = $nums[$k] * $nums[$i - 1] * $nums[$j + 1];
44 |             
45 |             $this->dp[$i][$j] = max($this->dp[$i][$j], $left + $right + $delta);
46 |         }
47 | 
48 |         return $this->dp[$i][$j];
49 |     }
50 | }
51 | 
52 | // Accepted
53 | // 70/70 cases passed (288 ms)
54 | // Your runtime beats 84.62 % of php submissions
55 | // Your memory usage beats 100 % of php submissions (16.5 MB)
56 | // @lc code=end
57 | 
58 | 


--------------------------------------------------------------------------------
/每日1题202007/[0719]312.戳气球_回溯法(超时).php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=312 lang=php
 4 |  *
 5 |  * [312] 戳气球
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/burst-balloons/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $nums
15 |      * @return Integer
16 |      */
17 |     function maxCoins($nums) {
18 | 
19 |         $res = 0;
20 |         $this->helper($nums, 0, $res);
21 |         return $res;
22 |     }
23 | 
24 |     function helper(&$nums, $coins, &$res) {
25 |         $len = count($nums);
26 | 
27 |         // boundary
28 |         if($len == 0) {
29 |             $res = max($res, $coins);
30 |             return true;
31 |         }
32 | 
33 |         // search
34 |         // 每一层可选择戳破的气球数
35 |         for ($i=0; $i < $len; $i++) { 
36 |             $delta = $nums[$i] * ($i - 1 < 0 ? 1 : $nums[$i-1]) * 
37 |                         ($i + 1 > $len - 1 ? 1 : $nums[$i+1]);
38 |             
39 |             $nums_copy = $nums;
40 |             unset($nums_copy[$i]);
41 |             $nums_copy = array_merge($nums_copy, []);
42 |             $this->helper($nums_copy, $coins + $delta, $res);
43 |         }
44 |     }
45 | 
46 |     // function array_insert($arr, $value, $position = 0) {
47 | 
48 |     //     $fore = ($position == 0) ? array() : array_splice($arr, 0, $position);
49 |     //     $fore[] = $value;
50 |     //     $ret = array_merge($fore, $arr);
51 | 
52 |     //     return $ret;
53 |     // }
54 | }
55 | 
56 | // 回溯法，超时
57 | // Time Limit Exceeded
58 | // 20/70 cases passed (N/A)
59 | 
60 | // Time Limit Exceeded
61 | // 24/70 cases passed (N/A)
62 | // @lc code=end
63 | 
64 | 


--------------------------------------------------------------------------------
/每日1题202007/[0720]167.两数之和-ii-输入有序数组.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=167 lang=php
 4 |  *
 5 |  * [167] 两数之和 II - 输入有序数组
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/two-sum-ii-input-array-is-sorted/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $numbers
15 |      * @param Integer $target
16 |      * @return Integer[]
17 |      */
18 |     function twoSum($numbers, $target) {
19 | 
20 |         $result = [];
21 |         foreach ($numbers as $k => $v) {
22 | 
23 |             if(isset($result[$target - $v])){
24 |                 return [$result[$target - $v], $k+1];
25 |             }
26 | 
27 |             $result[$v] = $k+1;
28 |         }
29 |     }
30 | }
31 | 
32 | // Accepted
33 | // 17/17 cases passed (12 ms)
34 | // Your runtime beats 97.3 % of php submissions
35 | // Your memory usage beats 100 % of php submissions (16.6 MB)
36 | // @lc code=end
37 | 
38 | 


--------------------------------------------------------------------------------
/每日1题202007/[0722]剑指 Offer 11. 旋转数组的最小数字.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * 剑指 Offer 11. 旋转数组的最小数字
 4 |  * 
 5 |  * https://leetcode-cn.com/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof/
 6 |  */
 7 | 
 8 | class Solution {
 9 | 
10 |     /**
11 |      * @param Integer[] $numbers
12 |      * @return Integer
13 |      */
14 |     function minArray($numbers) {
15 | 
16 |         $end = count($numbers) - 1;
17 | 
18 |         // 只有一个数时
19 |         if($end <= 0) {
20 |             return $numbers[0];
21 |         }
22 | 
23 |         // 升序数组，大于两个数时，优先比较首位顺序
24 |         if($numbers[0] < $numbers[$end]) {
25 |             return $numbers[0];
26 |         }
27 | 
28 |         while($end >= 1){
29 | 
30 |             if($numbers[$end] < $numbers[$end - 1]) {
31 |                 return $numbers[$end];
32 |             }
33 | 
34 |             if($numbers[$end] == $numbers[$end - 1] && $end - 2 < 0) {
35 |                 return $numbers[$end];
36 |             }
37 | 
38 |             $end--;
39 |         }
40 |     }
41 | }
42 | 
43 | // 执行结果：通过
44 | // 执行用时： 12 ms, 在所有 PHP 提交中击败了 97.59% 的用户
45 | // 内存消耗： 15.5 MB, 在所有 PHP 提交中击败了 100.00% 的用户


--------------------------------------------------------------------------------
/每日1题202007/[0723]64.最小路径和.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=64 lang=php
 4 |  *
 5 |  * [64] 最小路径和
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/minimum-path-sum/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[][] $grid
15 |      * @return Integer
16 |      */
17 |     function minPathSum($grid) {
18 |         
19 |         $m = count($grid);
20 |         $n = count($grid[0]);
21 |         if($grid == null || $m == 0 || $n ==0) {
22 |             return 0;
23 |         }
24 | 
25 |         $dp[0][0] = $grid[0][0];
26 | 
27 |         // 初始化边界
28 |         for ($i=1; $i < $m; $i++) { 
29 |             $dp[$i][0]  = $dp[$i - 1][0] + $grid[$i][0];
30 |         }
31 | 
32 |         for ($j=1; $j < $n; $j++) { 
33 |             $dp[0][$j]  = $dp[0][$j - 1] + $grid[0][$j];
34 |         }
35 | 
36 |         // 状态转移方程
37 |         for ($i=1; $i < $m; $i++) { 
38 |             for ($j=1; $j < $n; $j++) {
39 |                 // 从上往下走或者从左往右走，选出较小的一条路径
40 |                 $dp[$i][$j] = min($dp[$i - 1][$j], $dp[$i][$j - 1]) + $grid[$i][$j];
41 |             }
42 |         }
43 | 
44 |         return $dp[$m-1][$n-1];
45 |     }
46 | }
47 | 
48 | // Accepted
49 | // 61/61 cases passed (28 ms)
50 | // Your runtime beats 96.05 % of php submissions
51 | // Your memory usage beats 100 % of php submissions (18.6 MB)
52 | // @lc code=end
53 | 
54 | 


--------------------------------------------------------------------------------
/每日1题202007/[0724]1025.除数博弈.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=1025 lang=php
 4 |  *
 5 |  * [1025] 除数博弈
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/divisor-game/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer $N
15 |      * @return Boolean
16 |      */
17 |     function divisorGame($N) {
18 |         
19 |         if($N == 1) {
20 |             return false;
21 |         }
22 | 
23 |         return !$this->divisorGame($N - 1);
24 |     }
25 | }
26 | 
27 | // Accepted
28 | // 40/40 cases passed (4 ms)
29 | // Your runtime beats 100 % of php submissions
30 | // Your memory usage beats 100 % of php submissions (15.3 MB)
31 | // @lc code=end
32 | 
33 | 


--------------------------------------------------------------------------------
/每日1题202007/[0727]392.判断子序列.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=392 lang=php
 4 |  *
 5 |  * [392] 判断子序列
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/is-subsequence/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param String $s
15 |      * @param String $t
16 |      * @return Boolean
17 |      */
18 |     function isSubsequence($s, $t) {
19 | 
20 |         $m = strlen($s);
21 |         $n = strlen($t);
22 |         $i = 0;
23 |         $j = 0;
24 | 
25 |         while($i < $m && $j < $n) {
26 |             // s == t 则两者向右移动一位，如果 s != t，则 t 往右移动一位
27 |             if($s[$i] == $t[$j]) {
28 |                 $i++;
29 |             }
30 |             $j++;
31 |         }
32 |         
33 |         return $i == $m;
34 |     }
35 | }
36 | 
37 | // Accepted
38 | // 15/15 cases passed (4 ms)
39 | // Your runtime beats 94.74 % of php submissions
40 | // Your memory usage beats 100 % of php submissions (14.9 MB)
41 | // @lc code=end
42 | 
43 | 


--------------------------------------------------------------------------------
/每日1题202007/[0728]104.二叉树的最大深度.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=104 lang=php
 4 |  *
 5 |  * [104] 二叉树的最大深度
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/
 8 |  */
 9 | 
10 | // @lc code=start
11 | /**
12 |  * Definition for a binary tree node.
13 |  * class TreeNode {
14 |  *     public $val = null;
15 |  *     public $left = null;
16 |  *     public $right = null;
17 |  *     function __construct($value) { $this->val = $value; }
18 |  * }
19 |  */
20 | class Solution {
21 | 
22 |     /**
23 |      * @param TreeNode $root
24 |      * @return Integer
25 |      */
26 |     function maxDepth($root) {
27 |         
28 |         if($root == null) {
29 |             return 0;
30 |         }
31 | 
32 |         if($root->left == null && $root->right == null) {
33 |             return 1;
34 |         }
35 | 
36 |         if($root->left != null) {
37 |             $left = $this->maxDepth($root->left);
38 |         }
39 | 
40 |         if($root->right != null) {
41 |             $right = $this->maxDepth($root->right);
42 |         }
43 | 
44 |         return max($left, $right) + 1;
45 |     }
46 | }
47 | // @lc code=end
48 | 
49 | 


--------------------------------------------------------------------------------
/每日1题202007/[0730]343.整数拆分.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=343 lang=php
 4 |  *
 5 |  * [343] 整数拆分
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/integer-break/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer $n
15 |      * @return Integer
16 |      */
17 |     function integerBreak($n) {
18 |         if ($n <= 3) {
19 |             return $n - 1;
20 |         }
21 | 
22 |         $quotient = (int)($n / 3);
23 |         $remainder = (int) ($n % 3);
24 |         if ($remainder == 0) {
25 |             return (int) pow(3, $quotient);
26 |         } elseif ($remainder == 1) {
27 |             return (int) pow(3, $quotient - 1) * 4;
28 |         } else {
29 |             return (int) pow(3, $quotient) * 2; 
30 |         }
31 |     }
32 | }
33 | 
34 | // 官方数学解法
35 | // Accepted
36 | // 50/50 cases passed (8 ms)
37 | // Your runtime beats 56.52 % of php submissions
38 | // Your memory usage beats 100 % of php submissions (14.8 MB)
39 | // @lc code=end
40 | 
41 | 


--------------------------------------------------------------------------------
/每日1题202007/[0731]面试题 08.03. 魔术索引.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | // 面试题 08.03. 魔术索引
 3 | // https://leetcode-cn.com/problems/magic-index-lcci/
 4 | 
 5 | class Solution {
 6 | 
 7 |     /**
 8 |      * @param Integer[] $nums
 9 |      * @return Integer
10 |      */
11 |     function findMagicIndex($nums) {
12 | 
13 |         if($nums == null || count($nums) == 0) {
14 |             return -1;
15 |         }
16 | 
17 |         if($nums[0] == 0){
18 |             return 0;
19 |         }
20 | 
21 |         for ($i = 0; $i < count($nums); $i++) {
22 |             if ($nums[$i] == $i) {
23 |                 return $i;
24 |             }
25 |         }
26 | 
27 |         return -1;
28 |     }
29 | }


--------------------------------------------------------------------------------
/每日1题202008/README.md:
--------------------------------------------------------------------------------
1 | # leetcode 每日1题


--------------------------------------------------------------------------------
/每日1题202008/[0802]114.二叉树展开为链表.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=114 lang=php
 4 |  *
 5 |  * [114] 二叉树展开为链表
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/flatten-binary-tree-to-linked-list/
 8 |  * 参考 https://leetcode-cn.com/problems/flatten-binary-tree-to-linked-list/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by--26/
 9 |  */
10 | 
11 | // @lc code=start
12 | /**
13 |  * Definition for a binary tree node.
14 |  * class TreeNode {
15 |  *     public $val = null;
16 |  *     public $left = null;
17 |  *     public $right = null;
18 |  *     function __construct($val = 0, $left = null, $right = null) {
19 |  *         $this->val = $val;
20 |  *         $this->left = $left;
21 |  *         $this->right = $right;
22 |  *     }
23 |  * }
24 |  */
25 | class Solution {
26 | 
27 |     /**
28 |      * @param TreeNode $root
29 |      * @return NULL
30 |      */
31 |     function flatten($root) {
32 |         
33 |         while ($root != null) {
34 |             if ($root->left != null) {
35 |                 // 找到左子树最右边的节点
36 |                 $pre = $root->left;
37 |                 while ($pre->right != null) {
38 |                     $pre = $pre->right;
39 |                 }
40 | 
41 |                 // 将原来的右子树接到左子树的最右边节点
42 |                 $pre->right = $root->right;
43 |                 $root->right = $root->left;
44 |                 $root->left = null;
45 |             }
46 | 
47 |             // 考虑下一个节点
48 |             $root = $root->right;
49 |         }
50 |     }
51 | }
52 | 
53 | // Accepted
54 | // 225/225 cases passed (8 ms)
55 | // Your runtime beats 88.24 % of php submissions
56 | // Your memory usage beats 25 % of php submissions (15.3 MB)
57 | // @lc code=end
58 | 
59 | 


--------------------------------------------------------------------------------
/每日1题202008/[0805]337.打家劫舍-iii.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=337 lang=php
 4 |  *
 5 |  * [337] 打家劫舍 III
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/house-robber-iii/
 8 |  */
 9 | 
10 | // @lc code=start
11 | /**
12 |  * Definition for a binary tree node.
13 |  * class TreeNode {
14 |  *     public $val = null;
15 |  *     public $left = null;
16 |  *     public $right = null;
17 |  *     function __construct($value) { $this->val = $value; }
18 |  * }
19 |  */
20 | class Solution {
21 | 
22 |     /**
23 |      * @param TreeNode $root
24 |      * @return Integer
25 |      */
26 |     function rob($root) {
27 |         $root_status = $this->dfs($root);
28 |         return max($root_status[0], $root_status[1]);
29 |     }
30 | 
31 |     // dfs
32 |     function dfs($node) {
33 |         if ($node == null) return [0,0];
34 | 
35 |         $l = $this->dfs($node->left);
36 |         $r = $this->dfs($node->right);
37 | 
38 |         // 选择当前节点时，子节点都不可以选择
39 |         $selected = $node->val + $l[0] + $r[0];
40 | 
41 |         // 不选当前节点时，子节点都可以选择
42 |         $not_selected = max($l[0], $l[1]) + max($r[0], $r[1]);
43 | 
44 |         return [$not_selected, $selected];
45 |     }
46 | }
47 | 
48 | // Accepted
49 | // 124/124 cases passed (16 ms)
50 | // Your runtime beats 76.47 % of php submissions
51 | // Your memory usage beats 100 % of php submissions (17 MB)
52 | // @lc code=end
53 | 
54 | 


--------------------------------------------------------------------------------
/每日1题202008/[0807]100.相同的树.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=100 lang=php
 4 |  *
 5 |  * [100] 相同的树
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/same-tree/
 8 |  */
 9 | 
10 | // @lc code=start
11 | /**
12 |  * Definition for a binary tree node.
13 |  * class TreeNode {
14 |  *     public $val = null;
15 |  *     public $left = null;
16 |  *     public $right = null;
17 |  *     function __construct($val = 0, $left = null, $right = null) {
18 |  *         $this->val = $val;
19 |  *         $this->left = $left;
20 |  *         $this->right = $right;
21 |  *     }
22 |  * }
23 |  */
24 | class Solution {
25 | 
26 |     /**
27 |      * @param TreeNode $p
28 |      * @param TreeNode $q
29 |      * @return Boolean
30 |      */
31 |     function isSameTree($p, $q) {
32 |         
33 |         if($p == null && $q == null) return true;
34 |         if($p == null || $q == null) return false;
35 |         if($q->val != $p->val) return false;
36 | 
37 |         return $this->isSameTree($p->left, $q->left) && $this->isSameTree($p->right, $q->right);
38 |     }
39 | }
40 | 
41 | // Accepted
42 | // 59/59 cases passed (4 ms)
43 | // Your runtime beats 92.77 % of php submissions
44 | // Your memory usage beats 8.33 % of php submissions (15.2 MB)
45 | // @lc code=end
46 | 
47 | 


--------------------------------------------------------------------------------
/每日1题202008/[0808]99.恢复二叉搜索树.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=99 lang=php
 4 |  *
 5 |  * [99] 恢复二叉搜索树
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/recover-binary-search-tree/
 8 |  */
 9 | 
10 | // @lc code=start
11 | /**
12 |  * Definition for a binary tree node.
13 |  * class TreeNode {
14 |  *     public $val = null;
15 |  *     public $left = null;
16 |  *     public $right = null;
17 |  *     function __construct($val = 0, $left = null, $right = null) {
18 |  *         $this->val = $val;
19 |  *         $this->left = $left;
20 |  *         $this->right = $right;
21 |  *     }
22 |  * }
23 |  */
24 | class Solution {
25 | 
26 |     protected $t1;
27 |     protected $t2;
28 |     protected $pre;
29 | 
30 |     /**
31 |      * @param TreeNode $root
32 |      * @return NULL
33 |      */
34 |     function recoverTree($root) {
35 | 
36 |         // 中序遍历，左根右一定是从小到大，出现前者比后者大的时候，记录该位置，最终交换两个点
37 |         $this->inorder($root);
38 | 
39 |         $temp = $this->t1->val;
40 |         $this->t1->val = $this->t2->val;
41 |         $this->t2->val = $temp;
42 |     }
43 | 
44 |     function inorder($root) {
45 | 
46 |         if ($root == null) return true;
47 | 
48 |         $this->inorder($root->left);
49 | 
50 |         if ($this->pre != null && $this->pre->val > $root->val) {
51 |             if ($this->t1 == null) {
52 |                 $this->t1 = $this->pre;
53 |             }
54 |             $this->t2 = $root;
55 |         }
56 | 
57 |         $this->pre = $root;
58 |         $this->inorder($root->right);
59 |     }
60 | }
61 | 
62 | // Accepted
63 | // 1917/1917 cases passed (24 ms)
64 | // Your runtime beats 66.67 % of php submissions
65 | // Your memory usage beats 100 % of php submissions (15.4 MB)
66 | // @lc code=end
67 | 
68 | 


--------------------------------------------------------------------------------
/每日1题202008/[0809]93.复原ip地址.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=93 lang=php
 4 |  *
 5 |  * [93] 复原IP地址
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/restore-ip-addresses/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     protected $res;
14 | 
15 |     /**
16 |      * @param String $s
17 |      * @return String[]
18 |      */
19 |     function restoreIpAddresses($s) {
20 | 
21 |         $this->res = [];
22 |         $this->restore(0, '', $s);
23 |         return $this->res;
24 |     }
25 | 
26 |     function restore($count, $ip, $s) {
27 | 
28 |         if ($count == 4) {
29 |             // 当深度到达第四层时，s已经截取完且符合规则，将此ip加入最终结果集
30 |             if ($s == '') {
31 |                 $this->res[] = substr($ip, 0, -1);
32 |             }
33 |             return true;
34 |         }
35 | 
36 |         // 第一个ip段长度为 1
37 |         if(strlen($s) > 0) {
38 |             $this->restore($count + 1, $ip.$s[0].'.', substr($s, 1));
39 |         }
40 | 
41 |         // 第一个ip段长度为 2，合法ip 首位不为 0 
42 |         if(strlen($s) > 1 && $s[0] != '0') { // python写法 s[0:2] s[2:]
43 |             $this->restore($count + 1, $ip.substr($s, 0, 2).'.', substr($s, 2));
44 |         }
45 | 
46 |         // 第一个ip段长度为 3，合法ip 首位不为 0 
47 |         if(strlen($s) > 2 && $s[0] != '0' && (int)substr($s, 0, 3) < 256) { // python写法 s[0:3] s[3:]
48 |             $this->restore($count + 1, $ip.substr($s, 0, 3).'.', substr($s, 3));
49 |         }
50 |     }
51 | }
52 | 
53 | // Accepted
54 | // 147/147 cases passed (4 ms)
55 | // Your runtime beats 95.65 % of php submissions
56 | // Your memory usage beats 66.67 % of php submissions (14.8 MB)
57 | // @lc code=end
58 | 
59 | 


--------------------------------------------------------------------------------
/每日1题202008/[0810]696.计数二进制子串.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=696 lang=php
 4 |  *
 5 |  * [696] 计数二进制子串
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/count-binary-substrings/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param String $s
15 |      * @return Integer
16 |      */
17 |     function countBinarySubstrings($s) {
18 | 
19 |         // 计数条件：相同数量的0和1、且所有0和1都分别组合在一起
20 |         // pre 记录之前连续 0 或 1，cur 记录现在的连续 1 或 0，pre >= cur，n++ 是什么意思呢？
21 |         // 假设有一个数 000111，从头开始遍历，到达 1 时，0 的计数时，pre 计数可以达到 3
22 |         // 当出现 0001 时，cur == 1，pre > cur，包含 01 子串，符合条件，n++；
23 |         // 当出现 00011 时，cur == 2，pre > cur，包含 0011 子串，符合条件，n++；
24 |         // 当出现 000111 时，cur == 3，pre == cur，包含 000111 子串，符合条件，n++；
25 |         // 当 1 后面开始出现 0 时，同理。
26 | 
27 |         $n = 0;
28 |         $pre = 0;
29 |         $cur = 1;
30 |         $len = strlen($s) - 1;
31 | 
32 |         for ($i=0; $i < $len; $i++) { 
33 |             if ($s[$i] == $s[$i+1]) {
34 |                 $cur++;
35 |             } else {
36 |                 $pre = $cur;
37 |                 $cur = 1;
38 |             }
39 | 
40 |             if ($pre >= $cur) {
41 |                 $n++;
42 |             }
43 |         }
44 | 
45 |         return $n;
46 |     }
47 | }
48 | 
49 | // Accepted
50 | // 90/90 cases passed (48 ms)
51 | // Your runtime beats 100 % of php submissions
52 | // Your memory usage beats 100 % of php submissions (15 MB)
53 | // @lc code=end
54 | 
55 | 


--------------------------------------------------------------------------------
/每日1题202008/[0812]133.克隆图.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=133 lang=php
 4 |  *
 5 |  * [133] 克隆图
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/clone-graph/
 8 |  */
 9 | 
10 | // @lc code=start
11 | /**
12 |  * Definition for a Node.
13 |  * class Node {
14 |  *     public $val = null;
15 |  *     public $neighbors = null;
16 |  *     function __construct($val = 0) {
17 |  *         $this->val = $val;
18 |  *         $this->neighbors = array();
19 |  *     }
20 |  * }
21 |  */
22 | 
23 | class Solution {
24 |     /**
25 |      * @param Node $node
26 |      * @return Node
27 |      */
28 |     function cloneGraph($node) {
29 |         $s = serialize($node);
30 |         return unserialize($s);
31 |     }
32 | }
33 | 
34 | // Accepted
35 | // 21/21 cases passed (12 ms)
36 | // Your runtime beats 80.95 % of php submissions
37 | // Your memory usage beats 33.33 % of php submissions (16.1 MB)
38 | // @lc code=end
39 | 
40 | 


--------------------------------------------------------------------------------
/每日1题202008/[0814]20.有效的括号.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=20 lang=php
 4 |  *
 5 |  * [20] 有效的括号
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/valid-parentheses/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param String $s
15 |      * @return Boolean
16 |      */
17 |     function isValid($s) {
18 | 
19 |         $arr = [
20 |             '{' => '}',
21 |             '[' => ']',
22 |             '(' => ')',
23 |             '?' => '?'
24 |         ];
25 | 
26 |         $left = ['{','[','('];
27 |         $stack = ["?"];
28 |         
29 |         for ($i=0; $i < strlen($s); $i++) { 
30 |             if (in_array($s[$i], $left)) { // 如果是左括号，直接入栈
31 |                 $stack[] = $s[$i];
32 |             } elseif ($arr[array_pop($stack)] != $s[$i]) { // 如果不在右括号范围内，直接返回结果
33 |                 return false;
34 |             }
35 |         }
36 | 
37 |         return count($stack) == 1;
38 |     }
39 | }
40 | 
41 | // Accepted
42 | // 76/76 cases passed (8 ms)
43 | // Your runtime beats 79.31 % of php submissions
44 | // Your memory usage beats 70.97 % of php submissions (14.9 MB)
45 | // @lc code=end
46 | 
47 | 


--------------------------------------------------------------------------------
/每日1题202008/[0815]546.移除盒子.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=546 lang=php
 4 |  *
 5 |  * [546] 移除盒子
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/remove-boxes/
 8 |  * 视频讲解 https://www.bilibili.com/video/BV11W411Z7jG?from=search&seid=1926116731256697431
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 |     protected $m_;
14 |     /**
15 |      * @param Integer[] $nums
16 |      * @return Integer
17 |      */
18 |     function removeBoxes($nums) {
19 |         $n = count($nums);
20 | 
21 |         $this->m_ = array_fill(0, $n, array_fill(0, $n, array_fill(0, $n, 0)));
22 |         return $this->dfs($nums, 0, $n - 1, 0);
23 |     }
24 | 
25 |     function dfs(&$nums, $l, $r, $k) {
26 |         if ($l > $r) return 0;
27 |         if ($this->m_[$l][$r][$k] > 0) return $this->m_[$l][$r][$k];
28 |         $this->m_[$l][$r][$k] = $this->dfs($nums, $l, $r - 1, 0) + ($k+1) * ($k+1);
29 | 
30 |         for ($i = $l; $i < $r; $i++) {
31 |             if ($nums[$i] == $nums[$r]) {
32 |                 $this->m_[$l][$r][$k] = max($this->m_[$l][$r][$k], $this->dfs($nums, $l, $i, $k + 1) + $this->dfs($nums, $i + 1, $r - 1, 0));
33 |             }
34 |         }
35 | 
36 |         return $this->m_[$l][$r][$k];
37 |     }
38 | }
39 | // @lc code=end
40 | 
41 | 


--------------------------------------------------------------------------------
/每日1题202008/[0816]733.图像渲染.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=733 lang=php
 4 |  *
 5 |  * [733] 图像渲染
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/flood-fill/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[][] $image
15 |      * @param Integer $sr
16 |      * @param Integer $sc
17 |      * @param Integer $newColor
18 |      * @return Integer[][]
19 |      */
20 |     function floodFill($image, $sr, $sc, $newColor) {
21 |         
22 |     }
23 | }
24 | // @lc code=end
25 | 
26 | 


--------------------------------------------------------------------------------
/每日1题202008/[0817]110.平衡二叉树.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=110 lang=php
 4 |  *
 5 |  * [110] 平衡二叉树
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/balanced-binary-tree/
 8 |  */
 9 | 
10 | // @lc code=start
11 | /**
12 |  * Definition for a binary tree node.
13 |  * class TreeNode {
14 |  *     public $val = null;
15 |  *     public $left = null;
16 |  *     public $right = null;
17 |  *     function __construct($value) { $this->val = $value; }
18 |  * }
19 |  */
20 | class Solution {
21 | 
22 |     /**
23 |      * @param TreeNode $root
24 |      * @return Boolean
25 |      */
26 |     function isBalanced($root) {
27 | 
28 |         // 自顶向下
29 |         if ($root == null) {
30 |             return true;
31 |         } else {
32 |             return abs($this->height($root->left) - $this->height($root->right)) <= 1 && $this->isBalanced($root->left) && $this->isBalanced($root->right);
33 |         }
34 |     }
35 | 
36 |     function height($root) {
37 |         if ($root == null) {
38 |             return 0;
39 |         } else {
40 |             return max($this->height($root->left), $this->height($root->right)) + 1;
41 |         }
42 |     }
43 | }
44 | 
45 | // Accepted
46 | // 227/227 cases passed (24 ms)
47 | // Your runtime beats 19.4 % of php submissions
48 | // Your memory usage beats 69.7 % of php submissions (17 MB)
49 | // @lc code=end
50 | 
51 | 


--------------------------------------------------------------------------------
/每日1题202008/[0821]111.二叉树的最小深度.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=111 lang=php
 4 |  *
 5 |  * [111] 二叉树的最小深度
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/
 8 |  */
 9 | 
10 | // @lc code=start
11 | /**
12 |  * Definition for a binary tree node.
13 |  * class TreeNode {
14 |  *     public $val = null;
15 |  *     public $left = null;
16 |  *     public $right = null;
17 |  *     function __construct($value) { $this->val = $value; }
18 |  * }
19 |  */
20 | class Solution {
21 | 
22 |     /**
23 |      * @param TreeNode $root
24 |      * @return Integer
25 |      */
26 |     function minDepth($root) {
27 |         
28 |     }
29 | }
30 | // @lc code=end
31 | 
32 | 


--------------------------------------------------------------------------------
/每日1题202008/[0822]679.24-点游戏.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=679 lang=php
 4 |  *
 5 |  * [679] 24 点游戏
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/24-game/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $nums
15 |      * @return Boolean
16 |      */
17 |     function judgePoint24($nums) {
18 |         
19 |     }
20 | }
21 | // @lc code=end


--------------------------------------------------------------------------------
/每日1题202008/[0823]201.数字范围按位与.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=201 lang=php
 4 |  *
 5 |  * [201] 数字范围按位与
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/bitwise-and-of-numbers-range/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer $m
15 |      * @param Integer $n
16 |      * @return Integer
17 |      */
18 |     function rangeBitwiseAnd($m, $n) {
19 | 
20 |     }
21 | }
22 | // @lc code=end
23 | 
24 | 


--------------------------------------------------------------------------------
/每日1题202008/[0824]459.重复的子字符串.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=459 lang=php
 4 |  *
 5 |  * [459] 重复的子字符串
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/repeated-substring-pattern/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param String $s
15 |      * @return Boolean
16 |      */
17 |     function repeatedSubstringPattern($s) {
18 |         
19 |     }
20 | }
21 | // @lc code=end
22 | 
23 | 


--------------------------------------------------------------------------------
/每日1题202008/[0825]491.递增子序列.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=491 lang=php
 4 |  *
 5 |  * [491] 递增子序列
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/increasing-subsequences/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $nums
15 |      * @return Integer[][]
16 |      */
17 |     function findSubsequences($nums) {
18 | 
19 |     }
20 | }
21 | // @lc code=end
22 | 
23 | 


--------------------------------------------------------------------------------
/每日1题202008/[0826]17.电话号码的字母组合.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=17 lang=php
 4 |  *
 5 |  * [17] 电话号码的字母组合
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param String $digits
15 |      * @return String[]
16 |      */
17 |     function letterCombinations($digits) {
18 | 
19 |     }
20 | }
21 | // @lc code=end
22 | 
23 | 


--------------------------------------------------------------------------------
/每日1题202008/[0827]332.重新安排行程.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=332 lang=php
 4 |  *
 5 |  * [332] 重新安排行程
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/reconstruct-itinerary/
 8 |  * 视频讲解 https://www.bilibili.com/video/BV14J411h7W1?from=search&seid=1301487221452829034
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     /**
15 |      * @param String[][] $tickets
16 |      * @return String[]
17 |      */
18 |     function findItinerary($tickets) {
19 | 
20 |         $g = [];
21 |         $this->buildGraph($tickets, $g); // 构建图
22 | 
23 |         $stack = [];
24 |         $this->dfs($g, $stack, "JFK"); // 深度优先搜索
25 |         
26 |         return array_reverse($stack);
27 |     }
28 | 
29 |     function buildGraph($tickets, &$g) {
30 | 
31 |         foreach ($tickets as $ticket) {
32 |             $from = $ticket[0];
33 |             $to = $ticket[1];
34 | 
35 |             if (!array_key_exists($from, $g)) {
36 |                 $g[$from] = [];
37 |             }
38 | 
39 |             $g[$from][] = $to;
40 |         }
41 | 
42 |         foreach ($g as $from => $tos) {
43 |             sort($g[$from]);
44 |         }
45 |     }
46 | 
47 |     function dfs(&$g, &$stack, $from) {
48 | 
49 |         while (!empty($g[$from])) {
50 |             $to = array_shift($g[$from]);
51 |             $this->dfs($g, $stack, $to); // 前一个目的地作为新的起点
52 |         }
53 |         
54 |         array_push($stack, $from);
55 |     }
56 | }
57 | 
58 | // Accepted
59 | // 80/80 cases passed (32 ms)
60 | // Your runtime beats 100 % of php submissions
61 | // Your memory usage beats 100 % of php submissions (15.3 MB)
62 | // @lc code=end
63 | 
64 | 


--------------------------------------------------------------------------------
/每日1题202008/[0828]657.机器人能否返回原点.php:
--------------------------------------------------------------------------------
 1 | <?
 2 | /*
 3 |  * @lc app=leetcode.cn id=657 lang=php
 4 |  *
 5 |  * [657] 机器人能否返回原点
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/robot-return-to-origin/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param String $moves
15 |      * @return Boolean
16 |      */
17 |     function judgeCircle($moves) {
18 | 
19 |         $len = strlen($moves);
20 |         if ($len == 0) return true;
21 | 
22 |         $x = 0;
23 |         $y = 0;
24 |         
25 |         for ($i=0; $i < $len; $i++) { 
26 | 
27 |             if ($moves[$i] == 'R') {
28 |                 $x += 1;
29 |             } elseif ($moves[$i] == 'L') {
30 |                 $x -= 1;
31 |             } elseif ($moves[$i] == 'U') {
32 |                 $y += 1;
33 |             } elseif ($moves[$i] == 'D') {
34 |                 $y -= 1;
35 |             }
36 |         }
37 | 
38 |         return $x == 0 && $y == 0;
39 |     }
40 | }
41 | 
42 | // Accepted
43 | // 63/63 cases passed (32 ms)
44 | // Your runtime beats 9.09 % of php submissions
45 | // Your memory usage beats 91.67 % of php submissions (14.9 MB)
46 | // @lc code=end
47 | 
48 | 


--------------------------------------------------------------------------------
/每日1题202008/[0829]214.最短回文串.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=214 lang=php
 4 |  *
 5 |  * [214] 最短回文串
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/shortest-palindrome/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param String $s
15 |      * @return String
16 |      */
17 |     function shortestPalindrome($s) {
18 | 
19 |     }
20 | }
21 | // @lc code=end
22 | 
23 | 


--------------------------------------------------------------------------------
/每日1题202008/[0830]557.反转字符串中的单词-iii.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=557 lang=php
 4 |  *
 5 |  * [557] 反转字符串中的单词 III
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/reverse-words-in-a-string-iii/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param String $s
15 |      * @return String
16 |      */
17 |     function reverseWords($s) {
18 |         
19 |     }
20 | }
21 | // @lc code=end
22 | 
23 | 


--------------------------------------------------------------------------------
/每日1题202008/[0831]841.钥匙和房间.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=841 lang=php
 4 |  *
 5 |  * [841] 钥匙和房间
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/keys-and-rooms/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     protected $num;
14 |     protected $visited;
15 |     /**
16 |      * @param Integer[][] $rooms
17 |      * @return Boolean
18 |      */
19 |     function canVisitAllRooms($rooms) {
20 |         
21 |         $n = count($rooms);
22 |         $this->num = 0;
23 |         $this->visited = array_fill(0, $n, 0);
24 |         $this->dfs($rooms, 0);
25 | 
26 |         return $n == $this->num; // 是否全部访问过
27 |     }
28 | 
29 |     function dfs($rooms, $x) {
30 |         $this->visited[$x] = 1;
31 |         $this->num++;
32 | 
33 |         foreach ($rooms[$x] as $key) {
34 |             if (!$this->visited[$key]) { // 如果没有访问过，下探至下一层
35 |                 $this->dfs($rooms, $key);
36 |             }
37 |         }
38 |     }
39 | }
40 | 
41 | // Accepted
42 | // 67/67 cases passed (32 ms)
43 | // Your runtime beats 42.86 % of php submissions
44 | // Your memory usage beats 100 % of php submissions (16.3 MB)
45 | // @lc code=end
46 | 
47 | 


--------------------------------------------------------------------------------
/每日1题202009/README.md:
--------------------------------------------------------------------------------
1 | # leetcode 每日1题


--------------------------------------------------------------------------------
/每日1题202009/[0901]486.预测赢家_记忆化递归.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=486 lang=php
 4 |  *
 5 |  * [486] 预测赢家
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/predict-the-winner/
 8 |  * 视频讲解 https://www.bilibili.com/video/BV1kW411d7R2?from=search&seid=14164385378038574682
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     protected $m;
15 |     protected $size;
16 |     /**
17 |      * @param Integer[] $nums
18 |      * @return Boolean
19 |      */
20 |     function PredictTheWinner($nums) {
21 |         // 关于记忆化：用例 [1,5,233,7]
22 |         // 玩家1拿走1，玩家2拿走7；玩家1拿走7，玩家2拿走1；
23 |         // 剩下的子问题都是 [5,233]，只计算一次就好
24 | 
25 |         $this->size = count($nums);
26 |         // 存储重叠的子问题解
27 |         $this->m = array_fill(0, $this->size * $this->size, 0);
28 | 
29 |         // 判断玩家1 - 玩家2是否大于等于0
30 |         return $this->getScore($nums, 0, count($nums) - 1) >= 0;
31 |     }
32 | 
33 |     function getScore($nums, $l, $r) {
34 | 
35 |         if ($l == $r) return $nums[$l];
36 | 
37 |         $k = $l * $this->size + $r;
38 |         if ($this->m[$k] > 0) return $this->m[$k];
39 | 
40 |         // 求两种情况下的最优解
41 |         // 玩家1选择左端点L，那么玩家2的可选择区间则是[L + 1, R]
42 |         // 玩家1选择右端点R，那么玩家2的可选择区间则是[L, R - 1]
43 |         $this->m[$k] =  max(
44 |             $nums[$l] - $this->getScore($nums, $l + 1, $r),
45 |             $nums[$r] - $this->getScore($nums, $l, $r - 1)
46 |         );
47 | 
48 |         return $this->m[$k];
49 |     }
50 | }
51 | 
52 | // Accepted
53 | // 62/62 cases passed (12 ms)
54 | // Your runtime beats 100 % of php submissions
55 | // Your memory usage beats 100 % of php submissions (14.9 MB)
56 | // @lc code=end
57 | 
58 | 


--------------------------------------------------------------------------------
/每日1题202009/[0901]486.预测赢家_递归.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=486 lang=php
 4 |  *
 5 |  * [486] 预测赢家
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/predict-the-winner/
 8 |  * 视频讲解 https://www.bilibili.com/video/BV1kW411d7R2?from=search&seid=14164385378038574682
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     /**
15 |      * @param Integer[] $nums
16 |      * @return Boolean
17 |      */
18 |     function PredictTheWinner($nums) {
19 |         // 判断玩家1 - 玩家2是否大于等于0
20 |         return $this->getScore($nums, 0, count($nums) - 1) >= 0;
21 |     }
22 | 
23 |     function getScore($nums, $l, $r) {
24 | 
25 |         if ($l == $r) return $nums[$l];
26 | 
27 |         // 求两种情况下的最优解
28 |         // 玩家1选择左端点L，那么玩家2的可选择区间则是[L + 1, R]
29 |         // 玩家1选择右端点R，那么玩家2的可选择区间则是[L, R - 1]
30 |         return max(
31 |             $nums[$l] - $this->getScore($nums, $l + 1, $r),
32 |             $nums[$r] - $this->getScore($nums, $l, $r - 1)
33 |         );
34 |     }
35 | }
36 | 
37 | // Accepted
38 | // 62/62 cases passed (1340 ms)
39 | // Your runtime beats 100 % of php submissions
40 | // Your memory usage beats 100 % of php submissions (14.9 MB)
41 | // 效率较低
42 | // @lc code=end
43 | 
44 | 


--------------------------------------------------------------------------------
/每日1题202009/[0904]257.二叉树的所有路径.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=257 lang=php
 4 |  *
 5 |  * [257] 二叉树的所有路径
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/binary-tree-paths/
 8 |  */
 9 | 
10 | // @lc code=start
11 | /**
12 |  * Definition for a binary tree node.
13 |  * class TreeNode {
14 |  *     public $val = null;
15 |  *     public $left = null;
16 |  *     public $right = null;
17 |  *     function __construct($value) { $this->val = $value; }
18 |  * }
19 |  */
20 | class Solution {
21 | 
22 |     protected $arr;
23 |     /**
24 |      * @param TreeNode $root
25 |      * @return String[]
26 |      */
27 |     function binaryTreePaths($root) {
28 | 
29 |         if ($root == null) return []; 
30 | 
31 |         $this->dfs($root, "");
32 |         return $this->arr;
33 |     }
34 | 
35 |     function dfs($root, $tmp) {
36 | 
37 |         if ($root != null) {
38 |             $tmp = ($tmp == "") ? (string)$root->val : $tmp."->".$root->val;
39 |             if ($root->left == null && $root->right == null) {
40 |                 $this->arr[] = $tmp;
41 |             } else {
42 |                 $this->dfs($root->left, $tmp);
43 |                 $this->dfs($root->right, $tmp);
44 |             }
45 |         }
46 |     }
47 | }
48 | 
49 | // Accepted
50 | // 209/209 cases passed (12 ms)
51 | // Your runtime beats 17.14 % of php submissions
52 | // Your memory usage beats 7.14 % of php submissions (15.1 MB)
53 | // @lc code=end
54 | 
55 | 


--------------------------------------------------------------------------------
/每日1题202009/[0906]107.二叉树的层次遍历-ii.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=107 lang=php
 4 |  *
 5 |  * [107] 二叉树的层次遍历 II
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/binary-tree-level-order-traversal-ii/
 8 |  */
 9 | 
10 | // @lc code=start
11 | /**
12 |  * Definition for a binary tree node.
13 |  * class TreeNode {
14 |  *     public $val = null;
15 |  *     public $left = null;
16 |  *     public $right = null;
17 |  *     function __construct($value) { $this->val = $value; }
18 |  * }
19 |  */
20 | class Solution {
21 | 
22 |     /**
23 |      * @param TreeNode $root
24 |      * @return Integer[][]
25 |      */
26 |     function levelOrderBottom($root) {
27 | 
28 |         // 使用辅助队列，先进先出
29 |         $queue = [];
30 |         array_push($queue, [0, $root]);
31 |         $res = [];
32 | 
33 |         while (!empty($queue)) {
34 |             $cur = array_shift($queue);
35 | 
36 |             if ($cur[1] == null) continue;
37 |             $res[$cur[0]][] = $cur[1]->val;
38 | 
39 |             array_push($queue, [$cur[0] + 1, $cur[1]->left]);
40 |             array_push($queue, [$cur[0] + 1, $cur[1]->right]);
41 |         }
42 | 
43 |         return array_reverse($res);
44 |     }
45 | }
46 | 
47 | // Accepted
48 | // 34/34 cases passed (8 ms)
49 | // Your runtime beats 87.5 % of php submissions
50 | // Your memory usage beats 39.03 % of php submissions (15.7 MB)
51 | // @lc code=end
52 | 
53 | 


--------------------------------------------------------------------------------
/每日1题202009/[0907]347.前-k-个高频元素.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=347 lang=php
 4 |  *
 5 |  * [347] 前 K 个高频元素
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/top-k-frequent-elements/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $nums
15 |      * @param Integer $k
16 |      * @return Integer[]
17 |      */
18 |     function topKFrequent($nums, $k) {
19 | 
20 |         $res = [];
21 | 
22 |         // 统计次数
23 |         foreach ($nums as $val) {
24 |             $res[$val] = isset($res[$val]) ? $res[$val]+1 : 1; 
25 |         }
26 | 
27 |         // 按照键值进行降序排序
28 |         arsort($res);
29 | 
30 |         $new_res = [];
31 |         $i = 0;
32 |         foreach ($res as $key => $val) {
33 | 
34 |             $new_res[] = $key;
35 |             if(++$i == $k) break; // 取前k个
36 |         }
37 | 
38 |         return $new_res;
39 |     }
40 | }
41 | 
42 | // Accepted
43 | // 21/21 cases passed (36 ms)
44 | // Your runtime beats 72.04 % of php submissions
45 | // Your memory usage beats 89.74 % of php submissions (19.7 MB)
46 | // @lc code=end
47 | 
48 | 


--------------------------------------------------------------------------------
/每日1题202009/[0908]77.组合.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=77 lang=php
 4 |  *
 5 |  * [77] 组合
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/combinations/
 8 |  * 参考题解 https://leetcode-cn.com/problems/combinations/solution/hui-su-suan-fa-jian-zhi-python-dai-ma-java-dai-ma-/
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     protected $n; 
15 |     protected $k; 
16 | 
17 |     /**
18 |      * @param Integer $n
19 |      * @param Integer $k
20 |      * @return Integer[][]
21 |      */
22 |     function combine($n, $k) {
23 | 
24 |         $this->n = $n;
25 |         $this->k = $k;
26 |         $res = [];
27 |         $tmp = [];
28 |         $this->helper(1, $tmp, $res);
29 |         return $res;
30 |     }
31 | 
32 |     function helper($start, &$tmp, &$res) {
33 | 
34 |         if(count($tmp) == $this->k){
35 |             $res[] = $tmp;
36 |             return true;
37 |         }
38 | 
39 |         // 搜索起点的上界 + 接下来要选择的元素个数 - 1 = n
40 |         // 搜索起点的上界 = n - (k - path.size()) + 1
41 |         for ($i=$start; $i <= ($this->n - ($this->k - count($tmp)) + 1); $i++) { 
42 |             $tmp[] = $i;
43 |             $this->helper($i + 1, $tmp, $res);
44 |             array_pop($tmp);
45 |         }
46 |     }
47 | }
48 | 
49 | // Accepted
50 | // 27/27 cases passed (24 ms)
51 | // Your runtime beats 97.6 % of php submissions
52 | // Your memory usage beats 59.54 % of php submissions (19.7 MB)
53 | // @lc code=end
54 | 
55 | 


--------------------------------------------------------------------------------
/每日1题202009/[0909]39.组合总和.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=39 lang=php
 4 |  *
 5 |  * [39] 组合总和
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/combination-sum/
 8 |  * 视频讲解 https://www.bilibili.com/video/BV1Jt411H75d?from=search&seid=1354833469870329794
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     protected $results;
15 | 
16 |     /**
17 |      * @param Integer[] $candidates
18 |      * @param Integer $target
19 |      * @return Integer[][]
20 |      */
21 |     function combinationSum($candidates, $target) {
22 |         // 回溯法
23 |         $this->results = [];
24 |         $result = [];
25 |         sort($candidates);
26 |         $this->dfs($result, $candidates, $target, 0);
27 |         return $this->results;
28 |     }
29 | 
30 |     function dfs($result, $candidates, $target, $level) {
31 | 
32 |         if ($target == 0) {
33 |             $this->results[] = $result;
34 |             return true;
35 |         }
36 | 
37 |         for ($i=$level; $i < count($candidates) && $target - $candidates[$i] >= 0; $i++) { 
38 |             array_push($result, $candidates[$i]);
39 |             $this->dfs($result, $candidates, $target - $candidates[$i], $i);
40 |             array_pop($result);
41 |         }
42 |     }
43 | }
44 | // @lc code=end
45 | 
46 | 


--------------------------------------------------------------------------------
/每日1题202009/[0910]40.组合总和-ii.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=40 lang=php
 4 |  *
 5 |  * [40] 组合总和 II
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/combination-sum-ii/
 8 |  * 视频讲解 https://www.bilibili.com/video/BV1Pb411u7Yd?from=search&seid=13642324053212144492
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     protected $results;
15 | 
16 |     /**
17 |      * @param Integer[] $candidates
18 |      * @param Integer $target
19 |      * @return Integer[][]
20 |      */
21 |     function combinationSum2($candidates, $target) {
22 |         // 回溯法
23 |         $this->results = [];
24 |         $result = [];
25 |         sort($candidates); // 排序方便剪枝
26 |         $this->dfs($result, $candidates, $target, 0);
27 |         return $this->results;
28 |     }
29 | 
30 |     function dfs($result, $candidates, $target, $level) {
31 | 
32 |         if ($target == 0) {
33 |             $this->results[] = $result;
34 |             return true;
35 |         }
36 | 
37 |         for ($i=$level; $i < count($candidates); $i++) {
38 | 
39 |             if ($candidates[$i] > $target) return true;  // 剪枝
40 |             if ($i > $level && $candidates[$i] == $candidates[$i - 1]) continue; // 大于 level 证明不是第一个数，可以对比前一个数，相同则跳过
41 | 
42 |             array_push($result, $candidates[$i]);
43 |             $this->dfs($result, $candidates, $target - $candidates[$i], $i + 1);
44 |             array_pop($result);
45 |         }
46 |     }
47 | }
48 | 
49 | // Accepted
50 | // 172/172 cases passed (8 ms)
51 | // Your runtime beats 100 % of php submissions
52 | // Your memory usage beats 33.33 % of php submissions (14.9 MB)
53 | // @lc code=end
54 | 
55 | 


--------------------------------------------------------------------------------
/每日1题202009/[0914]94.二叉树的中序遍历.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=94 lang=php
 4 |  *
 5 |  * [94] 二叉树的中序遍历
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/binary-tree-inorder-traversal/
 8 |  */
 9 | 
10 | // @lc code=start
11 | /**
12 |  * Definition for a binary tree node.
13 |  * class TreeNode {
14 |  *     public $val = null;
15 |  *     public $left = null;
16 |  *     public $right = null;
17 |  *     function __construct($value) { $this->val = $value; }
18 |  * }
19 |  */
20 | class Solution {
21 | 
22 |     /**
23 |      * @param TreeNode $root
24 |      * @return Integer[]
25 |      */
26 |     function inorderTraversal($root) {
27 |         
28 |         $visited = 1;
29 |         $not_visited = 0;
30 |         $stack[] = [$not_visited, $root];
31 |         $res = [];
32 | 
33 |         while (!empty($stack)) {
34 |             $cur = array_pop($stack);
35 | 
36 |             if ($cur[1] == null) continue;
37 | 
38 |             if ($cur[0] == 0) {
39 |                 $stack[] = [$not_visited, $cur[1]->right];
40 |                 $stack[] = [$visited, $cur[1]];
41 |                 $stack[] = [$not_visited, $cur[1]->left];
42 |             } else {
43 |                 $res[] = $cur[1]->val;
44 |             }
45 |         }
46 | 
47 |         return $res;
48 |     }
49 | }
50 | 
51 | // Accepted
52 | // 68/68 cases passed (8 ms)
53 | // Your runtime beats 61.32 % of php submissions
54 | // Your memory usage beats 33.62 % of php submissions (15 MB)
55 | // @lc code=end
56 | 
57 | 


--------------------------------------------------------------------------------
/每日1题202009/[0914_1]144.二叉树的前序遍历.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=144 lang=php
 4 |  *
 5 |  * [144] 二叉树的前序遍历
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/binary-tree-preorder-traversal/
 8 |  */
 9 | 
10 | // @lc code=start
11 | /**
12 |  * Definition for a binary tree node.
13 |  * class TreeNode {
14 |  *     public $val = null;
15 |  *     public $left = null;
16 |  *     public $right = null;
17 |  *     function __construct($value) { $this->val = $value; }
18 |  * }
19 |  */
20 | class Solution {
21 | 
22 |     /**
23 |      * @param TreeNode $root
24 |      * @return Integer[]
25 |      */
26 |     function preorderTraversal($root) {
27 | 
28 |         // 与中序遍历解法类似，调整了入栈顺序
29 |         $visited = 1;
30 |         $not_visited = 0;
31 |         $stack[] = [$not_visited, $root];
32 |         $res = [];
33 | 
34 |         while (!empty($stack)) {
35 |             $cur = array_pop($stack);
36 | 
37 |             if ($cur[1] == null) continue;
38 | 
39 |             if ($cur[0] == 0) {
40 |                 $stack[] = [$not_visited, $cur[1]->right];
41 |                 $stack[] = [$not_visited, $cur[1]->left];
42 |                 $stack[] = [$visited, $cur[1]];
43 |             } else {
44 |                 $res[] = $cur[1]->val;
45 |             }
46 |         }
47 | 
48 |         return $res;
49 |     }
50 | }
51 | 
52 | // Accepted
53 | // 68/68 cases passed (4 ms)
54 | // Your runtime beats 96.91 % of php submissions
55 | // Your memory usage beats 56.43 % of php submissions (14.9 MB)
56 | // @lc code=end
57 | 
58 | 


--------------------------------------------------------------------------------
/每日1题202009/[0914_2]145.二叉树的后序遍历.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=145 lang=php
 4 |  *
 5 |  * [145] 二叉树的后序遍历
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/binary-tree-postorder-traversal/
 8 |  */
 9 | 
10 | // @lc code=start
11 | /**
12 |  * Definition for a binary tree node.
13 |  * class TreeNode {
14 |  *     public $val = null;
15 |  *     public $left = null;
16 |  *     public $right = null;
17 |  *     function __construct($val = 0, $left = null, $right = null) {
18 |  *         $this->val = $val;
19 |  *         $this->left = $left;
20 |  *         $this->right = $right;
21 |  *     }
22 |  * }
23 |  */
24 | class Solution {
25 | 
26 |     /**
27 |      * @param TreeNode $root
28 |      * @return Integer[]
29 |      */
30 |     function postorderTraversal($root) {
31 |         
32 |         // 与中序遍历解法类似，调整了入栈顺序
33 |         $visited = 1;
34 |         $not_visited = 0;
35 |         $stack[] = [$not_visited, $root];
36 |         $res = [];
37 | 
38 |         while (!empty($stack)) {
39 |             $cur = array_pop($stack);
40 | 
41 |             if ($cur[1] == null) continue;
42 | 
43 |             if ($cur[0] == 0) {
44 |                 $stack[] = [$visited, $cur[1]];
45 |                 $stack[] = [$not_visited, $cur[1]->right];
46 |                 $stack[] = [$not_visited, $cur[1]->left];
47 |             } else {
48 |                 $res[] = $cur[1]->val;
49 |             }
50 |         }
51 | 
52 |         return $res;
53 |     }
54 | }
55 | 
56 | // Accepted
57 | // 68/68 cases passed (8 ms)
58 | // Your runtime beats 69.84 % of php submissions
59 | // Your memory usage beats 26.41 % of php submissions (15 MB)
60 | // @lc code=end
61 | 
62 | 


--------------------------------------------------------------------------------
/每日1题202009/[0916]226.翻转二叉树.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=226 lang=php
 4 |  *
 5 |  * [226] 翻转二叉树
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/invert-binary-tree/
 8 |  */
 9 | 
10 | // @lc code=start
11 | /**
12 |  * Definition for a binary tree node.
13 |  * class TreeNode {
14 |  *     public $val = null;
15 |  *     public $left = null;
16 |  *     public $right = null;
17 |  *     function __construct($value) { $this->val = $value; }
18 |  * }
19 |  */
20 | class Solution {
21 | 
22 |     /**
23 |      * @param TreeNode $root
24 |      * @return TreeNode
25 |      */
26 |     function invertTree($root) {
27 | 
28 |         if ($root == null) return null;
29 | 
30 |         $right = $this->invertTree($root->right);
31 |         $left = $this->invertTree($root->left);
32 | 
33 |         $root->right = $left;
34 |         $root->left = $right;
35 | 
36 |         return $root;
37 |     }
38 | }
39 | 
40 | // Accepted
41 | // 68/68 cases passed (8 ms)
42 | // Your runtime beats 66.19 % of php submissions
43 | // Your memory usage beats 92.65 % of php submissions (14.4 MB)
44 | // @lc code=end
45 | 
46 | 


--------------------------------------------------------------------------------
/每日1题202009/[0918]47.全排列-ii.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=47 lang=php
 4 |  *
 5 |  * [47] 全排列 II
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/permutations-ii/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     protected $len;
14 |     protected $res;
15 | 
16 |     /**
17 |      * @param Integer[] $nums
18 |      * @return Integer[][]
19 |      */
20 |     function permuteUnique($nums) {
21 |         
22 |         if (count($nums) == 0) { return [];}
23 | 
24 |         $this->len = count($nums);
25 |         $this->res = [];
26 |         sort($nums);
27 |         $tmp = [];
28 |         $visited = [];
29 | 
30 |         $this->backtracking($tmp, $visited, $nums);
31 |         return $this->res;
32 |     }
33 | 
34 |     function backtracking(&$tmp, &$visited, $nums) {
35 | 
36 |         if (count($tmp) == $this->len) {
37 |             $this->res[] = $tmp;
38 |             return true;
39 |         }
40 | 
41 |         for ($i=0; $i < $this->len; $i++) {
42 | 
43 |             if ($visited[$i] == "1") continue;
44 | 
45 |             // 剪枝
46 |             if ($i > 0 && $nums[$i] == $nums[$i - 1] && !$visited[$i - 1]) continue;
47 | 
48 |             // 记录状态
49 |             $visited[$i] = "1";
50 |             $tmp[] = $nums[$i];
51 | 
52 |             $this->backtracking($tmp, $visited, $nums);
53 | 
54 |             // 恢复回溯前的状态
55 |             $visited[$i] = "0";
56 |             array_pop($tmp);
57 |         }
58 |     }
59 | }
60 | 
61 | // Accepted
62 | // 30/30 cases passed (16 ms)
63 | // Your runtime beats 91.11 % of php submissions
64 | // Your memory usage beats 21.87 % of php submissions (15.2 MB)
65 | // @lc code=end
66 | 
67 | 


--------------------------------------------------------------------------------
/每日1题202009/[0919]404.左叶子之和.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=404 lang=php
 4 |  *
 5 |  * [404] 左叶子之和
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/sum-of-left-leaves/
 8 |  */
 9 | 
10 | // @lc code=start
11 | /**
12 |  * Definition for a binary tree node.
13 |  * class TreeNode {
14 |  *     public $val = null;
15 |  *     public $left = null;
16 |  *     public $right = null;
17 |  *     function __construct($value) { $this->val = $value; }
18 |  * }
19 |  */
20 | class Solution {
21 | 
22 |     /**
23 |      * @param TreeNode $root
24 |      * @return Integer
25 |      */
26 |     function sumOfLeftLeaves($root) {
27 |         
28 |         if ($root == null) return 0;
29 | 
30 |         $res = 0;
31 |         $this->dfs($root, $res);
32 |         return $res;
33 |     }
34 | 
35 |     function dfs($root, &$res) {
36 |         
37 |         if ($root->left != null) {
38 |             $res += $this->isLeafNode($root->left) ? $root->left->val : $this->dfs($root->left, $res);
39 |         }
40 | 
41 |         if ($root->right != null && !$this->isLeafNode($root->right)) {
42 |             $res += $this->dfs($root->right, $res);
43 |         }
44 |     }
45 | 
46 |     // 判断是否叶子节点
47 |     function isLeafNode($node) {
48 |         
49 |         if ($node->left == null && $node->right == null) {
50 |             return true;
51 |         }
52 | 
53 |         return false;
54 |     }
55 | }
56 | 
57 | // Accepted
58 | // 102/102 cases passed (8 ms)
59 | // Your runtime beats 67.74 % of php submissions
60 | // Your memory usage beats 18.18 % of php submissions (15.2 MB)
61 | // @lc code=end
62 | 
63 | 


--------------------------------------------------------------------------------
/每日1题202009/[0920]78.子集.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=78 lang=php
 4 |  *
 5 |  * [78] 子集
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/subsets/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     protected $res;
14 |     /**
15 |      * @param Integer[] $nums
16 |      * @return Integer[][]
17 |      */
18 |     function subsets($nums) {
19 |         
20 |         $this->res = [];
21 | 
22 |         // 控制个数，0到最大递增
23 |         for ($i=0; $i <= count($nums); $i++) { 
24 |             $this->backtracking(0, $i, [], $nums);
25 |         }
26 | 
27 |         return $this->res;
28 |     }
29 | 
30 |     function backtracking($first, $k, $cur, $nums) {
31 | 
32 |         if (count($cur) == $k) {
33 |             $this->res[] = $cur;
34 |             return true;
35 |         }
36 | 
37 |         for ($i=$first; $i < count($nums); $i++) { 
38 |             $cur[] = $nums[$i];
39 |             $this->backtracking($i + 1, $k, $cur, $nums);
40 |             array_pop($cur);
41 |         }
42 |     }
43 | }
44 | 
45 | // Accepted
46 | // 10/10 cases passed (12 ms)
47 | // Your runtime beats 37.72 % of php submissions
48 | // Your memory usage beats 34.43 % of php submissions (15.1 MB)
49 | // @lc code=end
50 | 
51 | 


--------------------------------------------------------------------------------
/每日1题202009/[0921]538.把二叉搜索树转换为累加树.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=538 lang=php
 4 |  *
 5 |  * [538] 把二叉搜索树转换为累加树
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/convert-bst-to-greater-tree/
 8 |  */
 9 | 
10 | // @lc code=start
11 | /**
12 |  * Definition for a binary tree node.
13 |  * class TreeNode {
14 |  *     public $val = null;
15 |  *     public $left = null;
16 |  *     public $right = null;
17 |  *     function __construct($value) { $this->val = $value; }
18 |  * }
19 |  */
20 | class Solution {
21 | 
22 |     public $sum;
23 | 
24 |     /**
25 |      * @param TreeNode $root
26 |      * @return TreeNode
27 |      */
28 |     function convertBST($root) {
29 |         
30 |         // 中序遍历是递增序列，反向中序就是递减序列，最小的值就能累加到前面大于子集的数
31 |         if ($root != null) {
32 |             $this->convertBST($root->right);
33 |             $this->sum += $root->val;
34 |             $root->val = $this->sum;
35 |             $this->convertBST($root->left);
36 |         }
37 | 
38 |         return $root;
39 |     }
40 | }
41 | 
42 | // Accepted
43 | // 212/212 cases passed (28 ms)
44 | // Your runtime beats 69.23 % of php submissions
45 | // Your memory usage beats 8.82 % of php submissions (18.3 MB)
46 | // @lc code=end
47 | 
48 | 


--------------------------------------------------------------------------------
/每日1题202009/[0923]617.合并二叉树.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=617 lang=php
 4 |  *
 5 |  * [617] 合并二叉树
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/merge-two-binary-trees/
 8 |  */
 9 | 
10 | // @lc code=start
11 | /**
12 |  * Definition for a binary tree node.
13 |  * class TreeNode {
14 |  *     public $val = null;
15 |  *     public $left = null;
16 |  *     public $right = null;
17 |  *     function __construct($value) { $this->val = $value; }
18 |  * }
19 |  */
20 | class Solution {
21 | 
22 |     /**
23 |      * @param TreeNode $t1
24 |      * @param TreeNode $t2
25 |      * @return TreeNode
26 |      */
27 |     function mergeTrees($t1, $t2) {
28 | 
29 |         if ($t1 == null) return $t2;
30 |         if ($t2 == null) return $t1;
31 | 
32 |         $root = $t1;
33 |         $root->val += $t2->val;
34 | 
35 |         $root->left = $this->mergeTrees($t1->left, $t2->left);
36 |         $root->right = $this->mergeTrees($t1->right, $t2->right);
37 | 
38 |         return $root;
39 |     }
40 | }
41 | 
42 | // Accepted
43 | // 183/183 cases passed (24 ms)
44 | // Your runtime beats 89.86 % of php submissions
45 | // Your memory usage beats 81.58 % of php submissions (15.2 MB)
46 | // @lc code=end


--------------------------------------------------------------------------------
/每日1题202009/[0927]235.二叉搜索树的最近公共祖先.php:
--------------------------------------------------------------------------------
 1 | <?
 2 | /*
 3 |  * @lc app=leetcode.cn id=235 lang=php
 4 |  *
 5 |  * [235] 二叉搜索树的最近公共祖先
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-search-tree/
 8 |  * 参考题解 https://zxi.mytechroad.com/blog/tree/leetcode-235-lowest-common-ancestor-of-a-binary-search-tree/
 9 |  */
10 | 
11 | // @lc code=start
12 | /**
13 |  * Definition for a binary tree node.
14 |  * class TreeNode {
15 |  *     public $val = null;
16 |  *     public $left = null;
17 |  *     public $right = null;
18 |  *     function __construct($value) { $this->val = $value; }
19 |  * }
20 |  */
21 | 
22 | class Solution {
23 |     /**
24 |      * @param TreeNode $root
25 |      * @param TreeNode $p
26 |      * @param TreeNode $q
27 |      * @return TreeNode
28 |      */
29 |     function lowestCommonAncestor($root, $p, $q) {
30 |         // 二叉搜索树的特征，左子树节点值 <= 中间节点值 <= 右子树节点值
31 | 
32 |         // 如果两者都小于根节点的值，那么搜索它的左子树
33 |         if ($p->val < $root->val && $q->val < $root->val) {
34 |             return $this->lowestCommonAncestor($root->left, $p, $q);
35 |         }
36 | 
37 |         // 如果两者都大于根节点的值，那么搜索它的右子树
38 |         if ($p->val > $root->val && $q->val > $root->val) {
39 |             return $this->lowestCommonAncestor($root->right, $p, $q);
40 |         }
41 | 
42 |         // 一大一小、一大于一相等、一小于一相等，那么返回当前根节点
43 |         return $root;
44 |     }
45 | }
46 | 
47 | // Accepted
48 | // 27/27 cases passed (32 ms)
49 | // Your runtime beats 97.62 % of php submissions
50 | // Your memory usage beats 32.61 % of php submissions (18.1 MB)
51 | // @lc code=end
52 | 
53 | 


--------------------------------------------------------------------------------
/每日1题202009/[0930]701.二叉搜索树中的插入操作.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=701 lang=php
 4 |  *
 5 |  * [701] 二叉搜索树中的插入操作
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/insert-into-a-binary-search-tree/
 8 |  */
 9 | 
10 | // @lc code=start
11 | /**
12 |  * Definition for a binary tree node.
13 |  * class TreeNode {
14 |  *     public $val = null;
15 |  *     public $left = null;
16 |  *     public $right = null;
17 |  *     function __construct($val = 0, $left = null, $right = null) {
18 |  *         $this->val = $val;
19 |  *         $this->left = $left;
20 |  *         $this->right = $right;
21 |  *     }
22 |  * }
23 |  */
24 | class Solution {
25 | 
26 |     /**
27 |      * @param TreeNode $root
28 |      * @param Integer $val
29 |      * @return TreeNode
30 |      */
31 |     function insertIntoBST($root, $val) {
32 | 
33 |         if ($root == null) return new TreeNode($val);
34 | 
35 |         $this->helper($root, $val);
36 |         return $root;
37 |     }
38 | 
39 |     function helper(&$root, $val) {
40 | 
41 |         if ($root->val > $val) {
42 |             if ($root->left == null) {
43 |                 $root->left = new TreeNode($val);
44 |                 return true;
45 |             }
46 |             $this->helper($root->left, $val);
47 |         }
48 | 
49 |         if ($root->val < $val) {
50 |             if ($root->right == null) {
51 |                 $root->right = new TreeNode($val);
52 |                 return true;
53 |             }
54 |             $this->helper($root->right, $val);
55 |         }
56 | 
57 |     }
58 | }
59 | 
60 | // Accepted
61 | // 35/35 cases passed (44 ms)
62 | // Your runtime beats 88 % of php submissions
63 | // Your memory usage beats 50 % of php submissions (16.8 MB)
64 | // @lc code=end
65 | 
66 | 


--------------------------------------------------------------------------------
/每日1题202010/README.md:
--------------------------------------------------------------------------------
1 | # leetcode 每日1题


--------------------------------------------------------------------------------
/每日1题202010/[1003]1.两数之和.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=1 lang=php
 4 |  *
 5 |  * [1] 两数之和
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/two-sum/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $nums
15 |      * @param Integer $target
16 |      * @return Integer[]
17 |      */
18 |     function twoSum($nums, $target) {
19 | 
20 |         $visited = [];
21 |         foreach ($nums as $k => $num) {
22 |             if (array_key_exists($target - $num, $visited)) {
23 |                 if ($nums[$visited[$target - $num]] + $num === $target) {
24 |                     return [$visited[$target - $num], $k];
25 |                 }
26 |             }
27 | 
28 |             $visited[$num] = $k;
29 |         }
30 |     }
31 | }
32 | 
33 | // Accepted
34 | // 29/29 cases passed (16 ms)
35 | // Your runtime beats 80.91 % of php submissions
36 | // Your memory usage beats 32.61 % of php submissions (15.6 MB)
37 | // @lc code=end
38 | 
39 | 


--------------------------------------------------------------------------------
/每日1题202010/[1007]75.颜色分类_单向遍历.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=75 lang=php
 4 |  *
 5 |  * [75] 颜色分类
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/sort-colors/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $nums
15 |      * @return NULL
16 |      */
17 |     function sortColors(&$nums) {
18 | 
19 |         // 初始次数
20 |         $red = 0;
21 |         $white = 0;
22 |         $blue = 0;
23 |         
24 |         for ($i=0; $i < count($nums); $i++) { 
25 |             if ($nums[$i] == 0) {
26 |                 $red++;
27 |             }
28 |             if ($nums[$i] == 1) {
29 |                 $white++;
30 |             }
31 |             if ($nums[$i] == 2) {
32 |                 $blue++;
33 |             }
34 |         }
35 | 
36 |         $nums = array_merge(
37 |             array_fill(0, $red, 0), 
38 |             array_fill(0, $white, 1), 
39 |             array_fill(0, $blue, 2)
40 |         );
41 |     }
42 | }
43 | 
44 | // Accepted
45 | // 87/87 cases passed (12 ms)
46 | // Your runtime beats 37.5 % of php submissions
47 | // Your memory usage beats 26.32 % of php submissions (14.6 MB)
48 | // @lc code=end
49 | 
50 | 


--------------------------------------------------------------------------------
/每日1题202010/[1007]75.颜色分类_双指针.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=75 lang=php
 4 |  *
 5 |  * [75] 颜色分类
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/sort-colors/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $nums
15 |      * @return NULL
16 |      */
17 |     function sortColors(&$nums) {
18 | 
19 |         // 初始次数
20 |         $red = 0;
21 |         $white = 0;
22 |         $blue = 0;
23 |         $l = 0;
24 |         $r = count($nums) - 1;
25 | 
26 |         while ($l <= $r) {
27 |             if ($nums[$l] == 0 || $nums[$r] == 0) {
28 |                 if ($nums[$l] == 0 && $nums[$r] == 0 && $l != $r) $red++; 
29 |                 $red++;
30 |             }
31 |             if ($nums[$l] == 1 || $nums[$r] == 1) {
32 |                 if ($nums[$l] == 1 && $nums[$r] == 1 && $l != $r) $white++; 
33 |                 $white++;
34 |             }
35 |             if ($nums[$l] == 2 || $nums[$r] == 2) {
36 |                 if ($nums[$l] == 2 && $nums[$r] == 2 && $l != $r) $blue++; 
37 |                 $blue++;
38 |             }
39 | 
40 |             if ($l == $r) break;
41 |             $l++;
42 |             $r--;
43 |         }
44 | 
45 |         $nums = array_merge(
46 |             array_fill(0, $red, 0), 
47 |             array_fill(0, $white, 1), 
48 |             array_fill(0, $blue, 2)
49 |         );
50 |     }
51 | }
52 | 
53 | // Accepted
54 | // 87/87 cases passed (4 ms)
55 | // Your runtime beats 96.88 % of php submissions
56 | // Your memory usage beats 13.16 % of php submissions (14.7 MB)
57 | // @lc code=end
58 | 
59 | 


--------------------------------------------------------------------------------
/每日1题202010/[1008]344.反转字符串_双指针.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=344 lang=php
 4 |  *
 5 |  * [344] 反转字符串
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/reverse-string/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param String[] $s
15 |      * @return NULL
16 |      */
17 |     function reverseString(&$s) {
18 | 
19 |         if ($s == null) return null;
20 |         
21 |         $l = 0;
22 |         $r = count($s) - 1;
23 |         while ($l != $r) {
24 |             $tmp = $s[$l];
25 |             $s[$l] = $s[$r];
26 |             $s[$r] = $tmp;
27 |             if ($r - $l == 1) break;
28 |             $l++;
29 |             $r--;
30 |         }
31 |     }
32 | }
33 | 
34 | // Accepted
35 | // 478/478 cases passed (100 ms)
36 | // Your runtime beats 7.39 % of php submissions
37 | // Your memory usage beats 12.28 % of php submissions (34.9 MB)
38 | 
39 | // Accepted
40 | // 478/478 cases passed (68 ms)
41 | // Your runtime beats 49.03 % of php submissions
42 | // Your memory usage beats 21.05 % of php submissions (34.8 MB)
43 | // @lc code=end
44 | 
45 | 


--------------------------------------------------------------------------------
/每日1题202010/[1009]141.环形链表_哈希表.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=141 lang=php
 4 |  *
 5 |  * [141] 环形链表
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/linked-list-cycle/
 8 |  */
 9 | 
10 | // @lc code=start
11 | /**
12 |  * Definition for a singly-linked list.
13 |  * class ListNode {
14 |  *     public $val = 0;
15 |  *     public $next = null;
16 |  *     function __construct($val) { $this->val = $val; }
17 |  * }
18 |  */
19 | 
20 | class Solution {
21 |     /**
22 |      * @param ListNode $head
23 |      * @return Boolean
24 |      */
25 |     function hasCycle($head) {
26 |         $visited = [];
27 |         
28 |         while ($head != null) {
29 |             if (in_array($head, $visited)) { // listNode 也可以这样查找
30 |                 return true;
31 |             }
32 |             $visited[] = $head;
33 |             $head = $head->next;
34 |         }
35 |         return false;
36 |     }
37 | }
38 | 
39 | // Accepted
40 | // 17/17 cases passed (2064 ms)
41 | // Your runtime beats 10.94 % of php submissions
42 | // Your memory usage beats 37.08 % of php submissions (17.3 MB)
43 | // @lc code=end
44 | 
45 | 


--------------------------------------------------------------------------------
/每日1题202010/[1009]141.环形链表_快慢指针.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=141 lang=php
 4 |  *
 5 |  * [141] 环形链表
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/linked-list-cycle/
 8 |  */
 9 | 
10 | // @lc code=start
11 | /**
12 |  * Definition for a singly-linked list.
13 |  * class ListNode {
14 |  *     public $val = 0;
15 |  *     public $next = null;
16 |  *     function __construct($val) { $this->val = $val; }
17 |  * }
18 |  */
19 | 
20 | class Solution {
21 |     /**
22 |      * @param ListNode $head
23 |      * @return Boolean
24 |      */
25 |     function hasCycle($head) {
26 |         if ($head == null || $head->next == null) {
27 |             return false;
28 |         }
29 | 
30 |         // 快指针走两步，慢指针走一步，如果能够相遇则该链表有环
31 |         $slow = $head;
32 |         $fast = $head->next->next;
33 |         while ($fast != $slow) {
34 |             if ($slow == null || $fast == null) {
35 |                 return false;
36 |             }
37 |             $slow = $slow->next;
38 |             $fast = $fast->next->next;
39 |         }
40 | 
41 |         return true;
42 |     }
43 | }
44 | 
45 | // Accepted
46 | // 17/17 cases passed (16 ms)
47 | // Your runtime beats 70.94 % of php submissions
48 | // Your memory usage beats 65.56 % of php submissions (17.2 MB)
49 | // @lc code=end
50 | 
51 | 


--------------------------------------------------------------------------------
/每日1题202010/[1016]977.有序数组的平方_双指针.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=977 lang=php
 4 |  *
 5 |  * [977] 有序数组的平方
 6 |  * 
 7 |  * http://leetcode-cn.com/problems/squares-of-a-sorted-array/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $A
15 |      * @return Integer[]
16 |      */
17 |     function sortedSquares($A) {
18 | 
19 |         $n = count($A);
20 |         $ans = array_fill(0, $n, 0);
21 |         $i=0; $j = $n - 1; $pos = $n - 1;
22 |         while ($i <= $j) { // 左右端点取较大的填入结果集最后的位置，最终形成递增数组
23 |             if ($A[$i] * $A[$i] > $A[$j] * $A[$j]) {
24 |                 $ans[$pos] = $A[$i] * $A[$i];
25 |                 $i++;
26 |             } else {
27 |                 $ans[$pos] = $A[$j] * $A[$j];
28 |                 $j--;
29 |             }
30 |             $pos--;
31 |         }
32 |         return $ans;
33 |     }
34 | }
35 | 
36 | // Accepted
37 | // 132/132 cases passed (76 ms)
38 | // Your runtime beats 97.06 % of php submissions
39 | // Your memory usage beats 9.52 % of php submissions (18 MB)
40 | // @lc code=end
41 | 
42 | 


--------------------------------------------------------------------------------
/每日1题202010/[1016]977.有序数组的平方_常规解法.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=977 lang=php
 4 |  *
 5 |  * [977] 有序数组的平方
 6 |  * 
 7 |  * http://leetcode-cn.com/problems/squares-of-a-sorted-array/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $A
15 |      * @return Integer[]
16 |      */
17 |     function sortedSquares($A) {
18 | 
19 |         $ans = [];
20 | 
21 |         foreach ($A as $k => $v) {
22 |             $ans[$k] = $v * $v;
23 |         }
24 | 
25 |         sort($ans);
26 |         return $ans;
27 |     }
28 | }
29 | 
30 | // Accepted
31 | // 132/132 cases passed (72 ms)
32 | // Your runtime beats 100 % of php submissions
33 | // Your memory usage beats 9.52 % of php submissions (17.9 MB)
34 | // @lc code=end
35 | 
36 | 


--------------------------------------------------------------------------------
/每日1题202010/[1018]19.删除链表的倒数第n个节点.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=19 lang=php
 4 |  *
 5 |  * [19] 删除链表的倒数第N个节点
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/
 8 |  * 参考题解 https://zxi.mytechroad.com/blog/list/leetcode-19-remove-nth-node-from-end-of-list/
 9 |  */
10 | 
11 | // @lc code=start
12 | /**
13 |  * Definition for a singly-linked list.
14 |  * class ListNode {
15 |  *     public $val = 0;
16 |  *     public $next = null;
17 |  *     function __construct($val = 0, $next = null) {
18 |  *         $this->val = $val;
19 |  *         $this->next = $next;
20 |  *     }
21 |  * }
22 |  */
23 | class Solution {
24 | 
25 |     /**
26 |      * @param ListNode $head
27 |      * @param Integer $n
28 |      * @return ListNode
29 |      */
30 |     function removeNthFromEnd($head, $n) {
31 |         if (!$head) return null;
32 | 
33 |         $nodes = [];
34 |         $cur = $head;
35 |         while ($cur) {
36 |             $nodes[] = $cur;
37 |             $cur = $cur->next;
38 |         }
39 | 
40 |         // 链表长度 == n
41 |         $size = count($nodes);
42 |         if ($n == $size) return $head->next;
43 | 
44 |         // 找到需要删除的结点  
45 |         $node_to_remove = $nodes[$size - $n];
46 |         // 找到被删除的结点的前一个节点
47 |         $parent = $nodes[$size - $n - 1];
48 |         // 将 next 指针指向被删除的结点的 next 指针
49 |         $parent->next = $node_to_remove->next;
50 | 
51 |         return $head;
52 |     }
53 | }
54 | 
55 | // Accepted
56 | // 208/208 cases passed (8 ms)
57 | // Your runtime beats 71.79 % of php submissions
58 | // Your memory usage beats 30.52 % of php submissions (15 MB)
59 | // @lc code=end
60 | 
61 | 


--------------------------------------------------------------------------------
/每日1题202010/[1018]19.删除链表的倒数第n个节点_双指针.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=19 lang=php
 4 |  *
 5 |  * [19] 删除链表的倒数第N个节点
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/
 8 |  * 参考题解 https://zxi.mytechroad.com/blog/list/leetcode-19-remove-nth-node-from-end-of-list/
 9 |  */
10 | 
11 | // @lc code=start
12 | /**
13 |  * Definition for a singly-linked list.
14 |  * class ListNode {
15 |  *     public $val = 0;
16 |  *     public $next = null;
17 |  *     function __construct($val = 0, $next = null) {
18 |  *         $this->val = $val;
19 |  *         $this->next = $next;
20 |  *     }
21 |  * }
22 |  */
23 | class Solution {
24 | 
25 |     /**
26 |      * @param ListNode $head
27 |      * @param Integer $n
28 |      * @return ListNode
29 |      */
30 |     function removeNthFromEnd($head, $n) {
31 |         // 不使用数组存放节点的做法
32 |         $l = 0;
33 |         $cur = $head;
34 |         while ($cur) {
35 |             $l++;
36 |             $cur = $cur->next;
37 |         }
38 | 
39 |         if ($n == $l) {
40 |             return $head->next;
41 |         }
42 | 
43 |         $l = $l - $n;
44 |         $cur = $head;
45 |         while (--$l) {
46 |             $cur = $cur->next; // 需要删除结点的前一个
47 |         }
48 |         $node = $cur->next; // 需要删除的结点
49 |         $cur->next = $node->next; // 需要删除的结点的后一个
50 |         return $head;
51 |     }
52 | }
53 | 
54 | // Accepted
55 | // 208/208 cases passed (12 ms)
56 | // Your runtime beats 27.11 % of php submissions
57 | // Your memory usage beats 16.07 % of php submissions (15.3 MB)
58 | // @lc code=end
59 | 
60 | 


--------------------------------------------------------------------------------
/每日1题202010/[1019]844.比较含退格的字符串.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=844 lang=php
 4 |  *
 5 |  * [844] 比较含退格的字符串
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/backspace-string-compare/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param String $S
15 |      * @param String $T
16 |      * @return Boolean
17 |      */
18 |     function backspaceCompare($S, $T) {
19 |         return $this->helper($S) == $this->helper($T);
20 |     }
21 | 
22 |     function helper($str) {
23 |         if (strlen($str) == 1) return $str;
24 |         
25 |         $o = [];
26 |         for ($i=0; $i < strlen($str); $i++) { 
27 |             $c = $str[$i];
28 |             if ($c == '#') {
29 |                 if (!empty($o)) {
30 |                     array_pop($o);
31 |                 }
32 |             } else {
33 |                 array_push($o, $c);
34 |             }
35 |         }
36 | 
37 |         return implode("", $o);
38 |     }
39 | }
40 | 
41 | // Accepted
42 | // 110/110 cases passed (4 ms)
43 | // Your runtime beats 97.65 % of php submissions
44 | // Your memory usage beats 71.6 % of php submissions (15.1 MB)
45 | // @lc code=end
46 | 
47 | 


--------------------------------------------------------------------------------
/每日1题202010/[1020]143.重排链表_线性表存储.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=143 lang=php
 4 |  *
 5 |  * [143] 重排链表
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/reorder-list/
 8 |  * 参考题解 https://leetcode-cn.com/problems/reorder-list/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by-34/
 9 |  */
10 | 
11 | // @lc code=start
12 | /**
13 |  * Definition for a singly-linked list.
14 |  * class ListNode {
15 |  *     public $val = 0;
16 |  *     public $next = null;
17 |  *     function __construct($val = 0, $next = null) {
18 |  *         $this->val = $val;
19 |  *         $this->next = $next;
20 |  *     }
21 |  * }
22 |  */
23 | class Solution {
24 | 
25 |     /**
26 |      * @param ListNode $head
27 |      * @return NULL
28 |      */
29 |     function reorderList($head) {
30 |         if ($head == null) {
31 |             return null;
32 |         }
33 | 
34 |         $list = [];
35 |         while ($head != null) {
36 |             $list[] = $head;
37 |             $head = $head->next;
38 |         }
39 | 
40 |         $i = 0;
41 |         $j = count($list) - 1;
42 |         while ($i < $j) {
43 |             $list[$i]->next = $list[$j]; // 例如: L(0)->next = L(N) 
44 |             $i++;
45 |             // 偶数个节点的情况，会提前相遇
46 |             if ($i == $j) {
47 |                 break;
48 |             }
49 |             $list[$j]->next = $list[$i]; // i++，此时 L(0)->L(N)->next = L(1)
50 |             $j--;
51 |         }
52 | 
53 |         $list[$i]->next = null;
54 |     }
55 | }
56 | 
57 | // Accepted
58 | // 13/13 cases passed (44 ms)
59 | // Your runtime beats 14.14 % of php submissions
60 | // Your memory usage beats 41.05 % of php submissions (25.1 MB)
61 | // @lc code=end
62 | 
63 | 


--------------------------------------------------------------------------------
/每日1题202010/[1021]925.长按键入.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=925 lang=php
 4 |  *
 5 |  * [925] 长按键入
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/long-pressed-name/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param String $name
15 |      * @param String $typed
16 |      * @return Boolean
17 |      */
18 |     function isLongPressedName($name, $typed) {
19 |         // "alex"
20 |         // "aaleex"
21 |         $name_arr = str_split($name);
22 |         $typed_arr = str_split($typed);
23 |         $n_len = count($name_arr);
24 |         $t_len = count($typed_arr);
25 | 
26 |         $i = 0;
27 |         $j = 0;
28 |         while ($i < $n_len && $j < $t_len) {
29 |             if ($name_arr[$i] == $typed_arr[$j]) { // 相等同时右移一位
30 |                 $i++;
31 |                 $j++;
32 |             } elseif ($j > 0 && $typed_arr[$j] == $typed_arr[$j - 1]) { // 重复按的情况，type右移一位
33 |                     $j++;
34 |             } else {
35 |                 return false;
36 |             }
37 |         }
38 | 
39 |         // type 还没走完，剩下的都和前面一样
40 |         while ($j < $t_len && $typed_arr[$j] == $typed_arr[$j - 1]) {
41 |             $j++;
42 |         }
43 | 
44 |         // 两者都走到最后一位，才算匹配
45 |         return $i == $n_len && $j == $t_len;
46 |     }
47 | }
48 | 
49 | // Accepted
50 | // 84/84 cases passed (4 ms)
51 | // Your runtime beats 96.32 % of php submissions
52 | // Your memory usage beats 77.95 % of php submissions (15.2 MB)
53 | // @lc code=end
54 | 
55 | 


--------------------------------------------------------------------------------
/每日1题202010/[1022]763.划分字母区间.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=763 lang=php
 4 |  *
 5 |  * [763] 划分字母区间
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/unique-number-of-occurrences/
 8 |  * 参考题解 https://zxi.mytechroad.com/blog/string/leetcode-763-partition-labels/
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     /**
15 |      * @param String $S
16 |      * @return Integer[]
17 |      */
18 |     function partitionLabels($S) {
19 |         $last_index = [];
20 |         for ($i=0; $i < strlen($S); $i++) { // 先查出每个字符最后的位置
21 |             $last_index[$S[$i]] = $i;
22 |         }
23 | 
24 |         $ans = [];
25 |         for ($i=0; $i < strlen($S); $i++) { 
26 |             $end = max($end, $last_index[$S[$i]]); // 找到最后一次出现的位置
27 |             if ($i == $end) {
28 |                 $ans[] = $end - $start + 1;
29 |                 $start = $end + 1;
30 |             }
31 |         }
32 |         
33 |         return $ans;
34 |         
35 |     }
36 | }
37 | 
38 | // 复杂度分析
39 | // Time complexity: O(n)
40 | // Space complexity: O(26/128)
41 | 
42 | // Accepted
43 | // 116/116 cases passed (8 ms)
44 | // Your runtime beats 98.88 % of php submissions
45 | // Your memory usage beats 5.75 % of php submissions (15.4 MB)
46 | // @lc code=end


--------------------------------------------------------------------------------
/每日1题202010/[1022]763.划分字母区间_暴力解法.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=763 lang=php
 4 |  *
 5 |  * [763] 划分字母区间
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/partition-labels/
 8 |  * 参考题解 https://zxi.mytechroad.com/blog/string/leetcode-763-partition-labels/
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     /**
15 |      * @param String $S
16 |      * @return Integer[]
17 |      */
18 |     function partitionLabels($S) {
19 |         // 暴力解法
20 |         $ans = [];
21 |         $start = 0;
22 |         $end = 0;
23 | 
24 |         for ($i=0; $i < strlen($S); $i++) { 
25 |             $end = max($end, strrpos($S, $S[$i])); // 找到最后一次出现的位置
26 |             if ($i == $end) {
27 |                 $ans[] = $end - $start + 1;
28 |                 $start = $end + 1;
29 |             }
30 |         }
31 |         
32 |         return $ans;
33 |     }
34 | }
35 | // 复杂度分析
36 | // Time complexity: O(n^2)
37 | // Space complexity: O(1)
38 | 
39 | // Accepted
40 | // 116/116 cases passed (12 ms)
41 | // Your runtime beats 73.03 % of php submissions
42 | // Your memory usage beats 34.48 % of php submissions (15.3 MB)
43 | // @lc code=end
44 | 
45 | 


--------------------------------------------------------------------------------
/每日1题202010/[1023]234.回文链表_数组存储.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=234 lang=php
 4 |  *
 5 |  * [234] 回文链表
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/palindrome-linked-list/
 8 |  */
 9 | 
10 | // @lc code=start
11 | /**
12 |  * Definition for a singly-linked list.
13 |  * class ListNode {
14 |  *     public $val = 0;
15 |  *     public $next = null;
16 |  *     function __construct($val) { $this->val = $val; }
17 |  * }
18 |  */
19 | class Solution {
20 | 
21 |     /**
22 |      * @param ListNode $head
23 |      * @return Boolean
24 |      */
25 |     function isPalindrome($head) {
26 | 
27 |         if ($head == null) return true;
28 |         
29 |         $tmp = [];
30 |         while ($head != null) {
31 |             $tmp[] = $head->val;
32 |             $head = $head->next;
33 |         }
34 | 
35 |         $i = 0;
36 |         $j = count($tmp) - 1;
37 |         while ($i < $j) {
38 |             if ($tmp[$i] != $tmp[$j]) {
39 |                 return false;
40 |             }
41 |             $i++;
42 |             $j--;
43 |         }
44 | 
45 |         return true;
46 |     }
47 | }
48 | 
49 | // Accepted
50 | // 26/26 cases passed (24 ms)
51 | // Your runtime beats 87.57 % of php submissions
52 | // Your memory usage beats 49.16 % of php submissions (27.4 MB)
53 | // @lc code=end
54 | 
55 | 


--------------------------------------------------------------------------------
/每日1题202010/[1028]1207.独一无二的出现次数.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=1207 lang=php
 4 |  *
 5 |  * [1207] 独一无二的出现次数
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/unique-number-of-occurrences/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $arr
15 |      * @return Boolean
16 |      */
17 |     function uniqueOccurrences($arr) {
18 | 
19 |         $tmp = [];
20 |         foreach ($arr as $k => $v) { 
21 |             if (!array_key_exists($v, $tmp)) { // 统计次数
22 |                 $tmp[$v] = 1;
23 |             } else {
24 |                 $tmp[$v]++;
25 |             }
26 |         }
27 | 
28 |         sort($tmp); // 排序
29 |         $prev = 0;
30 |         foreach ($tmp as $k1 => $v1) {
31 |             if ($prev > 0 && $prev == $v1) { // 出现相同的返回 false
32 |                 return false;
33 |             } else {
34 |                 $prev = $v1;
35 |             }
36 |         }
37 | 
38 |         return true;
39 |     }
40 | }
41 | 
42 | // Accepted
43 | // 63/63 cases passed (8 ms)
44 | // Your runtime beats 69.57 % of php submissions
45 | // Your memory usage beats 9.52 % of php submissions (15.5 MB)
46 | // @lc code=end
47 | 
48 | 


--------------------------------------------------------------------------------
/每日1题202010/[1029]129.求根到叶子节点数字之和.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=129 lang=php
 4 |  *
 5 |  * [129] 求根到叶子节点数字之和
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/sum-root-to-leaf-numbers/
 8 |  */
 9 | 
10 | // @lc code=start
11 | /**
12 |  * Definition for a binary tree node.
13 |  * class TreeNode {
14 |  *     public $val = null;
15 |  *     public $left = null;
16 |  *     public $right = null;
17 |  *     function __construct($value) { $this->val = $value; }
18 |  * }
19 |  */
20 | class Solution {
21 | 
22 |     protected $ans;
23 | 
24 |     /**
25 |      * @param TreeNode $root
26 |      * @return Integer
27 |      */
28 |     function sumNumbers($root) {
29 | 
30 |         if ($root == null) return 0;
31 | 
32 |         $this->ans = 0;
33 |         $this->helper($root, 0);
34 |         return $this->ans;
35 |     }
36 | 
37 |     function helper($t, $num) {
38 | 
39 |         if ($t == null) return true;
40 | 
41 |         $num = 10 * $num + $t->val; // 1->2->3 == 123
42 |         if ($t->left == null && $t->right == null) { // 叶子节点时退出
43 |             $this->ans += $num;
44 |         } else {
45 |             $this->helper($t->left, $num); 
46 |             $this->helper($t->right, $num);
47 |         }
48 |     }
49 | }
50 | 
51 | // Accepted
52 | // 110/110 cases passed (8 ms)
53 | // Your runtime beats 64.71 % of php submissions
54 | // Your memory usage beats 25 % of php submissions (15.6 MB)
55 | // @lc code=end
56 | 
57 | 


--------------------------------------------------------------------------------
/每日1题202010/[1030]463.岛屿的周长.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=463 lang=php
 4 |  *
 5 |  * [463] 岛屿的周长
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/island-perimeter/
 8 |  * 参考题解 https://zxi.mytechroad.com/blog/math/leetcode-463-island-perimeter/
 9 |  */
10 | 
11 | // @lc code=start
12 | class Solution {
13 | 
14 |     /**
15 |      * @param Integer[][] $grid
16 |      * @return Integer
17 |      */
18 |     function islandPerimeter($grid) {
19 | 
20 |         if (count($grid) == 0 || count($grid[0]) == 0) return 0;
21 | 
22 |         $area = 0;
23 |         $conn = 0;
24 |         $m = count($grid);
25 |         $n = count($grid[0]);
26 |         for ($i=0; $i < $m; $i++) { 
27 |             for ($j=0; $j < $n; $j++) { 
28 |                 if ($grid[$i][$j] == 1) {
29 |                     ++$area; // 岛屿数量+1
30 |                     if ($i > 0 && $grid[$i - 1][$j] == 1) ++$conn; // 如果上面有岛屿各子，记录一次相邻
31 |                     if ($j > 0 && $grid[$i][$j - 1] == 1) ++$conn; // 如果左边有岛屿各子，记录一次相邻
32 |                 }
33 |             }
34 |         }
35 | 
36 |         return $area*4 - $conn*2; // 每次相邻需要减去合并的两条边
37 |     }
38 | }
39 | 
40 | // Accepted
41 | // 5833/5833 cases passed (220 ms)
42 | // Your runtime beats 65.22 % of php submissions
43 | // Your memory usage beats 52.63 % of php submissions (17.3 MB)
44 | // @lc code=end
45 | 
46 | 


--------------------------------------------------------------------------------
/每日1题202011/README.md:
--------------------------------------------------------------------------------
1 | # leetcode 每日1题


--------------------------------------------------------------------------------
/每日1题202011/[1102]349.两个数组的交集_暴力解法.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=349 lang=php
 4 |  *
 5 |  * [349] 两个数组的交集
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/intersection-of-two-arrays
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $nums1
15 |      * @param Integer[] $nums2
16 |      * @return Integer[]
17 |      */
18 |     function intersection($nums1, $nums2) {
19 |         $n1 = count($nums1);
20 |         $n2 = count($nums2);
21 | 
22 |         $ans = [];
23 |         $nums = [];
24 |         if ($n1 > $n2) {
25 |             $nums = array_unique($nums2);
26 |             foreach ($nums as $v) {
27 |                 if (in_array($v, $nums1)) {
28 |                     $ans[] = $v;
29 |                 }
30 |             }
31 |         } else {
32 |             $nums = array_unique($nums1);
33 |             foreach ($nums as $v) {
34 |                 if (in_array($v, $nums2)) {
35 |                     $ans[] = $v;
36 |                 }
37 |             }
38 |         }
39 | 
40 |         return $ans;
41 |     }
42 | }
43 | 
44 | // Accepted
45 | // 60/60 cases passed (16 ms)
46 | // Your runtime beats 66.67 % of php submissions
47 | // Your memory usage beats 18.94 % of php submissions (15.3 MB)
48 | // @lc code=end
49 | 
50 | 


--------------------------------------------------------------------------------
/每日1题202011/[1103]941.有效的山脉数组.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * @lc app=leetcode.cn id=941 lang=php
 4 |  *
 5 |  * [941] 有效的山脉数组
 6 |  * 
 7 |  * https://leetcode-cn.com/problems/valid-mountain-array/
 8 |  */
 9 | 
10 | // @lc code=start
11 | class Solution {
12 | 
13 |     /**
14 |      * @param Integer[] $A
15 |      * @return Boolean
16 |      */
17 |     function validMountainArray($A) {
18 | 
19 |         if (count($A) == 0) return false; // 空数组不符合条件
20 |         
21 |         $large = 0;
22 |         $less = 0;
23 |         $cur = $A[0];
24 | 
25 |         for ($i=1; $i < count($A); $i++) { 
26 |             if ($cur > $A[$i]) {
27 |                 if ($large == 2) return false;  // 上坡后下坡，不允许再次上坡
28 |                 if ($large == 1 && $less == 1) $large = 2;
29 |                 $large = 1;
30 |             } elseif ($cur < $A[$i]) {
31 |                 if ($large == 1) return false; // 不允许出现凹型
32 |                 $less = 1;
33 |             } else {
34 |                 return false; // 前后不可以出现相等
35 |             }
36 |             $cur = $A[$i];
37 |         }
38 |         
39 |         if ($large == 0 || $less == 0) return false; // 持续上坡、持续下坡都不符合条件
40 |         return true;
41 |     }
42 | }
43 | 
44 | // Accepted
45 | // 51/51 cases passed (76 ms)
46 | // Your runtime beats 46.67 % of php submissions
47 | // Your memory usage beats 14.29 % of php submissions (16.5 MB)
48 | // @lc code=end
49 | 
50 | 


--------------------------------------------------------------------------------