算法随笔 — 线性表基础 — 栈

迈不过友情╰ 2022-10-21 11:48 164阅读 0赞

## 栈是什么 ##

![栈][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70]  
栈是如上图所示的一种数据结构，它具有先入后出(FILO)的特性

它的结构有长度、数据类型等等

和队列相似，栈通常可以用数组来实现

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

## 栈的作用 ##

说到栈可能就可以联想到递归

这里用 leetCode20-有效的括号 这道题来抛砖引玉

![leetCode20题目][leetCode20]  
通过找规律我们可以发现

1.  在任一位置的左括号数量≥右括号数量
2.  最后位置左右括号相等

通过以上规律就可以编写相应的程序进行解题

在此基础上，我们还可以进行优化，思考一下，我们是否一定需要两个变量来分别存储左括号和右括号的数量呢？

其实，只要记录左右括号数量的差值就可以表示任一位置左右括号数量的关系了，因此我们可以定义一个变量 diff，遇到左括号时递增、遇到右括号时递减(具体程序见下文)

通过以上解决方法我们可以联想到

1.  \+1等同“进”(事情发生) -1等同“出”(事情解决)
2.  一对 () 等同一个完整的事件
3.  (()) 表示解决一个问题时，需要先解决其子问题
4.  (()()) 表示解决一个问题时，需要先按顺序解决其两个子问题(如：函数嵌套)

说到这里，我们回归主题，栈的作用是什么?

通过上面的联想可以总结成一句话：**栈可以用来解决完全包含事件的问题**

比如树的深度优先遍历，就可以将其理解成完全包含事件从而用栈去解决

![深度优先遍历][20210504140145559.png]  
再比如说 “表达式求值”

![表达式求值1][1]  
![表达式求值2][2]  
首先定义操作符的权重，乘除的权重为2，加减的权重为1

权重最低的操作符放在根节点上，然后每个操作符每在一个括号内，其权重就加100

![表达式权重][20210504141239859.png]

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

## 习题 ##

### leetCode \[面试题\]03.04 化栈为队 ###

使用两个栈实现一个队列

![化栈为队原理][20210504142043433.png]  
在构造这个队列中有三个方法比较重要

*  push() S2.push(val)
 *  update() S1为空时，S2的元素按操作顺序放到S1中
 *  pop() 先执行update()，再进行S1.pop()

![队列操作过程][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 1]

class MyQueue { 
      popStack: number[]
      pushStack: number[]
      
      constructor() { 
        this.popStack = []
        this.pushStack = []
      }
      
      push(x: number): void { 
        this.pushStack.push(x)
      }
      
      pop(): number { 
        this.update()
        return this.popStack.pop()
      }
      
      peek(): number { 
        this.update()
        return this.popStack[this.popStack.length - 1]
      }
      
      empty(): boolean { 
        return !this.popStack.length && !this.pushStack.length
      }
      
      update() { 
        if (!this.popStack.length) { 
          while (this.pushStack.length) this.popStack.push(this.pushStack.pop())
        }
      }
    }

![化栈为队结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 2]

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

### leetCode 682 棒球比赛 ###

![棒球比赛规则][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 3]  
这道题通过栈很容易实现，这里就不多做解释，直接上代码

function calPoints(ops: string[]): number { 
      const points: number[] = []
      ops.forEach(op => { 
        switch (op) { 
          case '+':
            points.push(points[points.length - 1] + points[points.length - 2])
            break
          case 'D':
            points.push(points[points.length - 1] * 2)
            break
          case 'C':
            points.pop()
            break
          default:
            points.push(Number(op))
        }
      })
      return points.reduce((pre, cur) => pre + cur, 0)
    }

![棒球比赛结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 4]

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

### leetCode 844 比较含退格的字符串 ###

![比较含退格字符串题目][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 5]  
这题只要通过栈，遇到一般字符就压栈，遇到 \# 就出栈即可

function backspaceCompare(s: string, t: string): boolean { 
      const SStack: string[] = []
      const TStack: string[] = []
      
      for (let c of s) { 
        if (c === '#') SStack.length && SStack.pop()
        else SStack.push(c)
      }
      for (let c of t) { 
        if (c === '#') TStack.length && TStack.pop()
        else TStack.push(c)
      }
      
      return SStack.join('') === TStack.join('')
    }

![比较含退格字符串结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 6]

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

### leetCode 946 验证栈序列 ###

![验证栈序列题目][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 7]  
解答这道题时，需要实现一个栈用于模拟入栈操作，然后对 poped数组 进行遍历，每次遍历的值(出栈的值)要么是当前栈顶元素，要么是未来要入栈的元素。

基于以上认识，我们可以定义 **i**指针 指向 poped，**j**指针 指向 pushed。

当 j 在 pushed 范围且栈空或当前栈顶元素不等于弹出元素时，入栈

如果pushed中的元素全部都压入到模拟栈中而且当前栈顶元素不等于出栈元素时，说明条件不成立

function validateStackSequences(pushed: number[], popped: number[]): boolean { 
      if (pushed.length !== popped.length) return false
      
      const stack = []
      for (let item of popped) { 
        if (stack.length && stack[stack.length - 1] === item) { 
          stack.pop()
          continue
        }
        
        while (stack[stack.length - 1] !== item) { 
          if (!pushed.length) return false
          stack.push(pushed.shift())
        }
        stack.pop()
      }
      return !stack.length
    }

![验证栈序列结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 8]

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

### leetCode 20 有效的括号 ###

![有效的括号][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 9]  
实现一个栈，遇到左括号时直接入栈，遇到右括号时与当前栈顶元素比，如果是同类型左括号则出栈，否则返回 false

遍历结束之后如果栈空说明括号完全配对

function isValid(s: string): boolean { 
      const bracketStack: string[] = []
      const bracketMap = { 
        ')': '(',
        '}': '{',
        ']': '['
      }
      
      for (let c of s) { 
        //* 左括号
        if (Object.values(bracketMap).indexOf(c) !== -1) { 
          bracketStack.push(c)
          continue
        }
        //* 右括号
        if (bracketStack[bracketStack.length - 1] === bracketMap[c]) { 
          bracketStack.pop()
        } else { 
          return false
        }
      }
      
      return !bracketStack.length
    }

![有效的括号结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 10]

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

### leetCode 1021 删除最外层的括号 ###

![删除最外层括号题目][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 11]  
![删除最外层括号原理][20210504145800885.png]  
定义一个初始值为0的变量 diff 用来记录左括号数量与右括号数量的差

遇到左括号时自增，同时如果自增前值大于0则需要该左括号；

遇到右括号时自减，同时如果自减前值大于1则需要该右括号;

function removeOuterParentheses(S: string): string { 
      let diff = 0, res = ''
      for (let c of S) { 
        if (c === '(' && diff++ > 0) res += c
        else if (c === ')' && diff-- > 1) res += c
      }
      return res
    }

![删除最外层括号][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 12]

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

### leetCode 1249 移除无效的括号 ###

![移除无效的括号题目][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 13]  
一个通用方法是：

1.  正向扫描去除多余的右括号
2.  逆向扫描去除多余的左括号

去除括号的方法可以参照上文。

还有另外一种方法是通过栈实现，首先定义一个栈用来存左括号的下标，再定义一个栈用来存右括号的下标

遇到左括号时直接入栈，遇到右括号时，如果左栈没值，则入栈，如果左栈有值，则左栈出栈

经过以上操作之后，左右栈中存的是多余左括号和右括号的下标，根据这些下标进行数组操作即可得到最终答案

function minRemoveToMakeValid(s: string): string { 
      const leftStack: number[] = [], rightStack: number[] = [], cloneArr = s.split('')
      for (let i = 0; i < s.length; i++) { 
        if (s[i] === '(') leftStack.push(i)
        else if (s[i] === ')') leftStack.length ? leftStack.pop() : rightStack.push(i)
      }
      const bracketsToBeRemoved = [...leftStack, ...rightStack]
      bracketsToBeRemoved.forEach(i => cloneArr.splice(i, 1, ''))
      return cloneArr.join('')
    }

![移除无效括号结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 14]

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

### leetCode 145 二叉树的后序遍历 ###

![二叉树后续遍历题目][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 15]  
这道题有两种解法，首先讲一下递归

在递归这个方法中，首先创建一个新数组，然后就可以返回后序遍历函数的执行结果了

return postorderTraversalNode(root, arr)

在这个函数中，先判断传入节点是否存在，然后递归调用该节点的左子节点和右子节点，最后输出当前节点

function postorderTraversal(root: TreeNode | null): number[] { 
      if (!root) return []
      let node
      const res = [], stack = [root]
      while (stack.length) { 
        node = stack.pop()
        res.unshift(node.val)
        if (node.left) stack.push(node.left)
        if (node.right) stack.push(node.right)
      }
      return res
    }

![二叉树后序遍历结果1][1 1]  
如果是用栈的方式实现，我们需要定义两个栈，一个栈用来存储当前节点，另一个栈用来存储对应节点的行为代码

*  0: 压入对应节点的左节点
 *  1: 压入对应节点的右节点
 *  2: 输出对应节点

首先初始化一个存储答案的数组，然后初始化两个栈，如下图所示  
![通过栈实现二叉树的后续遍历][20210504154553891.png]  
当 S1 栈中有元素时执行如下操作

1.  S2.pop()
2.  根据上一步结果分别作以下操作  
    \* 0: S2.push(1) => 存在左子节点 => S1.push(左子); S2.push(0)  
    \* 1: S2.push(2) => 存在右子节点 => S1.push(右子); S2.push(0)  
    \* 2: ans.push(当前节点.val) => S1.pop()

function postorderTraversal(root: TreeNode | null): number[] { 
      if (!root) return []
      const ans: number[] = []
      //* 1:压入栈顶节点的左子节点 2:压入栈顶节点的右子节点 0:输出对应节点的值
      const nodeStack: TreeNode[] = [root], actionStack: Array<0 | 1 | 2> = [0]
      let action = 0, node = root
      while (nodeStack.length) { 
        action = actionStack.pop()
        node = nodeStack[nodeStack.length - 1]
        switch (action) { 
          case 0:
            actionStack.push(1)
            if (node.left) { 
              nodeStack.push(node.left)
              actionStack.push(0)
            }
            break
          case 1:
            actionStack.push(2)
            if (node.right) { 
              nodeStack.push(node.right)
              actionStack.push(0)
            }
            break
          case 2:
            ans.push(nodeStack.pop().val)
        }
      }
      return ans
    }

![二叉树后序遍历结果2][2 1]

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

### leetCode 331 验证二叉树的前序序列化 ###

![验证二叉树的前序序列化题目][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 16]  
这道题有两种解法，一种是通过消字符，另一种是通过记录节点数量

先说第一种方式，其原理如下  
![验证二叉树前序序列化原理1][1 2]

function isValidSerialization(preorder: string): boolean { 
      let preorderClone = preorder.split(',')
      let flag = false
      while (preorderClone.length > 1) { 
        flag = false
        for (let i = preorderClone.length - 1; i >= 0; i--) { 
          if (preorderClone[i] !== '#' && preorderClone[i + 1] === '#' && preorderClone[i + 2] === '#') { 
            preorderClone.splice(i, 3, '#')
            flag = true
          }
        }
        if (!flag) break
      }
      return preorderClone.length === 1 && preorderClone[0] === '#'
    }

![验证二叉树前序序列化结果1][1 3]  
另一种方法是记录节点数量，首先初始化栈  
![验证二叉树前序序列化解题2][2 2]  
遍历给定字符串

遇 “\#” 栈顶元素自减，如果栈顶是0则出栈;  
遇到其他字符，栈顶元素自减，如果栈顶是0则出栈，然后将2压栈

最后如果序列正确，栈空

function isValidSerialization(preorder: string): boolean { 
      const preorderClone = preorder.split(',')
      const stack = [1]
      for (let c of preorderClone) { 
        if (!stack.length) return false
        if (c === '#') { 
          stack[stack.length - 1]--
          if (!stack[stack.length - 1]) stack.pop()
        } else { 
          stack[stack.length - 1]--
          if (!stack[stack.length - 1]) stack.pop()
          stack.push(2)
        }
      }
      return !stack.length
    }

![验证二叉树前序序列化结果2][2 3]

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

### leetCode 227 基本计算器II ###

![基本计算器题目][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 17]  
首先初始化一个栈，然后遍历字符串

对于数字和操作符分别对应不同的操作，数字要注意非个位数

最后栈中所有数字的和就是结果

function calculate(s: string): number { 
      const clone = s.split(' ').join('').split('')
      const numStack: number[] = []
      let num = 0, op = '+'
      clone.forEach((c, i) => { 
        if (!isNaN(Number(c))) { 
          // 数字
          num = num * 10 + Number(c)
          if (i !== clone.length - 1) return
        }
        if (isNaN(Number(c)) || i === clone.length - 1) { 
          // 操作符
          switch (op) { 
            case '+':
              numStack.push(num)
              break
            case '-':
              numStack.push(-num)
              break
            case '*':
              numStack.push(numStack.pop() * num)
              break
            case '/':
              numStack.push(numStack.pop() / num | 0)
          }
          op = c
          num = 0
        }
      })
      
      return numStack.reduce((pre, cur) => pre + cur, 0)
    }

![基本计算器结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 18]

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

### leetCode 636 函数的独占时间 ###

![函数独占时间题目][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 19]  
初始化长度为n的数组和执行指针go，遍历logs

在函数next 中做如下操作

1.  创建duration变量记录子任务时间
2.  记录当前任务的开始
3.  往后遍历直到碰到end，遍历时递归调用 next() (子任务)
4.  记录当前任务结束位置
5.  记录当前任务独占时间 (end - start + 1 - duration)
6.  返回当前任务总时间 (end - start + 1)

function exclusiveTime(n: number, logs: string[]): number[] { 
      const ans = (new Array(n) as any).fill(0)
      let go = 0
      
      const next = () => { 
        let duration = 0
        const start = logs[go].split(':')
        // 找到当前任务的结束位置，如果下一位置是start，说明是子任务
        while (++go < logs.length - 1 && logs[go].indexOf('e') === -1) { 
          duration = duration + next()
        }
        const end = logs[go].split(':')
        const res = Number(end[2]) - Number(start[2]) + 1 - duration
        ans[Number(start[0])] += res
        return res + duration
      }
      
      while (go < logs.length - 1) { 
        next()
        go++
      }
      
      return ans
    }

![函数的独占时间结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 20]

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

### leetCode 1124 表现良好的最长时间段 ###

![表现良好的最长时间段题目][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 21]  
要解答这道题，需要更加深刻地理解栈，首先我们把符合条件的变为1，不符合条件的变为-1，然后引入“前缀和数组”这个概念

前缀和数组的意思就是，当前数组的值是原数组中对应值从头开始的累加和

如题目中的 \[9,9,6,0,6,6,9\] 首先变成 \[1,1,-1,-1,-1,-1,1\]，接着转为前缀和数组就是 \[0,1,2,1,0,-1,-2,1\]

在前缀和数组中，为了方便计算，我们人为在数组开头添加0，这时原数组的下标在前缀和中就是从1开始了

在前缀和数组中，如果要求 i ~ j 的和，通过观察可以得到  s = p r e S u m \[ j \] − p r e S u m \[ i − 1 \] s=preSum\[j\]-preSum\[i-1\] s=preSum\[j\]−preSum\[i−1\]

回归到题目中，当  p r e S u m \[ j \] − p r e S u m \[ i − 1 \] > 0 preSum\[j\]-preSum\[i-1\]>0 preSum\[j\]−preSum\[i−1\]>0，则说明“表现良好”的天数 大于 “摸鱼”的天数，由此可得，“表现良好”的时间段  t = j − ( i − 1 ) = j − i + 1 t=j-(i-1)=j-i+1 t=j−(i−1)=j−i\+1  
由此可得，j 越大，i 越小，t 就越大

为了使 j 更大，我们使用倒序遍历；为了使 i 更小，我们只有在前缀和比当前最小值更小时，才压入下标栈中

有了以上概念，接下来就可以开始写程序了

首先初始化一个栈用来存前缀和数组的下标  
![前缀和下标栈][20210504162606687.png]  
遍历前缀和数组，只有当当前前缀和小于下表站顶部数字对应的前缀和时，才压入当前下标

如果是题目的示例，遍历完前缀和数组的栈应该如下图所示  
![前缀和下标栈结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 22]  
初始化变量max为0，倒序遍历前缀和数组，终止条件为 遍历下标 ≤ max

for (let i = preSum.length - 1; i > max; i--) {  xxx }

当出现“表现良好的时间段”时 (当前前缀和与栈顶数字对应的前缀和之差大于0)，比较当前max和下标与栈顶元素之差并更新最大值

max = Math.max(max, i - stack.pop())

注意，上述操作之所以出栈是因为i是递减的，之后没有比这更大的差了

function longestWPI(hours: number[]): number { 
      let max = 0
      const preSum = [0], indexStack = [0]
      // 前缀数组准备
      hours.forEach((h, i) => h > 8 ? preSum.push(preSum[i] + 1) : preSum.push(preSum[i] - 1))
      // 找到小的前缀和
      preSum.forEach((s, i) => (s < preSum[indexStack[indexStack.length - 1]]) && indexStack.push(i))
      // 倒叙遍历前缀和数组
      for (let i = preSum.length - 1; i > max; i--) { 
        while (indexStack.length && preSum[i] - preSum[indexStack[indexStack.length - 1]] > 0) { 
          max = Math.max(max, i - indexStack.pop())
        }
      }
      return max
    }

![表现良好的最长时间段结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 23]

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

## 结语 ##

有任何问题欢迎评论区或私信讨论~

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70]: /images/20221021/2f989fe1c1cf4906975102b2ab5f419b.png
[leetCode20]: /images/20221021/b8c051e6b512481ca8a210da56a485d1.png
[20210504140145559.png]: /images/20221021/4159c41bc1bb4e29b583b91f6de6b886.png
[1]: /images/20221021/e970073f60274cac9be932d4c39280d5.png
[2]: /images/20221021/33e9eadc85ad418b844013298f5f6abe.png
[20210504141239859.png]: /images/20221021/614a16a00ed544dca3060934bd68e969.png
[20210504142043433.png]: /images/20221021/5c2eb7617a8b48c3aed8bb3086531c58.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 1]: /images/20221021/76c13ba12db4403aae051799aea7d17a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 2]: /images/20221021/c2a7add85bfc401c9a2bce82fcd54f85.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 3]: /images/20221021/f81e101861e94bec9d2b9cc48906826e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 4]: /images/20221021/097499c4baae4c06a4f5cf25ffc96c03.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 5]: /images/20221021/92f1e6ddf1f443c2ba280cec0773caef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 6]: /images/20221021/c541afff87734375baa72d8fc992f84d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 7]: /images/20221021/bf03c53f69a248e88c66fc61b12e4b0f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 8]: /images/20221021/5fa60e67b4994a8dadc3f5565fc7c2a2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 9]: /images/20221021/a22c3dd024304d01905ac366d06f43bd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 10]: /images/20221021/1aa882aa7e284772b3acbfcf2239d025.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 11]: /images/20221021/e3ff79a374d3497b8e2d35c29ce969cc.png
[20210504145800885.png]: /images/20221021/5ad5aa7425fc47f08c549655b751380c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 12]: /images/20221021/f0a99d82769041bf95ffb86c9c2c1aa7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 13]: /images/20221021/e8763491569f43d582c560617dba9fde.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 14]: /images/20221021/a3ed6f6689d1449b85938a2974d19b67.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 15]: /images/20221021/c83543993c224a4999ad9875dd2a610d.png
[1 1]: /images/20221021/a8f6bb2334c84b089683a36d70e589f5.png
[20210504154553891.png]: /images/20221021/59c6c4c7a53b4ee5bf329953c4c51e83.png
[2 1]: /images/20221021/d67990b053954cc9bc7cd692c727ec7c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 16]: /images/20221021/d661a69ac4094b56a4549cf5335dc663.png
[1 2]: /images/20221021/539bf22e76c04e0c8ab3e4cb00ffcd60.png
[1 3]: /images/20221021/2a34cb7a9b4e456b82c01b43c50e5069.png
[2 2]: /images/20221021/fc0953b9021b4b3788e24ce912f0bc53.png
[2 3]: /images/20221021/ce38a5d0da0b452085adb2eab16c2c57.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 17]: /images/20221021/2166efdd6ab746a8b9677fa4744c0883.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 18]: /images/20221021/7b1ef51c5f824658819472e2aa145daa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 19]: /images/20221021/b10de01a5a5d470bade5db2f2feac53b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 20]: /images/20221021/fc22a48e28fe46d0b1a9cd4929591d99.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 21]: /images/20221021/b05fc48a913545efad82269fcc635f4e.png
[20210504162606687.png]: /images/20221021/dada4af71b974771b3449c40a25e4bd0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 22]: /images/20221021/cf20ff7918e24e25b869a5383dee6020.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RNX0dvZHNwZWVk_size_16_color_FFFFFF_t_70 23]: /images/20221021/add9d1d9e9c7400a973354b547d692ac.png