基于Linux的C++ Part 4: 算法

短命女 2022-10-14 10:53 130阅读 0赞

### Part 4: 算法 ###

*  4.1 算法概念与特征
 *   *  算法基本概念
     *  算法特征
     *  算法示例
 *  4.2 算法描述
 *   *  伪代码
     *  流程图（程序框图）
 *  4.3 算法设计与实现
 *   *  算法设计与实现步骤
     *  典型示例1 ：素性判定问题
     *  算法选择
     *  典型示例2 ：最大公约数问题
 *  4.4 递归算法
 *   *  递归问题
     *  递归的工作步骤
     *  阶乘函数示例
     *  斐波那契数列函数示例
     *  循环与递归的比较
     *  递归函数调用的栈框架
     *  汉诺塔问题
     *  递归信任
 *  4.5 容错与算法复杂度
 *   *  容 错
     *  算法复杂度
 *  4.6 编程实战

# 4.1 算法概念与特征 #

## 算法基本概念 ##

*  算法定义：解决问题的方法与步骤
 *  设计算法的目的：给出解决问题的逻辑描述，根据算法描述进行实际编程

## 算法特征 ##

*  有穷性：算法在每种情况下都可以在有限步后终止
 *  确定性：算法步骤的顺序和内容没有二义性
 *  输入：算法有零个或多个输入
 *  输出：算法至少具有一个输出
 *  有效性：所有操作具有明确含义，并能在有限时间内完成  
    正确性不是算法的特征，算法的正确性需要数学证明

## 算法示例 ##

*  示例一：3\*3 幻方  
    ![在这里插入图片描述][20210521123840249.png]  
    步骤1：把 1 写在第一行中间一格  
    步骤2：在该格右上方的那一格中写入下一自然数  
    在此过程中，若该数已超出 3 × 3 幻方范围，则将该数书写在其所在的那一排或列的另一端格子中，即相当于认为幻方外围仍然包含了同样的幻方，而该数就写在外围幻方的同样位置  
    每写完三个数，将第四个数写在第三个数下面格子中  
    步骤3：重复步骤2，直到所有格子均填满
 *  查英文单词  
    步骤1：翻开词典任意一页  
    步骤2：若所要的词汇按字母排列顺序在本页第一个单词之前，则往前翻开任意一页，重复步骤2；若所查词汇在本页最后一个单词之后，则往后翻开任意一页，重复步骤2  
    步骤3：若上述两条件均不满足，则该单词要么在本页上，要么词典中不存在  
    依次比较本页单词，或者查出该单词，或者得到该单词查不到的结论

# 4.2 算法描述 #

## 伪代码 ##

*  混合自然语言与计算机语言、数学语言的算法描述方法
 *  优点：方便，容易表达设计者思想，能够清楚描述算法流程，便于修改
 *  缺点：不美观，复杂算法不容易理解
 *  示例1：顺序结构  
    执行某任务  
    执行下一任务
 *  示例2：分支结构

if( 条件表达式 )
     	处理条件为真的情况
     else 
     	处理条件为假的情况

switch( 条件变量 ){ 
    case 常量表达式 1: 处理分支 1
    case 常量表达式 2: 处理分支 2
    ……
    default: 处理默认分支
    }

*  示例3：循环结构

for( 初始化表达式; 条件表达式; 步进表达式 ) || while( 条件表达式 )
    { 
    循环体内部代码逻辑描述
    }

## 流程图（程序框图） ##

*  使用图形表示算法执行逻辑
 *  优点：美观，算法表达清晰
 *  缺点：绘制复杂，不易修改，占用过多篇幅
 *  常用流程图的框图与符号  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70]
 *  示例1：幻方流程图  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70 1]
 *  示例二： 查英文单词  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70 2]

# 4.3 算法设计与实现 #

## 算法设计与实现步骤 ##

*  构造算法解决问题
 *  按照自顶向下、逐步求精的方式进行
 *  使用程序设计语言编程实现

## 典型示例1 ：素性判定问题 ##

判断给定的某个自然数 n（大于 2）是否为素数  
算法逻辑：

*  输入：大于 2 的正整数 n
 *  输出：该数是否为素数，若为素数返回 true，否则返回 false
 *  步骤 1：设除数 i 为 2
 *  步骤 2：判断除数 i 是否已为 n，若为真返回 true，否则继续
 *  步骤 3：判断 n % i 是否为 0，若为 0 返回 false，否则继续
 *  步骤 4：将除数 i 递增，重复步骤 2

素数判定函数方法一,循环次数多，效率非常低
    bool IsPrime( unsigned int n )
    { 
    unsigned int i = 2;
    while( i < n )
    { 
    if( n % i == 0 )
    return false;
    i++;
    }
    return true;
    }

素数判定函数方法二：程序快于方法一，循环的遍历的次数由n降至sqrt(n)
    bool IsPrime( unsigned int n )
    { 
    unsigned int i = 2;
    while( i <= (unsigned int)sqrt(n) )//若一个自然数n为和数，则一定存在在2~n之间的两个数p和q（p<=q），且p << sqrt(n)
    { 
    if( n % i == 0 )//如果i能被n整除，则直接返回结果，n不是素数
    return false;
    i++;
    }
    return true;
    }

素数判定函数方法三：更快，结合了方法一和方法二
    bool IsPrime( unsigned int n )
    { 
    unsigned int i = 3;//从3开始循环
    if( n % 2 == 0 ) //如果这个数是偶数，则一定不是素数，直接返回结果
    return false;
    while( i <= (unsigned int)sqrt(n) )
    { 
    if( n % i == 0 )
    return false;
    i += 2;//每次递增2，因为进入while循环之前已经判断奇偶性
    }
    return true;
    }

素数判定函数方法四，更精确
    bool IsPrime( unsigned int n )
    { 
    unsigned int i = 3;
    if( n % 2 == 0 )
    return false;
    while( i <= (unsigned int)sqrt(n) + 1 )//sqrt(n)保存的是浮点型，会有微小误差，会漏掉一些平方数
    { 
    if( n % i == 0 )
    return false;
    i += 2;
    }
    return true;
    }

素数判定函数方法五，更精确 更快
    bool IsPrime( unsigned int n )
    { 
    unsigned int i = 3, t = (unsigned int)sqrt(n) + 1;//只计算一次sqrt(n)，程序就会变快，因为这里n不变。
    if( n % 2 == 0 )
    return false;
    while( i <= t )
    { 
    if( n % i == 0 )
    return false;
    i += 2;
    }
    return true;
    }

## 算法选择 ##

*  算法选择的权衡指标  
    正确性：算法是否完全正确？  
    效率：在某些场合，对程序效率的追求具有重要意义  
    可理解性：算法是否容易理解，也是必须要考虑的
 *  算法评估：  
    衡量算法的好坏，主要是**效率**

## 典型示例2 ：最大公约数问题 ##

求两个正整数 x 与 y 的最大公约数  
函数原型设计

unsigned int gcd( unsigned int x, unsigned int y );

最大公约数函数：穷举法 效率低
    unsigned int gcd( unsigned int x, unsigned int y )
    { 
    unsigned int t;
    t = x < y ? x : y;
    while( x % t != 0 || y % t != 0 )
    t--;
    return t;
    }

最大公约数函数：欧氏算法*/
    输入：正整数 x、y
    输出：最大公约数
    步骤 1：x 整除以 y，记余数为 r
    步骤 2：若 r 为 0，则最大公约数即为 y，算法结束
    步骤 3：否则将 y 作为新 x，将 r 作为新 y，重复上述步骤
    unsigned int gcd( unsigned int x, unsigned int y )
    { 
    unsigned int r;
    while( true )
    { 
    r = x % y;
    if( r == 0 )
    return y;
    x = y;
    y = r;
    }
    }

# 4.4 递归算法 #

## 递归问题 ##

递归问题的引入

*  递推公式：数学上非常常见  
    例一：阶乘函数：1! = 1，n! = n × (n-1)!  
    例二：斐波那契数列函数：f(1) = f(2) = 1，f(n) = f(n-1) + f(n-2)
 *  递推函数一定是分段函数，具有初始表达式
 *  递推函数的计算逻辑：逐步简化问题规模

## 递归的工作步骤 ##

*  递推过程：逐步分解问题，使其更简单
 *  回归过程：根据简单情形组装最后的答案

## 阶乘函数示例 ##

使用循环实现
    unsigned int GetFactorial( unsigned int n )
    { 
    unsigned int result = 1, i = 0;
    while( ++i <= n )
    result *= i;
    return result;
    }

使用递归实现
    unsigned int GetFactorial( unsigned int n )
    { 
    unsigned int result;
    if( n == 1 ) result = 1;
    else result = n * GetFactorial( n - 1 );
    return result;
    }

## 斐波那契数列函数示例 ##

使用循环实现
    unsigned int GetFibonacci( unsigned int n )
    { 
    unsigned int i, f1, f2, f3;
    if( n == 2 || n == 1 ) return 1;
    f2 = 1; f1 = 1;
    for( i = 3; i <= n; i++ ){ 
    f3 = f1 + f2; f1 = f2; f2 = f3;
    }
    return f3;
    }

使用递归实现
    unsigned int GetFibonacci( unsigned int n )
    { 
    if( n == 2 || n == 1 ) return 1;
    else return GetFibonacci( n - 1 ) + GetFibonacci( n - 2 );
    }

## 循环与递归的比较 ##

*  循环使用显式的循环结构重复执行代码段，递归使用重复的**函数调用**执行代码段
 *  循环在满足其*终止条件时终止执行*，而递归则在问题*简化到最简单情形时终止执行*
 *  循环的重复是在当前迭代执行结束时进行，递归的重复则是在遇到对同名函数的调用时进行
 *  循环和递归都可能隐藏程序错误，循环的条件测试可能永远为真，递归可能永远退化不到最简单情形
 *  理论上，任何递归程序都可以使用循环迭代的方法解决  
    递归函数的码更短小精悍  
    一旦掌握递归的思考方法，递归程序更易理解

## 递归函数调用的栈框架 ##

#include <iostream>
    using namespace std;
    void PrintWelcomeInfo();
    unsigned int GetInteger();
    unsigned int GetFactorial( unsigned int n );
    int main()
    { 
    unsigned int n, result;
    PrintWelcomeInfo();
    n = GetInteger();
    result = GetFactorial( n );
    cout << n << "! = " << result << ".\n";
    return 0;
    }
    void PrintWelcomeInfo()
    { 
    cout << "The program gets a number and computes the factorial.\n";
    }
    unsigned int GetInteger()
    { 
    unsigned int t;
    cout << "Input a non-negative number: ";
    cin >> t;
    return t;
    }
    unsigned int GetFactorial( unsigned int n )
    { 
    unsigned int result;
    if( n == 0 )
    result = 1;
    else
    result = n * GetFactorial( n - 1 );
    return result;
    }

*  函数调用栈框架说明  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70 3]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70 5]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70 6]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70 7]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70 8]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70 9]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70 10]

## 汉诺塔问题 ##

假设有三个分别命名为 X、Y 和 Z 的塔座，在塔座 X 上插有 n 个直径大小不同、从小到大分别编号为 1, 2, …, n 的圆盘，如图所示：  
![在这里插入图片描述][2021052117494981.png]  
要求将塔座X上的 n 个圆盘移动到塔座 Z 上并按相同顺序叠放，圆盘移动时必须遵循下述规则：

*  每次只能移动一个圆盘；
 *  圆盘可以插在X、Y与Z中的任意塔座上；
 *  任何时刻都不能将较大的圆盘压在较小的圆盘上。

如何实现移动圆盘的操作呢？  
**问题分析**  
待解决的问题

*  Q1：是否存在某种简单情形，问题很容易解决
 *  Q2：是否可将原始问题分解成性质相同但规模较小的子问题，且新问题的解  
    答对原始问题有关键意义

**解决思维**

*  A1：只有一个圆盘时是最简单情形
 *  A2：对于 n > 1，考虑 n – 1 个圆盘，如果能将 n - 1 个圆盘移动到某个塔  
    座上，则可以移动第 n 个圆盘  
    策略：首先将 n – 1 个圆盘移动到塔座 Y 上，然后将第 n 个圆盘移动到 Z 上，  
    最后再将 n - 1 个圆盘从 Y 上移动到 Z 上

**伪代码**

void MoveHanoi( unsigned int n, HANOI from, HANOI tmp, HANOI to )
    { 
    if( n == 1 )
    将一个圆盘从 from 移动到 to
    else
    { 
    将 n – 1 个圆盘从 X 以 Z 为中转移动到 Y
    将圆盘 n 从 X 移动到 Z
    将 n - 1个圆盘从 Y 以 X 为中转移动到 Z
    }
    }

**程序代码**

#include <iostream>
    using namespace std;
    void Welcome();
    int GetPlate();
    void MoveHanoi(int n,char from,char tmp,char to);
    void MovePlate(int n, char from, char to);
    int main() { 
    	int plates;
    	int sum=0;
    	Welcome();
    	plates = GetPlate();
    	cout << "Move process: \n";
    	MoveHanoi(plates, 'X', 'Y', 'Z');
    	cout << "Finish!\n";
    	return 0;
    }
    
    void Welcome() { 
    	cout << "This is a Tower of Hanoi problem!" << endl;
    }
    
    int GetPlate() { 
    	int n;
    	cout << "Please input the counts of the plates: " << endl;
    	cin >> n;
    	cout << "You want to move " << n << " plates.\n";
    	return n;
    }
    
    void MovePlate(int n, char from, char to) { 
    	cout << "No" << n << ": " << from << " - " << to << endl;
    }
    
    void MoveHanoi(int n, char from, char tmp, char to){ 
    	if (n == 1) { 
    		MovePlate(1, from, to);
    	}
    	else { 
    		MoveHanoi(n - 1, from, to, tmp);
    		MovePlate(n, from, to);
    		MoveHanoi(n - 1, tmp, from, to);
    	}
    }

运行结果：
    This is a Tower of Hanoi problem!
    Please input the counts of the plates:
    4
    You want to move 4 plates.
    Move process:
    No1: X  -  Y
    No2: X  -  Z
    No1: Y  -  Z
    No3: X  -  Y
    No1: Z  -  X
    No2: Z  -  Y
    No1: X  -  Y
    No4: X  -  Z
    No1: Y  -  Z
    No2: Y  -  X
    No1: Z  -  X
    No3: Y  -  Z
    No1: X  -  Y
    No2: X  -  Z
    No1: Y  -  Z
    Finish!

## 递归信任 ##

*  递归实现是否检查了最简单情形  
    在尝试将问题分解成子问题前，首先应检查问题是否已足够简单  
    在大多数情况下，递归函数以 if 开头  
    如果程序不是这样，仔细检查源程序
 *  大量递归错误是由没有正确解决最简单情形导致的  
    最简单情形不能调用递归
 *  递归分解是否使问题更简单  
    只有分解出的子问题更简单，递归才能正确工作，否则将形成无限递  
    归，算法无法终止
 *  问题简化过程是否能够确实回归最简单情形，还是遗漏了某些情况  
    如汉诺塔问题需要调用两次递归过程，程序中如果遗漏了任意一个都  
    会导致错误
 *  子问题是否与原始问题完全一致  
    如果递归过程改变了问题实质，则整个过程肯定会得到错误结果
 *  使用递归信任时，子问题的解是否正确组装为原始问题的解  
    将子问题的解正确组装以形成原始问题的解也是必不可少的步骤

# 4.5 容错与算法复杂度 #

## 容 错 ##

*  容错的定义：允许错误的发生
 *  错误的处理  
    很少见的特殊情况或普通错误：忽略该错误不对程序运行结果产生影响  
    用户输入错误：通知用户错误性质，提醒用户更正输入  
    致命错误：通知用户错误的性质，停止执行
 *  典型容错手段  
    数据有效性检查  
    程序流程的提前终止
 *  **数据有效性检查**

void GetUserInput()
    { 
    获取用户输入数据
    while( 用户输入数据无效 )
    { 
    通知用户输入数据有误，提醒用户重新输入数据
    重新获取用户输入数据
    }
    }
    void Input()
    { 
    GetInputData();
    while( !IsValid() )
    { 
    OutputErrorInfo();
    GetinputData();
    }
    }

*  **程序流程的提前终止**

const int failed_in_testing_primality = 1;
    bool IsPrime( unsigned int n )
    { 
    unsigned int i = 3, t = (unsigned int)sqrt(n) + 1;
    if( n <= 1 )
    { 
    cout << "IsPrime: Failed in testing the primality of " << n << endl;
    exit( failed_in_testing_primality )//在"stdlib.h"定义的
    }
    if( n == 2 )
    return true;
    if( n % 2 == 0 )
    return false;
    while( i <= t )
    { 
    if( n % i == 0 )
    return false;
    i += 2;
    }
    return true;
    }

## 算法复杂度 ##

*  引入算法复杂度的目的  
    度量算法的效率与性能
 *  大 O 表达式  
    算法效率与性能的近似表示（定性描述）  
    算法执行时间与问题规模的关系
 *  表示原则  
    忽略所有对变化趋势影响较小的项，例如多项式忽略高阶项之外的所有项  
    忽略所有与问题规模无关的常数，例如多项式的系数
 *  标准算法复杂度类型  
    *O(1)*：常数级，表示算法执行时间与问题规模无关  
    *O(log(n))*：对数级，表示算法执行时间与问题规模的对数成正比  
    *O(sqrt(n))*：平方根级，表示算法执行时间与问题规模的平方根成正比  
    *O(n)*：线性级，表示算法执行时间与问题规模成正比  
    *O(n*log(n))*：nlog(n)* 级，表示算法执行时间与问题规模的 n\*log(n) 成正比  
    *O(n2)*：平方级，表示算法执行时间与问题规模的平方成正比  
    ……
 *  算法复杂度估计  
    以嵌套的循环次数估计：

for( i = 0; i < n; i++ )
    	cout << "No. " << I << ": Hello, World!\n";					//O(n)

for( i = 0; i < n; i++ )
    	for( j = 0; j < n; j++ )
    		cout << "Hello, World!\n";								//O(n2)

for( i = 0; i < n; i++ )
    	for( j = i; j < n; j++ )
    		cout << "Hello, World!\n";								//O(n2)

# 4.6 编程实战 #

*  设计算法，将某个大于1的自然数n分解为其素因子的乘积，如6=2*3，7=7，8=2*2\*2。

#include <iostream>
    #include "stdlib.h"
    using namespace std;
    const int failed_in_input=1;
    void Welcome();
    int GetInteger();
    void Decompose(int n);
    int main(){ 
        int n;
        n=GetInteger();
        Decompose(n);
        cout << "Finish!\n";
        return 0;
    }
    
    void Welcome(){ 
        cout << "This is a program to decompose a natural number!\n";
    }
    
    int GetInteger(){ 
        int n;
        cout <<"Please enter a number !\n";
        cin >> n; 
        if (n<=1){ 
            cout << "Failed in decomposing because of your invalid input!!\n";
            exit(failed_in_input);
        }
        return n;
    }
    
    void Decompose(int n){ 
        int i=2;							/循环标志
        cout << n << "= ";
        if(n==2){ 
            cout << 1 << " * " << 2 << endl;
        }
        else{ 
            for(i=2;i<=n;i++){ 				//从最小的质数 2 开始执行循环
            	while (n!=i)				//停止条件
            	{ 
                	if (n%i==0){ 			//判断当前i是否能整除n,若能 求商 ，继续
                    	cout << i << "*" ;
                    	n = (n/i);			//把商赋值给n，继续,直到n<i，跳出
                	}
                	else{ 
                    	break;				//判断当前i是否能整除n,若不能，则i+1
                	}
            	}  
        	} 
        	cout << n << endl;
        }
        
    }

运行结果：
    Please enter a number !
    1
    Failed in decomposing because of your invalid input!!
    
    Please enter a number !
    2
    2= 1 * 2
    Finish!
    
    Please enter a number !
    8
    8= 2*2*2
    
    Please enter a number !
    11
    11= 11
    Finish!

*  设计算法，分别使用循环和递归两种策略求二项式系数C(n,k)。其中，n为自然数，k为不大于n的非负整数。

[20210521123840249.png]: /images/20221014/f6104d69020847a4845cd0ef7d5189b2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70]: /images/20221014/e43130c0bdb14c4c9809edca83e9ddbb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70 1]: /images/20221014/93dfb1b8adb647e09fee270f1b407bc8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70 2]: /images/20221014/c18453720ba4471b84ead6751291840b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70 3]: /images/20221014/47519948cb02449ba5e07f7665bf1409.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70 4]: /images/20221014/4ac13aae6af64360848db3757587eb8f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70 5]: /images/20221014/b8a86e60a62d45b3a724738f3d400636.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70 6]: /images/20221014/902cce7b66694b32b9e258327b77e870.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70 7]: /images/20221014/8f15b353a59448d793eeb13cb5791684.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70 8]: /images/20221014/0a66d74bf7d346d4a3f9a32b5e18ee21.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70 9]: /images/20221014/b0842e5a460c460f86b82322c2ab48e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70 10]: /images/20221014/757d71d30cda4253a233589f2869965e.png
[2021052117494981.png]: /images/20221014/507be35a3a0949fe963326d74662a150.png