ACWING蓝桥杯每日一题python(持续更新

news2024/10/2 18:19:26

ACWing蓝桥杯每日一题

一直没时间去总结算法，终于有空可以总结一下刷的acwing了，因为没时间所以最近只刷了ACWING的蓝桥杯每日一题。。。真是该死

1.截断数组

在这里插入图片描述
首先我们要知道，如果sum(a)不能被3整除或者len(a) < 3 ，那么他肯定没法让截断的三个子数组和都一样
然后我们只要把平均值算出来，从前往后遍历，我们会得到1average截断点，也会得到2average截断点，意思就是说在1average截断点前的子数组加和为average ，那么其实答案就是 2average截断点的个数 + 在2average截断点之前的 1average截断点的个数，，所以我们只要让当tot = 2average时，答案 += 当时的1average 截断点的个数就好了

注意！在判断tot = average 还是 2average 时，要先判断是否等于2average，因为当tot等于0时，1average == 2average，你如果先判断了2*average，就会把1级截断点和二级截断点在同一个地方。。

同时考虑到数组全为0的情况，那么这种情况我们就C（len-1,2）就行了

具体代码如下

n = int(input())
a = [int(x) for x in input().split()]
def c(a,b):
    res = 1
    while b:
        res = res * a / b
        a -= 1
        b -= 1
    return int(res)
if sum(a) % 3 != 0 or len(a) < 3:
    print(0)
elif a == [0]*len(a):
    print(c(len(a)-1,2))
else:
    average = sum(a) // 3
    one = 0
    res = 0
    tot = 0
    for i in range(n-1): # 最后一个点不能考虑进去，要留下一个做第三部分
        tot += a[i]
        
        if tot == 2*average: res += one
        if tot == average:one += 1
        
    print(res)

2.改变数组元素

在这里插入图片描述
初始化一个V 数组，大小为（n+1）初始化都是0
只需要去通过i去遍历a[i],遍历到第i次时，我们就把 i - a[i] + 1 到 i 全部加1，
i就可以代表V数组实际的长度应该是多少，例如当i = 5 ，那么其实V数组实际上长度是5，因为末尾只被加了5个0 ，然后假设a[5] = 2 ，那就是V[4] 和 V[5] + 1 ，这里为什么可以+ 1 不用让他等于1？因为整个流程没有减过，所以只要这个位置不等于0，就代表他被改变过，一定等于1
然后这种从i - a[i] + 1 到 i 全部加1的实现通过差分就很好实现了

具体代码如下

def add(l,r):  # 差分,最后前缀和后L到R + 1
    V[l] += 1
    V[r+1] -= 1 

t = int(input())
for _ in range(t):

    ## 第i次就等于从i- a[i] + 1到i 全变为1
    ## 利用差分，从 i - a[i] + 1 到 i 全部加1 ，因为不会减，所以最后只要前缀和不是0就代表他被换过
    n = int(input())
    a = [int(x) for x in input().split()]
    V = [0]*(n+1) #直接开一个这么大的数组,直接开N  TLE了
    for i in range(1,n+1):  # i要从1开始，i等于1表示数组中末尾添加了一个0
        if a[i-1] == 0:continue
        if (a[i-1] >= i):
            add(0,i-1)
        else:
            add(i - a[i-1],i-1)
    for i in range(n):
        V[i+1] += V[i]
    for i in range(n):
        if V[i] != 0 :print(1,end = ' ')
        else: print(0,end = ' ')
    print()

3.我在哪？

在这里插入图片描述
这题我觉得主要的就是需要考虑到字符串的哈希存储，因为字符串没法像数组那样去用下标来找到第几个字母，所以得先将字符串进行哈希存储，然后再遍历遍历列表，例如k = 4 ，就字符串前四个的值放入集合中，然后字符串2-5的哈希值看看在不在集合中，如果在，就返回False
然后要找K的话其实从1开始遍历就好了，只不过那样时间复杂度是O（n）很可能会被卡，最好用二分

具体代码如下

字符串哈希

## 核心思想：将字符串看成P进制数，P的经验值是131或13331，取这两个值的冲突概率低
##  小技巧：取模的数用2^64，溢出的结果就是取模的结果
## h[k]存储字符串前k个字母的哈希值, p[k]存储 P^k mod 2^64
N = 10**5 +10
P = 131
M = 91815541
h = [0] * N
p = [0] * N
p[0] = 1
n = int(input())
s = " " + input()
for i in range(1,n+1):
    h[i] = h[i-1]*P + ord(s[i]) % M
def get(l,r):
    return (h[r] - h[l-1] * P**(r-l+1)) % M
def check(k):
    a = set()
    for i in range(1,n - k + 2):
        if get(i,i + k -1) in a:
            return False
        else:
            a.add(get(i,i+k-1))
    return True

if __name__ == '__main__':
    l,r = 1,n
    while l < r:
        mid = (l + r) >> 1
        if check(mid): r = mid
        else: l = mid + 1
    print(r)

4.字符串删减

在这里插入图片描述
这个相对于Python来说就很好做吧，别的我不知道，就是记录一下连续x的长度，然后最后计算一下就好了，直接看代码吧

具体代码如下

n = int(input())
s = input()
lens = 0
lenshuzu = [] # 记录每一段连续的数组
for i in s:
    if i == 'x':
        lens += 1
    else:
        lenshuzu.append(lens)
        lens = 0
lenshuzu.append(lens)
res = 0
for i in lenshuzu:
    if i >= 3:
        res += i - 2
print(res)

5.砖块

在这里插入图片描述

在这里插入图片描述

这题我选择算是用贪心的方法去做吧，分为两种，全变黑和全变白
如果是全变白，那么就当看到黑的砖块，就把他变白就好了
后面的输入操作的我可能是写的有点麻烦了。。有大佬有更简便的可以指导一下

具体代码如下

T = int(input())
for _ in range(T):
    k = int(input())
    p = input()
    p2 = p #记录一下
    p = list(p)
    caozuo1 = []
    ans1 = 0
    flag1 = False
    flag2 = False
    # 全变白色
    for i in range(k-1):
        if p[i] == 'B':
            p[i] = 'W'
            if p[i+1] == 'B':p[i+1] = 'W'
            else: p[i+1] = 'B'
            caozuo1.append(i+1)
            ans1 += 1
    if p == ['W']*k :flag1 = True
    
    # 全变黑色
    p2 = list(p2)
    caozuo2 = []
    ans2 = 0
    for i in range(k-1):
        if p2[i] == 'W':
            p2[i] = 'B'
            if p2[i+1] == 'W':p2[i+1] = 'B'
            else: p2[i+1] = 'W'
            caozuo2.append(i+1)
            ans2 += 1
    if p2 == ['B']*k:flag2 = True
    if flag1 and flag2:
        if ans1 < ans2:
            print(ans1)
            if caozuo1:
                for i in caozuo1:
                    print(i,end = ' ')
                print()
            continue
        else:
            print(ans2)
            if caozuo2:
                for i in caozuo2:
                    print(i,end = ' ')
                print()
            continue
    if flag1:
        print(ans1)
        if caozuo1:
            for i in caozuo1:
                print(i,end = ' ')
            print()
        continue
    if flag2:
        print(ans2)
        if caozuo2:
            for i in caozuo2:
                print(i,end = ' ')
            print()
        continue
    print(-1)

6.树的遍历

在这里插入图片描述
这题就递归做，可以通过中序和后序找到根节点的左右子树的中序和后序，然后递归往下建立

建立完一棵树之后就用Dfs去搜索就好了

具体代码如下

class TreeNode(object):
    def __init__(self,x):
        self.val = x
        self.left = None
        self.right = None

class Solution(object):
    def buildTree(self,inorder,postorder):  # inorder是中序，postorder是后序
        if not postorder:
            return None
        root = TreeNode(postorder[-1])
        root_index = inorder.index(postorder[-1]) # 根节点在中序中的坐标
        left_i = inorder[:root_index] # 根据中序确定左右子树
        right_i = inorder[root_index + 1:]
        len_li = len(left_i)  # 左子树长度
        left_p = postorder[:len_li]  # 确定后序遍历的左右子树
        right_p = postorder[len_li:-1]

        root.left = self.buildTree(left_i,left_p)
        root.right = self.buildTree(right_i,right_p)
        return root
def bfs(root):  #广搜进行层序遍历
    if root == None:
        return
    q = []
    q.append(root)
    head = 0
    while len(q)!=0:
        print(q[head].val,end=' ')

        if q[head].left != None:
            q.append(q[head].left)

        if q[head].right != None:
            q.append(q[head].right)

        q.pop(0)


n = int(input())
    
posto = [int(x) for x in input().split()]
inord = [int(x) for x in input().split()]
    
solution = Solution()
root = solution.buildTree(inord,posto)
bfs(root)

7.亲戚

在这里插入图片描述
在这里插入图片描述
啊这题典型的并查集，让同样是亲戚的有同一个祖先就好了，不用管祖先是谁
简单说一下并查集吧
就是有一个p数组，代表自己的父亲是谁，然后就是每次遍历两个a,b，如果a和b没有同一个祖先，我们就让a的祖先 去 变成b的祖先的儿子，这样a和b就有同一个祖先了吧？
然后怎么找a和b的祖先呢，这也是并查集的精髓所在，一个find函数

def find(x):
    if p[x] != x:
        p[x] = find(p[x])
    return p[x]

如果x的父亲不是自己，就代表x不是这个家族的祖先对吧，那么让p[x]等于find(p[x])，find(p[x])就是找到p[x]的祖先，一层一层网上找，这个find函数的精髓在于，他会让p[x] = find(p[x]) 就是如果你现在他这个找到祖先的一条线的P[x]都会直接变为他们的祖先，而不是他们的父亲
然后就很好做了，看看他们的祖先是否一样就能代表是不是一个群体了

具体完整代码如下

import sys
# 不知道为什么用map(int,input().split())会被卡。。
N, M = map(int, sys.stdin.readline().strip().split())
p = [i for i in range(N + 1)]

def find(x):
    if p[x] != x:
        p[x] = find(p[x])
    return p[x]

for i in range(M):
    a, b = map(int, sys.stdin.readline().strip().split())
    pa, pb = find(a), find(b)
    if pa != pb:
        p[pa] = pb
q = int(input())
for i in range(q):
    a, b = map(int, sys.stdin.readline().strip().split())
    if find(a) == find(b):
        print('Yes')
    else:
        print('No')

8.笨拙的手指

在这里插入图片描述
这题我的想法是，把二进制的每一位都变一下，就是把可能的正确答案都存在一个列表中，然后去对比二进制和三进制的列表，找到相同的，二进制的好做，0和1之间变换只要用^就可以了，三进制就需要在遍历一下1-3 ，如果与当前位不同再去变，看代码吧，蛮容易看懂的，比我写清晰多了

具体代码如下

import copy
er = input()
three = input()
erjinzhi = []
sanjinzhi = []
for i in range(len(er)):
    erjinzhi.append(int(er[i]))
for j in range(len(three)):
    sanjinzhi.append(int(three[j]))
res_2 = []
res_3 = []
copy_erjinzhi = copy.deepcopy(erjinzhi)
for i in range(len(erjinzhi)):  #勉强算20
    erjinzhi = copy.deepcopy(copy_erjinzhi)
    erjinzhi[i] = erjinzhi[i] ^ 1
    lenlen = 2**(len(erjinzhi)-1)
    res = 0
    for j in erjinzhi:
        res += j*lenlen
        lenlen >>= 1
    res_2.append(res)
    
    

copy_sanjinzhi = copy.deepcopy(sanjinzhi)
for i in range(len(sanjinzhi)):  #勉强算20

    for j in range(3):
        sanjinzhi = copy.deepcopy(copy_sanjinzhi)
        if sanjinzhi[i] != j:
            sanjinzhi[i] = j
            lenlen = 3**(len(sanjinzhi) - 1)
            res = 0
            for k in sanjinzhi:
                res += k*lenlen
                lenlen //= 3
            res_3.append(res)
res = 0
for i in res_2:
    for j in res_3:
        if i == j:
            res = max(res,i)
print(res)

9.裁剪序列

在这里插入图片描述
我也没搞懂。。抱歉

10.周期

在这里插入图片描述
在这里插入图片描述
首先，我们要知道KMP算法的next数组是什么用的，他是可以找到后缀和前缀相同的个数的一个数组，具体求法可以看我的KMP手写算法那一个

然后我们只需要从头到尾扫一遍，只要（i % (i-next[i])）== 0 就代表有重复节，并且长度是i // ( i - next[i])
例如 abcabcabcabc 当i等于12时，就是全长了嘛，然后next[i] = 9
满足条件吧？ 长度为4

具体代码如下

def find_next(p):
    next = [0] * (len(p)+1)
    j,k = 0,-1
    next[0] = -1  # 防止死循环 k一直等于0 j也不加
    while(j <= len(p) - 1):
        if (k == -1 or p[j] == p[k]):
            j += 1
            k += 1
            next[j] = k
        else:
            k = next[k]
    next[0] = 0
    return next

if __name__ == '__main__':
    flag = 1
    while True:
        n = int(input())
        if n == 0: break
        print('Test case #{}'.format(flag))
        s = input()
        next = find_next(s)
        for i in range(2,n+1):
            if i % (i - next[i]) == 0 and next[i]:
                print('{} {}'.format(i,i//(i - next[i])))
        print()
        flag += 1

11.最大异或和

在这里插入图片描述
先求出前i个数的异或和sum[i]，再在大小为m的滑动窗口内进行trie.
在这里插入图片描述
参考自https://www.acwing.com/solution/content/48648/
用trie树嘛，每个数都被记录在一个trie树中，一个二分数，每个节点都有一个0，1孩子，我们这边用了30层，完全够用了，然后把每个数的二进制数给存进去
先计算前缀异或和s[i]
要求异或和a[l]…a[r] 转化为前缀异或和数组(s[r]^s[l-1])

具体代码如下

N = 100010 * 31
M = 100010
son = [[0]*2 for _ in range(N)]  #　son[p][n] n 只有两个取值为0和1，
idx = 0
s = [0]*M
cnt = [0]*N # cnt变量表示这个节点在构建字典树的时候保存了几次
# 遍历的时候，如果节点的cnt>0，就代表可以接着往下走，
def insert(x,v):
    
    global idx,son,s,cnt
    p = 0
    for i in range(30,-1,-1):
        # 意思就是一棵树有30层，来代表每个数的二进制数
        u = x >> i & 1
        if(int(not son[p][u])):  # p的儿子有0和1两条路径
            idx += 1
            son[p][u] = idx
        p = son[p][u]            #p变为儿子，如果v是1，那么这条路径的p的1儿子+1
        cnt[p] += v              
        

### 我们遍历的话肯定是想从最高位开始，走1的分支，因为那样异或和才会更大
def query(x):
    # res 初始值为s[i]
    res = x
    p = 0
    for i in range(30,-1,-1):
        u = x >> i & 1       # x的二进制的第i位
## 现在x的第i位是u ，所以我们要走跟u相反的，这样他们异或才会为1
        if cnt[son[p][int(not u)]]:  # 就是存在和不存在 p 有两个儿子嘛，一个是0一个是1，如果u是1，就要看p的0的儿子还有没有
            u = int(not u)

        res ^= u << i  # u << i 因为之前 u = x >> i & 1 了，现在还回去
        # print(res)
        p = son[p][u]  # 接着往下走
    return res


if __name__ == '__main__':
    n,m = map(int,input().split())
    a = [int(x) for x in input().split()]
    for i in range(1,n+1):
        s[i] = s[i-1]^a[i-1]

    insert(s[0],1)
    Res = 0
    for i in range(1,n+1):
        if i > m :
            insert(s[i - m - 1],-1)

        Res = max(Res,query(s[i]))
        insert(s[i],1)        # 把s[i]加入到树中
    print(Res)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/397539.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Android使用移动智能终端补充设备标识获取OAID

Android使用移动智能终端补充设备标识获取OAID

官网http://www.msa-alliance.cn/col.jsp?id120首先到官网注册账号&#xff0c;申请下载相关sdk和授权证书2.把 oaid_sdk_x.x.x.aar 拷贝到项目的 libs 目录&#xff0c;并设置依赖&#xff0c;其中x.x.x 代表版本号3.supplierconfig.json 拷贝到项目 assets 目录下&#xff0…
阅读更多...
keepalived实现nginx高可用

keepalived实现nginx高可用

文章目录前言keepalived简介软件架构简单理解环境准备一、keepalived安装1.1 下载keepalived 安装包1.2 解压/下载依赖1.3 编译1.4 创建软连接1.5 增加系统服务1.6 启动keepalived二、实现Nginx高可用2.1 创建keepalived配置文件2.2 Nginx监控脚本2.4 重启keepalived2.5 查看虚…
阅读更多...
自己DIY装机后，如何使用U盘装系统

自己DIY装机后，如何使用U盘装系统

最近自己整了一台主机&#xff0c;然后需要装一下系统&#xff0c;这边就讲一下如何用U盘给新电脑装系统。 安装Windows 10 光盘映像 首先你需要一个内存大于8GB的U盘&#xff0c;并且是纯净的&#xff0c;里面没有东西。 这边以Windows 10 为例&#xff1a; 百度搜索 下载…
阅读更多...
IMX6ULL 启动方式之启动设备的选择

IMX6ULL 启动方式之启动设备的选择

一. 硬件启动方式选择 汇编程序启动 LED 灯实验&#xff0c;是从SD卡读取 bin 文件并启动&#xff0c;说明 IMX6ULL 支持从 SD 卡启动。 IMX6ULL 支持多种启动方式。 注意&#xff1a;硬件原理图中&#xff0c;标注 DNP ( do not pupulate) 的意思是不焊接&#xff0c;即没…
阅读更多...
【AcWing】归并排序及其应用

【AcWing】归并排序及其应用

&#x1f386;音乐分享 &#xff08;点击链接可以听哦&#x1f60e;&#xff09; 无名之辈 - 陈雪燃 目录 归并排序 归并排序应用 文章中的图片来源&#xff1a; (2条消息) 归并排序&#xff08;分治法&#xff09;_分治法 归并排序_小小的香辛料的博客-CSDN博客 AcWing…
阅读更多...
Springboot怎么实现WebSocket通信（二）

Springboot怎么实现WebSocket通信（二）

前言上一篇文章分享了单机模式下&#xff0c;websocket的基本使用方法&#xff0c;但在实际的业务中&#xff0c;通常是不会这样使用的&#xff0c;大部项目都是分布式部署的&#xff0c;一个工程布署了多个服务节点&#xff0c;前端并不直接请求具体服务节点&#xff0c;而是先…
阅读更多...
C51---PWM 脉冲宽度调制

C51---PWM 脉冲宽度调制

1.PWM:脉冲宽度调制,它是通过一系列脉冲宽度进行调制&#xff0c;等效出所需要的波形&#xff08;包含形状以及幅值&#xff09;。对模拟信号电平进行数字编码。也就是说通过调节占空比的变化来调节信号、能量等的变化&#xff0c;占空比就是指在一个周期内&#xff0c;信号处于…
阅读更多...
第九届省赛——6打印大X

第九届省赛——6打印大X

题目&#xff1a;本题目要求你在控制台输出一个由数字组成的等腰三角形。具体的步骤是&#xff1a;1. 先用1,2,3&#xff0c;...的自然数拼一个足够长的串2. 用这个串填充三角形的三条边。从上方顶点开始&#xff0c;逆时针填充。比如&#xff0c;当三角形高度是8时&#xff1a…
阅读更多...
【Java开发】JUC进阶 06：异步回调、JMM、Volatile

【Java开发】JUC进阶 06：异步回调、JMM、Volatile

1 异步回调异步是多线程的一种特殊实现方式&#x1f4cc; 举例我需要一个计算时间5秒方法的返回值我不想等这5秒钟&#xff0c;我想要继续执行下面的代码&#xff0c;那就异步执行这个方法当我通过get去获取这个返回值时&#xff0c;如果已经过了5秒&#xff0c;也就是方法执行…
阅读更多...
16、参数估计

16、参数估计

概率基本定义先验分布&#xff1a;似然函数&#xff1a;后验分布&#xff1a;贝叶斯公式&#xff1a;&#xff0c;其中后验分布 似然函数 先验分布 / P(D)贝叶斯公式假设&#xff0c;现在有两个一定概率发生的事件A和B&#xff0c;且它们之间存在一定的关系P(A) 表示事件A发生…
阅读更多...
UNIX网络编程卷一 学习笔记 第八章 基本UDP套接字编程

UNIX网络编程卷一 学习笔记 第八章 基本UDP套接字编程

UDP是无连接不可靠的数据报协议&#xff0c;不同于TCP提供的面向连接的可靠字节流。使用UDP编写的常见程序有&#xff1a;DNS、NFS、SNMP。 以下是典型的UDP客户/服务器程序的函数调用&#xff0c;客户不与服务器建立连接&#xff0c;而是只使用sendto函数给服务器发送数据报&…
阅读更多...
03_Linux压缩解压,用户用户组,文件权限

03_Linux压缩解压,用户用户组,文件权限

目录 Linux下常用的压缩格式 gzip 压缩工具 gzip 对文件夹进行压缩 bzip2 压缩工具 tar打包工具 对.tar.bz2 进行压缩和解压缩 对.tar.gz 进行压缩和解压缩 rar格式 zip格式 Linux用户 Linux用户组 创建用户和用户组 Linux文件权限 Linux文件权限修改 Linux下常用…
阅读更多...
windows10安装nodejs

windows10安装nodejs

一、下载 官网 Download | Node.js 某云盘 链接&#xff1a;https://pan.baidu.com/s/1PCd4fh4ohEvAc8qSrb4-WA 提取码&#xff1a;yola 二、安裝 双击安装程序&#xff1a;具体步骤如下&#xff1a; 设置环境变量 验证安装是否安装成功 进入cmd命令行窗口&#xff0c;输入…
阅读更多...
SQL优化操作1

SQL优化操作1

一.存储过程建表 建两张30万条数据的表以做测试用 1.user_course_info delimiter $$ # 定义结束符 drop procedure if exists addTestDataOne; # 存储过程名叫&#xff1a;addTestData create procedure addTestDataOne() begin declare number int; set number 1; w…
阅读更多...
node 配置 vue npm配置

node 配置 vue npm配置

下载node 版本16https://nodejs.org/download/release/v16.16.0/node-v16.16.0-x64.msi复制安装地址&#xff0c;省空间&#xff0c;生报错老老实实复制就好D:\Program\nodejs新建node_cache和node_globalD:\Program\nodejs\node_cacheD:\Program\nodejs\node_global运行命令np…
阅读更多...
Sentinel架构篇 - 熔断降级

Sentinel架构篇 - 熔断降级

熔断降级 概念 除了流量控制以外&#xff0c;对调用链路中不稳定的资源进行熔断降级也是保障高可用的重要措施之一。一个服务常常会调用其它模块&#xff0c;可能是一个远程服务、数据库、或者第三方 API 等。然而&#xff0c;被依赖的服务的稳定性是不能保证的。如果依赖的服…
阅读更多...
原生HTML放大镜

原生HTML放大镜

该放大区域用背景图片放大 <!DOCTYPE html> <html lang"zh"><head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.0"><meta http-equiv"X-UA-Compat…
阅读更多...
Linux - buff和cache的区别

Linux - buff和cache的区别

free -h命令可以查看内存的使用情况 [rootzabbix-server ~]# free -htotal used free shared buff/cache available Mem: 1.8G 432M 894M 10M 492M 1.2G Swap: 2.0G 0B 2.0G为什…
阅读更多...
抖音小程序实践四：实现小程序分享

抖音小程序实践四：实现小程序分享

有时候我们要把一个小程序分享给别人&#xff0c;去看套餐、买东西之类的&#xff0c;是一个很常见的功能&#xff0c;但是在接入抖音小程序的时候&#xff0c;初始化右上角三个点并没有分享的入口&#xff0c;那看来不是要申请&#xff0c;就是有别的开发的口子了。下面我们一…
阅读更多...
《SQL基础》17. InnoDB引擎

《SQL基础》17. InnoDB引擎

InnoDB引擎InnoDB引擎逻辑存储结构架构内存结构磁盘结构后台线程事务原理事务基础redo logundo logMVCC基本概念隐式字段undo log版本链readView原理分析InnoDB引擎 逻辑存储结构 InnoDB的逻辑存储结构如下图所示&#xff1a; 表空间 表空间是InnoDB存储引擎逻辑结构的最高层…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023