2016年第七届蓝桥杯省赛

雨点打透心脏的1/2处 2022-11-06 14:54 268阅读 0赞

# 2016年第七届蓝桥杯省赛 #

\[第一题：煤球数目\]  
\[第二题：生日蜡烛\]  
\[第三题：凑算式\]  
\[第四题：快速排序\]  
\[第五题：抽签\]  
\[第六题：方格填数\]  
\[第七题：剪邮票\]  
\[第八题：四平方和\]  
\[第九题：交换瓶子\]  
\[第十题：最大比例\]

## 01煤球数目 ##

有一堆煤球，堆成三角棱锥形。具体：  
第一层放1个，  
第二层3个（排列成三角形），  
第三层6个（排列成三角形），  
第四层10个（排列成三角形），  
….  
如果一共有100层，共有多少个煤球？

请填表示煤球总数目的数字。  
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

解题思路：  
每层的个数是上层的个数加上层数，就是An = An-1 + n,题目是求的前100层一共多少煤球。所以是Sn代码双重for循环就出来了。

答案是：171700

————————————————

#include <iostream>
    #include <bits/stdc++.h>
    using namespace std;
    int main(int argc, char *argv[]) { 
        int level=0,index=1;
        int sum=0;
        for(int level=1;level<=100;level++)
        { 
            sum+=index;
            index+=level+1;     
        }
        cout<<sum<<endl;
        return 0;
    }

## 02 生日蜡烛 ##

某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。

现在算起来，他一共吹熄了236根蜡烛。

请问，他从多少岁开始过生日party的？

请填写他开始过生日party的年龄数。  
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

#include<stdio.h>
    main()
    { 
    	int i,s,j;
    	for(i=1;i<70;i++)
    	{ 
    		s=0;
    		for(j=i;j<70;j++)
    		{ 
    			s+=j;
    			if(s==236)
    			printf("%d %d",i,j);
    			if(s>236)break;
    		}
    	}
    	/* s=0; for(i=26;i<34;i++) s+=i; printf("%d",s); */
    }

## 03 凑算式 ##

![img][]

这个算式中A代表1-9的数字，不同的字母代表不同的数字。

比如：  
6+8/3+952/714 就是一种解法，  
5+3/1+972/486 是另一种解法。

这个算式一共有多少种解法？

注意：你提交应该是个整数，不要填写任何多余的内容或说明性文字。

#include<iostream> 
    using namespace std;  
    int main(void){   
        int count=0;  
        for(int a=1;a<10;a++){   
            for(int b=1;b<10;b++){   
                if(a==b)continue;  
                for(int c=1;c<10;c++){   
                    if(a==c||c==b)continue;  
                    for(int d=1;d<10;d++){   
                        if(a==d||d==b||c==d)continue;  
                        for(int e=1;e<10;e++){   
                            if(e==a||e==b||e==c||e==d)continue;  
                            for(int f=1;f<10;f++){   
                                if(f==a||f==b||f==c||f==d||f==e)continue;  
                                for(int g=1;g<10;g++){   
                                    if(g==a||g==b||g==c||g==d||g==e||g==f)continue;  
                                    for(int h=1;h<10;h++){   
                                        if(h==a||h==b||h==c||h==d||h==e||h==f||h==g)continue;  
                                        for(int i=1;i<10;i++){   
                                            if(i==a||i==b||i==c||i==d||i==e||i==f||i==g||i==h)continue;  
                                            int t1=a*c*(100*g+10*h+i);    
                                            int t2=b*(100*g+10*h+i);    
                                            int t3=c*(100*d+10*e+f);    
                                            int t4=10*c*(100*g+10*h+i);   
                                            if(t1+t2+t3==t4)count++;  
                                        }  
                                    }  
                                }  
                            }  
                        }  
                    }     
                }  
            }  
        }  
        cout<<count<<endl;  
    }

#include <stdio.h>
    bool visit[10];//默认初值都为0 
    int num[10];
    int index;
    int ans=0;
    int solve()
    { 
        double sum=num[0]+(double)num[1]/num[2]+(double)(num[3]*100+num[4]*10+num[5])/(num[6]*100+num[7]*10+num[8]);
        if(sum==10)
        { 
            ans++;
        } 
    }
    int dfs(int index)
    { 
        if(index==9)
        { 
            solve();
            return 0;
        }
        for(int i=1;i<=9;i++)//数字i 0-9 
        { 
            if(!visit[i])//判断数字i有没有访问使用过 数字1 
            { 
                visit[i]=true;//没有访问过使用过，则赋值为true 代表已经使用过 visit[1]已被访问 
                num[index]= i;//把访问的这个数字赋给数组num[index] num[0]=1;
                dfs(index+1);//然后继续递归
                visit[i]=false;//回溯 将visit[i]=false; 然后进行下一次循环 即visit[1]=false;然后 i=2,即数字2进行递归 
            }
        }
    }
    int main()
    { 
        dfs(0);
        printf("%d",ans);
    }

## 04快速排序 ##

排序在各种场合经常被用到。  
快速排序是十分常用的高效率的算法。

其思想是：先选一个“标尺”，  
用它把整个队列过一遍筛子，  
以保证：其左边的元素都不大于它，其右边的元素都不小于它。

这样，排序问题就被分割为两个子区间。  
再分别对子区间排序就可以了。

下面的代码是一种实现，请分析并填写划线部分缺少的代码。

#include <stdio.h>
    
    void swap(int a[], int i, int j)
    { 
    	int t = a[i];
    	a[i] = a[j];
    	a[j] = t;
    }
    
    int partition(int a[], int p, int r)
    { 
        int i = p;
        int j = r + 1;
        int x = a[p];
        while(1){ 
            while(i<r && a[++i]<x);
            while(a[--j]>x);
            if(i>=j) break;
            swap(a,i,j);
        }
    	______________________;//填空
        return j;
    }
    
    void quicksort(int a[], int p, int r)
    { 
        if(p<r){ 
            int q = partition(a,p,r);
            quicksort(a,p,q-1);
            quicksort(a,q+1,r);
        }
    }
        
    int main()
    { 
    	int i;
    	int a[] = { 5,13,6,24,2,8,19,27,6,12,1,17};
    	int N = 12;
        quicksort(a, 0, N-1);
    
        for(i=0; i<N; i++) printf("%d ", a[i]);
        printf("\n");
    
    
    return 0;
    }

注意：只填写缺少的内容，不要书写任何题面已有代码或说明性文字。

划线处为 swap(a,p,j);

## 05 抽签 ##

X星球要派出一个5人组成的观察团前往W星。  
其中：  
A国最多可以派出4人。  
B国最多可以派出2人。  
C国最多可以派出2人。  
…

那么最终派往W星的观察团会有多少种国别的不同组合呢？

下面的程序解决了这个问题。  
数组a\[\] 中既是每个国家可以派出的最多的名额。  
程序执行结果为：  
DEFFF  
CEFFF  
CDFFF  
CDEFF  
CCFFF  
CCEFF  
CCDFF  
CCDEF  
BEFFF  
BDFFF  
BDEFF  
BCFFF  
BCEFF  
BCDFF  
BCDEF  
…  
(以下省略，总共101行)

#include <stdio.h>
    #define N 6
    #define M 5
    #define BUF 1024
    
    void f(int a[], int k, int m, char b[])
    { 
    	int i,j;
    	
    	if(k==N){  
    		b[M] = 0;
    		if(m==0) printf("%s\n",b);
    		return;
    	}
    	
    	for(i=0; i<=a[k]; i++){ 
    		for(j=0; j<i; j++) 
                b[M-m+j] = k+'A';
    		______________________;  //填空位置
    	}
    }
    int main()
    { 	
    	int  a[N] = { 4,2,2,1,1,3};
    	char b[BUF];
    	f(a,0,M,b);
    	return 0;
    }

仔细阅读代码，填写划线部分缺少的内容。

注意：不要填写任何已有内容或说明性文字。

【划线处随便选一个】

很明显是一个递归搜索题，第一个参数和最后一个参数肯定是不变的a，b；第二个参数的意思是现在该选哪一个国家,然后看到递归最后k==N，所以第二个应该是k+1；第三个参数可以看到b\[M-m+j\]，所以推测是m-j。

f(a, k + 1, m - i, b)
    
    f(a, k + 1, m - j, b)
    
    f(a, (++k)–, m - i, b)

## 06方格填数 ##

如下的10个格子  
±-±-±-+  
| | | |  
±-±-±-±-+  
| | | | |  
±-±-±-±-+  
| | | |  
±-±-±-+

（如果显示有问题，也可以参看【图1.jpg】）

填入0~9的数字。要求：连续的两个数字不能相邻。  
（左右、上下、对角都算相邻）

一共有多少种可能的填数方案？

请填写表示方案数目的整数。  
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。  
![在这里插入图片描述][20200218203211465.jpg]

#include<stdio.h>
    #include<stdlib.h>
    int count=0;
    int take[10],index=0;//记录当前已经填入的数字，用于填数字前判断是否已经使用，避免重复使用 
    int is_legal(int s[3][4])//判断是否满足要求：相邻位置数字不能相邻，就是两数字的差大于1.就是为什么s[0][0]、s[2][3]置为-2；
    { 
        //这里的判断方法有点死板。假设每个位置都有上下左右和对角，只需要判断这些位置
        //是不是在数组中，在就进行比较，不在就说明没有。 
        for(int i=0;i<3;i++)
        { 
            for(int j=0;j<4;j++)
            { 
                if(j-1>=0)
                { 
                    if(abs(s[i][j]-s[i][j-1])==1)
                    { 
                        return 0;
                    }
                }
                if(j+1<4)
                { 
                    if(abs(s[i][j]-s[i][j+1])==1)
                    { 
                        return 0;
                    }
                }
                if(i+1<3)
                { 
                    if(abs(s[i][j]-s[i+1][j])==1)
                    { 
                        return 0;
                    }
                }
                if(j-1>=0&&i+1<3)
                { 
                    if(abs(s[i][j]-s[i+1][j-1])==1)
                    { 
                        return 0;
                    }
                }
                if(j+1<4&&i+1<3)
                { 
                    if(abs(s[i][j]-s[i+1][j+1])==1)
                    { 
                        return 0;
                    }
                }
                if(i-1>=0&&j+1<4)
                { 
                    if(abs(s[i][j]-s[i-1][j+1])==1)
                    { 
                        return 0;
                    }
                }
                if(i-1>=0)
                { 
                    if(abs(s[i][j]-s[i-1][j])==1)
                    { 
                        return 0;
                    }
                }
                if(j-1>=0&&i-1>=0)
                { 
                    if(abs(s[i][j]-s[i-1][j-1])==1)
                    { 
                        return 0;
                    }
                }
            }
        } 
        return 1;
    }
    void fun(int s[3][4],int a,int b)
    { 
        int i;
        if(a==2&&b==3)//表示当前已经填满了表格，需要进行判断看是否满足要求 
        { 
            if(is_legal(s))
            { 
                count++;
            }
        }
        else//继续填写 
        { 
            for(i=0;i<=9;i++)
            { 
                int j;
                for(j=0;j<index;j++)//填写的数字必须是没有用过的 
                { 
                    if(i==take[j])
                    { 
                        break;
                    }
                }
                if(j==index)
                { 
                    s[a][b]=i;
                    take[index++]=i;
                    if(b<3)//表示当前行还没填完 
                    { 
                        fun(s,a,b+1);
                    }
                    else//当前行填完就从下一行开始 
                    { 
                        if(a<2)//判断当前行是否是最后一行 
                        { 
                            fun(s,a+1,0);
                        }
                    }
                    index--;//在一次填满结束后，当前位置的数字换为其他可以填写的数字
                            //所以当前使用的数字需要出去。 
                }
            } 
        }
    }
    int main()
    { 
        int s[3][4];
        s[0][0]=-2;
        s[2][3]=-2;
        //左上角和右下角没有，为了方便判断把数值设为-2（小于-1大于10均可） 
        fun(s,0,1);
        printf("%d\n",count);
        return 0;
    }

//package 真题2016;
    
    public class fanggetianshu6 { 
    	
    	static int counts=0;//计数君
    	
    	public static void judge(int[]a) { //判定语句
    		if(Math.abs(a[0]-a[3])==1||Math.abs(a[0]-a[4])==1||Math.abs(a[0]-a[5])==1||Math.abs(a[0]-a[1])==1) { 
    			return;
    		}else if(Math.abs(a[1]-a[4])==1||Math.abs(a[1]-a[5])==1||Math.abs(a[1]-a[6])==1||Math.abs(a[1]-a[2])==1) { 
    			return;
    		}else if(Math.abs(a[2]-a[5])==1||Math.abs(a[2]-a[6])==1) { 
    			return;
    		}else if(Math.abs(a[3]-a[7])==1||Math.abs(a[3]-a[8])==1||Math.abs(a[3]-a[4])==1) { 
    			return;
    		}else if(Math.abs(a[4]-a[7])==1||Math.abs(a[4]-a[8])==1||Math.abs(a[4]-a[9])==1||Math.abs(a[4]-a[5])==1) { 
    			return;
    		}else if(Math.abs(a[5]-a[8])==1||Math.abs(a[5]-a[9])==1||Math.abs(a[5]-a[6])==1) { 
    			return;
    		}else if(Math.abs(a[6]-a[9])==1||Math.abs(a[7]-a[8])==1||Math.abs(a[8]-a[9])==1) { 
    			return;
    		}else counts++;
    		
    	}
    	
    	public static void swap(int[]a,int i,int j) { //交换方法
    		int temp=a[i];
    		a[i]=a[j];
    		a[j]=temp;
    	}
    	
    	public static void qpl(int[] a,int start) { 
    		if(start==a.length) { //末端判定（即凑齐）
    			judge(a);
    		}else { 
    			for(int i=start;i<a.length;i++) { 
    				swap(a,i,start);//回溯
    				qpl(a,start+1);
    				swap(a,i,start);//回溯
    			}
    		}
    	}
    
    	public static void main(String[] args) { 
    		// dfs或者全排列，一般都是末端验证，还没凑满10个数就加判断条件减少搜索次数也可以，但判断位置和判断条件不好确定
    		int[]a={ 0,1,2,3,4,5,6,7,8,9};//就0-9，直接创建方便点
    		qpl(a,0);
    		System.out.println(counts);
    	}
    }

## 07 剪邮票 ##

![图1][1]

如【图1.jpg】, 有12张连在一起的12生肖的邮票。  
现在你要从中剪下5张来，要求必须是连着的。  
（仅仅连接一个角不算相连）  
比如，【图2.jpg】，【图3.jpg】中，粉红色所示部分就是合格的剪取。

请你计算，一共有多少种不同的剪取方法。

请填写表示方案数目的整数。

注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。  
![图2][2]

![图3][3]

#include<stdio.h>
    #include<math.h>
    
    
    /* 1 2 3 4 6 7 8 9 11 12 13 14 */
    
    int mp[12]={ 1,2,3,4,6,7,8,9,11,12,13,14};
    
    int bp[5]={ 0};
    
    int f()
    { 
        int i,j,cz,s=0,all=0;
    //每个人都得有至少一个朋友
        for(i=0;i<5;i++)
        { 
    
            for(j=0;j<5;j++)
    
                if(j!=i)
                { 
                    cz=abs(bp[i]-bp[j]);
    
                    if(cz==1||cz==5)
                    { 
                        s++;
                        break;
                    }
                }
    
        }
    //至少一个人必须要有两个朋友在
        for(i=0;i<5;i++)
        { 
    
            for(j=0;j<5;j++)
    
                if(j!=i)
                { 
                    cz=abs(bp[i]-bp[j]);
    
                    if(cz==1||cz==5)
                    { 
                        all++;
                    }
                }
    
        }	
    
        if(s==5&&all>6)
        { 
            printf("%d %d %d %d %d\n",bp[0],bp[1],bp[2],bp[3],bp[4]);
            return 1;
        }
        else 
            return 0;
    
    }
    
    main()
    { 
        int a,b,c,d,e,sum=0;
    
        for(a=0;a<12;a++)
            for(b=a+1;b<12;b++)
                for(c=b+1;c<12;c++)
                    for(d=c+1;d<12;d++)
                        for(e=d+1;e<12;e++)
                        { 
                            bp[0]=mp[a];
                            bp[1]=mp[b];
                            bp[2]=mp[c];
                            bp[3]=mp[d];
                            bp[4]=mp[e];
    
                            sum+=f();
                        }
    
        printf("%d",sum);
    }

## 08 四平方和 ##

四平方和定理，又称为拉格朗日定理：  
每个正整数都可以表示为至多4个正整数的平方和。  
如果把0包括进去，就正好可以表示为4个数的平方和。

比如：  
5 = 0^2 + 0^2 + 1^2 + 2^2  
7 = 1^2 + 1^2 + 1^2 + 2^2  
（^符号表示乘方的意思）

对于一个给定的正整数，可能存在多种平方和的表示法。  
要求你对4个数排序：  
0 <= a <= b <= c <= d  
并对所有的可能表示法按 a,b,c,d 为联合主键升序排列，最后输出第一个表示法

程序输入为一个正整数N (N<5000000)  
要求输出4个非负整数，按从小到大排序，中间用空格分开

例如，输入：  
5  
则程序应该输出：  
0 0 1 2

再例如，输入：  
12  
则程序应该输出：  
0 2 2 2

再例如，输入：  
773535  
则程序应该输出：  
1 1 267 838

资源约定：  
峰值内存消耗 < 256M  
CPU消耗 < 3000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

注意: main函数需要返回0  
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。  
注意: 所有依赖的函数必须明确地在源文件中 \#include ， 不能通过工程设置而省略常用头文件。

提交时，注意选择所期望的编译器类型。

#include<stdio.h>
    #include<math.h>
    
    int bp[3000]={ 0}; 
    
    main()
    { 
    	int a,b,c,d;
    	
    	int i,n;
    	
    	scanf("%d",&n);
    	
    	for(i=0;i<=sqrt(n);i++)
    		bp[i]=i*i;
    	
    	for(a=0;a<sqrt(n);a++)
    	for(b=a;b<sqrt(n);b++)
    	for(c=b;c<sqrt(n);c++)
    	for(d=c;d<sqrt(n);d++)
    	{ 
    		if(bp[a]+bp[b]+bp[c]+bp[d]==n)
    		{ 
    			printf("%d %d %d %d\n",a,b,c,d);
    			return 0;
    		}
    	}
    	
    }

## 09 交换瓶子 ##

有N个瓶子，编号 1 ~ N，放在架子上。

比如有5个瓶子：  
2 1 3 5 4

要求每次拿起2个瓶子，交换它们的位置。  
经过若干次后，使得瓶子的序号为：  
1 2 3 4 5

对于这么简单的情况，显然，至少需要交换2次就可以复位。

如果瓶子更多呢？你可以通过编程来解决。

输入格式为两行：  
第一行: 一个正整数N（N<10000）, 表示瓶子的数目  
第二行：N个正整数，用空格分开，表示瓶子目前的排列情况。

输出数据为一行一个正整数，表示至少交换多少次，才能完成排序。

例如，输入：  
5  
3 1 2 5 4

程序应该输出：  
3

再例如，输入：  
5  
5 4 3 2 1

程序应该输出：  
2

资源约定：  
峰值内存消耗 < 256M  
CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

提交时，注意选择所期望的编译器类型。

\*\*分析：\*\*贪心法，从左向右如果当前第i个瓶子编号不是i就把编号为i的瓶子换过来。

大神代码O(n)就解决了， 我比赛的是用的是O(n^2), o(>﹏<)o

#include <stdio.h>
    #include <math.h>
     
    int main()
    { 
    	int arr[10010];		//记录第i个瓶子编号为多少
    	int flag[10010];	//记录编号为i的瓶子在哪儿
    	int ans = 0;
    	int n,i;
    	scanf("%d",&n);
     
    	for(i = 1 ; i <= n ; i ++)
    		scanf("%d",&arr[i]);
    		
    	for(i = 1 ; i <= n ; i ++ )
    		flag[arr[i]] = i;
    	
    	for(i = 1 ; i <= n ; i ++)
    	{ 
    		if( i != arr[i] )
    		{ 
    			int x = arr[i];
    			arr[i] ^= arr[flag[i]] ^= arr[i] ^= arr[flag[i]];
    			flag[i] ^= flag[x] ^= flag[i] ^= flag[x];
    			ans ++;
    		}  
    	}
    	
    	printf("%d\n",ans);
    	return 0;
    }

## 10 最大比例 ##

X星球的某个大奖赛设了M级奖励。每个级别的奖金是一个正整数。  
并且，相邻的两个级别间的比例是个固定值。  
也就是说：所有级别的奖金数构成了一个等比数列。比如：  
16,24,36,54  
其等比值为：3/2

现在，我们随机调查了一些获奖者的奖金数。  
请你据此推算可能的最大的等比值。

输入格式：  
第一行为数字 N (0<N<100)，表示接下的一行包含N个正整数  
第二行N个正整数Xi(Xi<1 000 000 000 000)，用空格分开。每个整数表示调查到的某人的奖金数额

要求输出：  
一个形如A/B的分数，要求A、B互质。表示可能的最大比例系数

测试数据保证了输入格式正确，并且最大比例是存在的。

例如，输入：  
3  
1250 200 32

程序应该输出：  
25/4

再例如，输入：  
4  
3125 32 32 200

程序应该输出：  
5/2

再例如，输入：  
3  
549755813888 524288 2

程序应该输出：  
4/1

资源约定：  
峰值内存消耗 < 256M  
CPU消耗 < 3000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

提交时，注意选择所期望的编译器类型。

**思路**

是想将所有抽样的等级进行从小到大排序。然后再将数组中重复的元素去掉。

再依次进行每相邻两数的比值操作。这个比值，可能是所有n个数所组成的等比数列的公比q，或者是q2、q3、q4、……q(n-1)

而我们要求的是原序列的最大公比值。

在求得一个和公比有关的数组之后，我们再进行这些”公比“的比较，遍历所有的“公比”的·比值，保留最

小的就是所要求得的最终结果。

#include<iostream>
    #include<algorithm>
    using namespace std;
    long long g(long long a,long long b){ 
        return (a%b==0)?b:g(b,a%b); 
    }
    bool s(long long a,long long b){ 
        return a>b;
    }
    int main(){ 
        int n;
        cin>>n;
        long long a[n],b[n],c[n],x,y;
        int j=0;
        for(int i=0;i<n;i++)
            cin>>a[i];
        sort(a,a+n,s);
        for(int i=0;i<n-1;i++){ 
            if(a[i]==a[i+1])
                continue;
            long long f=g(a[i],a[i+1]);
            // cout<<f<<endl;
            b[j]=a[i]/f; //化简得到分母
            c[j]=a[i+1]/f;//约分得分子 
            // cout<<b[j]<<" "<<c[j]<<endl;
            j++;
        }
        x=g(b[0],b[1]);
        for(int i=1;i<j;i++){ 
            x=g(b[i],x);
        }
        y=g(c[0],c[1]);
        for(int i=1;i<j;i++){ 
            y=g(c[i],y);
        }
        sort(b,b+j,s);
        for(int i=j-1;i>=0;i--){ 
            // cout<<b[i]<<endl;
            if(b[i]!=x){    //不等于最大公约数的最小值除以最大公约数
                x=b[i]/x;
                break;
            }
        }
        sort(c,c+j,s);
        for(int i=j-1;i>=0;i--){ 
            // cout<<c[i]<<endl;
            if(c[i]!=y){ 
                y=c[i]/y;
                break;
            }
        }
        cout<<x<<"/"<<y<<endl;
        return 0;
    }

//部分来自网络上大佬们的代码，来源难查，侵删

[img]: /images/20221023/4caec82a139548b9b16eae4f42b71cb0.png
[20200218203211465.jpg]: /images/20221023/681c974e6035430082844bdab8b52030.png
[1]: /images/20221023/99934080a2544623bfae2109aee62f93.png
[2]: /images/20221023/94fc91c657314d0cae9dc98ccf383e0c.png
[3]: /images/20221023/7a26840fb8d64327889a7d9df3480a9c.png