算法思想 - 搜索算法

news2024/11/22 15:34:38
本文主要介绍算法中搜索算法的思想，主要包含BFS，DFS。

搜索相关题目

深度优先搜索和广度优先搜索广泛运用于树和图中，但是它们的应用远远不止如此。

BFS

广度优先搜索的搜索过程有点像一层一层地进行遍历，每层遍历都以上一层遍历的结果作为起点，遍历一个距离能访问到的所有节点。需要注意的是，遍历过的节点不能再次被遍历。

第一层:

  • 0 -> {6,2,1,5};

第二层:

  • 6 ->

  • 2 -> {}

  • 1 -> {}

  • 5 ->

第三层:

  • 4 -> {}

  • 3 -> {}

可以看到，每一层遍历的节点都与根节点距离相同。设 di 表示第 i 个节点与根节点的距离，推导出一个结论: 对于先遍历的节点 i 与后遍历的节点 j，有 di<=dj。利用这个结论，可以求解最短路径等 最优解 问题: 第一次遍历到目的节点，其所经过的路径为最短路径。应该注意的是，使用 BFS 只能求解无权图的最短路径。

在程序实现 BFS 时需要考虑以下问题:

  • 队列: 用来存储每一轮遍历得到的节点；

  • 标记: 对于遍历过的节点，应该将它标记，防止重复遍历。

计算在网格中从原点到特定点的最短路径长度

[[1,1,0,1],
 [1,0,1,0],
 [1,1,1,1],
 [1,0,1,1]]

1 表示可以经过某个位置，求解从 (0, 0) 位置到 (tr, tc) 位置的最短路径长度。

public int minPathLength(int[][] grids, int tr, int tc) {
    final int[][] direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    final int m = grids.length, n = grids[0].length;
    Queue<Pair<Integer, Integer>> queue = new LinkedList<>();
    queue.add(new Pair<>(0, 0));
    int pathLength = 0;
    while (!queue.isEmpty()) {
        int size = queue.size();
        pathLength++;
        while (size-- > 0) {
            Pair<Integer, Integer> cur = queue.poll();
            for (int[] d : direction) {
                int nr = cur.getKey() + d[0], nc = cur.getValue() + d[1];
                Pair<Integer, Integer> next = new Pair<>(nr, nc);
                if (next.getKey() < 0 || next.getValue() >= m
                        || next.getKey() < 0 || next.getValue() >= n) {

                    continue;
                }
                grids[next.getKey()][next.getValue()] = 0; // 标记
                if (next.getKey() == tr && next.getValue() == tc) {
                    return pathLength;
                }
                queue.add(next);
            }
        }
    }
    return -1;
}

组成整数的最小平方数数量

279. Perfect Squares (Medium)

For example, given n = 12, return 3 because 12 = 4 + 4 + 4; given n = 13, return 2 because 13 = 4 + 9.

可以将每个整数看成图中的一个节点，如果两个整数之差为一个平方数，那么这两个整数所在的节点就有一条边。

要求解最小的平方数数量，就是求解从节点 n 到节点 0 的最短路径。

本题也可以用动态规划求解，在之后动态规划部分中会再次出现。

public int numSquares(int n) {
    List<Integer> squares = generateSquares(n);
    Queue<Integer> queue = new LinkedList<>();
    boolean[] marked = new boolean[n + 1];
    queue.add(n);
    marked[n] = true;
    int level = 0;
    while (!queue.isEmpty()) {
        int size = queue.size();
        level++;
        while (size-- > 0) {
            int cur = queue.poll();
            for (int s : squares) {
                int next = cur - s;
                if (next < 0) {
                    break;
                }
                if (next == 0) {
                    return level;
                }
                if (marked[next]) {
                    continue;
                }
                marked[next] = true;
                queue.add(cur - s);
            }
        }
    }
    return n;
}

/**
 * 生成小于 n 的平方数序列
 * @return 1,4,9,...
 */
private List<Integer> generateSquares(int n) {
    List<Integer> squares = new ArrayList<>();
    int square = 1;
    int diff = 3;
    while (square <= n) {
        squares.add(square);
        square += diff;
        diff += 2;
    }
    return squares;
}

最短单词路径

127. Word Ladder (Medium)

Input:
beginWord = "hit",
endWord = "cog",
wordList = ["hot","dot","dog","lot","log","cog"]

Output: 5

Explanation: As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length 5.
Input:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log"]

Output: 0

Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.

找出一条从 beginWord 到 endWord 的最短路径，每次移动规定为改变一个字符，并且改变之后的字符串必须在 wordList 中。

public int ladderLength(String beginWord, String endWord, List<String> wordList) {
    wordList.add(beginWord);
    int N = wordList.size();
    int start = N - 1;
    int end = 0;
    while (end < N && !wordList.get(end).equals(endWord)) {
        end++;
    }
    if (end == N) {
        return 0;
    }
    List<Integer>[] graphic = buildGraphic(wordList);
    return getShortestPath(graphic, start, end);
}

private List<Integer>[] buildGraphic(List<String> wordList) {
    int N = wordList.size();
    List<Integer>[] graphic = new List[N];
    for (int i = 0; i < N; i++) {
        graphic[i] = new ArrayList<>();
        for (int j = 0; j < N; j++) {
            if (isConnect(wordList.get(i), wordList.get(j))) {
                graphic[i].add(j);
            }
        }
    }
    return graphic;
}

private boolean isConnect(String s1, String s2) {
    int diffCnt = 0;
    for (int i = 0; i < s1.length() && diffCnt <= 1; i++) {
        if (s1.charAt(i) != s2.charAt(i)) {
            diffCnt++;
        }
    }
    return diffCnt == 1;
}

private int getShortestPath(List<Integer>[] graphic, int start, int end) {
    Queue<Integer> queue = new LinkedList<>();
    boolean[] marked = new boolean[graphic.length];
    queue.add(start);
    marked[start] = true;
    int path = 1;
    while (!queue.isEmpty()) {
        int size = queue.size();
        path++;
        while (size-- > 0) {
            int cur = queue.poll();
            for (int next : graphic[cur]) {
                if (next == end) {
                    return path;
                }
                if (marked[next]) {
                    continue;
                }
                marked[next] = true;
                queue.add(next);
            }
        }
    }
    return 0;
}

DFS

广度优先搜索一层一层遍历，每一层得到的所有新节点，要用队列存储起来以备下一层遍历的时候再遍历。

而深度优先搜索在得到一个新节点时立马对新节点进行遍历: 从节点 0 出发开始遍历，得到到新节点 6 时，立马对新节点 6 进行遍历，得到新节点 4；如此反复以这种方式遍历新节点，直到没有新节点了，此时返回。返回到根节点 0 的情况是，继续对根节点 0 进行遍历，得到新节点 2，然后继续以上步骤。

从一个节点出发，使用 DFS 对一个图进行遍历时，能够遍历到的节点都是从初始节点可达的，DFS 常用来求解这种 可达性 问题。

在程序实现 DFS 时需要考虑以下问题:

  • 栈: 用栈来保存当前节点信息，当遍历新节点返回时能够继续遍历当前节点。可以使用递归栈。

  • 标记: 和 BFS 一样同样需要对已经遍历过的节点进行标记。

查找最大的连通面积

695. Max Area of Island (Easy)

[[0,0,1,0,0,0,0,1,0,0,0,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,1,1,0,1,0,0,0,0,0,0,0,0],
 [0,1,0,0,1,1,0,0,1,0,1,0,0],
 [0,1,0,0,1,1,0,0,1,1,1,0,0],
 [0,0,0,0,0,0,0,0,0,0,1,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,0,0,0,0,0,0,1,1,0,0,0,0]]
private int m, n;
private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};

public int maxAreaOfIsland(int[][] grid) {
    if (grid == null || grid.length == 0) {
        return 0;
    }
    m = grid.length;
    n = grid[0].length;
    int maxArea = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            maxArea = Math.max(maxArea, dfs(grid, i, j));
        }
    }
    return maxArea;
}

private int dfs(int[][] grid, int r, int c) {
    if (r < 0 || r >= m || c < 0 || c >= n || grid[r][c] == 0) {
        return 0;
    }
    grid[r][c] = 0;
    int area = 1;
    for (int[] d : direction) {
        area += dfs(grid, r + d[0], c + d[1]);
    }
    return area;
}

矩阵中的连通分量数目

200. Number of Islands (Medium)

Input:
11000
11000
00100
00011

Output: 3

可以将矩阵表示看成一张有向图。

private int m, n;
private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};

public int numIslands(char[][] grid) {
    if (grid == null || grid.length == 0) {
        return 0;
    }
    m = grid.length;
    n = grid[0].length;
    int islandsNum = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] != '0') {
                dfs(grid, i, j);
                islandsNum++;
            }
        }
    }
    return islandsNum;
}

private void dfs(char[][] grid, int i, int j) {
    if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] == '0') {
        return;
    }
    grid[i][j] = '0';
    for (int[] d : direction) {
        dfs(grid, i + d[0], j + d[1]);
    }
}

好友关系的连通分量数目

547. Friend Circles (Medium)

Input:
[[1,1,0],
 [1,1,0],
 [0,0,1]]
Output: 2
Explanation:The 0th and 1st students are direct friends, so they are in a friend circle.
The 2nd student himself is in a friend circle. So return 2.

好友关系可以看成是一个无向图，例如第 0 个人与第 1 个人是好友，那么 M[0][1] 和 M[1][0] 的值都为 1。

private int n;

public int findCircleNum(int[][] M) {
    n = M.length;
    int circleNum = 0;
    boolean[] hasVisited = new boolean[n];
    for (int i = 0; i < n; i++) {
        if (!hasVisited[i]) {
            dfs(M, i, hasVisited);
            circleNum++;
        }
    }
    return circleNum;
}

private void dfs(int[][] M, int i, boolean[] hasVisited) {
    hasVisited[i] = true;
    for (int k = 0; k < n; k++) {
        if (M[i][k] == 1 && !hasVisited[k]) {
            dfs(M, k, hasVisited);
        }
    }
}

填充封闭区域

130. Surrounded Regions (Medium)

For example,
X X X X
X O O X
X X O X
X O X X

After running your function, the board should be:
X X X X
X X X X
X X X X
X O X X

使被 'X' 包围的 'O' 转换为 'X'。

先填充最外侧，剩下的就是里侧了。

private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
private int m, n;

public void solve(char[][] board) {
    if (board == null || board.length == 0) {
        return;
    }

    m = board.length;
    n = board[0].length;

    for (int i = 0; i < m; i++) {
        dfs(board, i, 0);
        dfs(board, i, n - 1);
    }
    for (int i = 0; i < n; i++) {
        dfs(board, 0, i);
        dfs(board, m - 1, i);
    }

    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (board[i][j] == 'T') {
                board[i][j] = 'O';
            } else if (board[i][j] == 'O') {
                board[i][j] = 'X';
            }
        }
    }
}

private void dfs(char[][] board, int r, int c) {
    if (r < 0 || r >= m || c < 0 || c >= n || board[r][c] != 'O') {
        return;
    }
    board[r][c] = 'T';
    for (int[] d : direction) {
        dfs(board, r + d[0], c + d[1]);
    }
}

能到达的太平洋和大西洋的区域

417. Pacific Atlantic Water Flow (Medium)

Given the following 5x5 matrix:

  Pacific ~   ~   ~   ~   ~
       ~  1   2   2   3  (5) *
       ~  3   2   3  (4) (4) *
       ~  2   4  (5)  3   1  *
       ~ (6) (7)  1   4   5  *
       ~ (5)  1   1   2   4  *
          *   *   *   *   * Atlantic

Return:
[[0, 4], [1, 3], [1, 4], [2, 2], [3, 0], [3, 1], [4, 0]] (positions with parentheses in above matrix).

左边和上边是太平洋，右边和下边是大西洋，内部的数字代表海拔，海拔高的地方的水能够流到低的地方，求解水能够流到太平洋和大西洋的所有位置。

private int m, n;
private int[][] matrix;
private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};

public List<int[]> pacificAtlantic(int[][] matrix) {
    List<int[]> ret = new ArrayList<>();
    if (matrix == null || matrix.length == 0) {
        return ret;
    }

    m = matrix.length;
    n = matrix[0].length;
    this.matrix = matrix;
    boolean[][] canReachP = new boolean[m][n];
    boolean[][] canReachA = new boolean[m][n];

    for (int i = 0; i < m; i++) {
        dfs(i, 0, canReachP);
        dfs(i, n - 1, canReachA);
    }
    for (int i = 0; i < n; i++) {
        dfs(0, i, canReachP);
        dfs(m - 1, i, canReachA);
    }

    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (canReachP[i][j] && canReachA[i][j]) {
                ret.add(new int[]{i, j});
            }
        }
    }

    return ret;
}

private void dfs(int r, int c, boolean[][] canReach) {
    if (canReach[r][c]) {
        return;
    }
    canReach[r][c] = true;
    for (int[] d : direction) {
        int nextR = d[0] + r;
        int nextC = d[1] + c;
        if (nextR < 0 || nextR >= m || nextC < 0 || nextC >= n
                || matrix[r][c] > matrix[nextR][nextC]) {

            continue;
        }
        dfs(nextR, nextC, canReach);
    }
}

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

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

相关文章

【C/C++基础练习题】复习题三，易错点知识点笔记

【C/C++基础练习题】复习题三，易错点知识点笔记

C复习题知识点记录&#xff1a; 在定义结构体类型时&#xff0c;不可以为成员设置默认值。 在公用一个共用体变量时。系统为其分配存储空间的原则是按成员中占内存空间最大者分配 a ,La, "a", L"a" 字符 长字符 字符串 长字符串 布尔类型只有两个值 fal…
阅读更多...
尚医通（十四）Spring Cloud GateWay网关 | 跨域 | 权限认证

尚医通（十四）Spring Cloud GateWay网关 | 跨域 | 权限认证

目录一、网关基本概念1、API网关介绍2、Spring Cloud Gateway3、Spring Cloud Gateway核心概念二、创建service_gateway模块&#xff08;网关服务&#xff09;1、创建service_gateway模块2、在pom.xml引入依赖3、编写application.properties配置文件4、编写启动类5、前端端口号…
阅读更多...
Early Data将在数据应用领域与亚马逊云科技加深合作

Early Data将在数据应用领域与亚马逊云科技加深合作

数字经济时代&#xff0c;伴随着大数据应用的不断深入&#xff0c;企业对用户及市场发展动向的判断正变得愈加精准。数据资产不再是虚无缥缈的东西&#xff0c;而是可以帮助企业切切实实找到业务增长点&#xff0c;洞悉潜在商机&#xff0c;拥有巨大潜力的“宝藏”。IDC数据显示…
阅读更多...
无需登录复制网站文字的解决方案

无需登录复制网站文字的解决方案

大家好，我是爱编程的喵喵。双985硕士毕业，现担任全栈工程师一职，热衷于将数据思维应用到工作与生活中。从事机器学习以及相关的前后端开发工作。曾在阿里云、科大讯飞、CCF等比赛获得多次Top名次。喜欢通过博客创作的方式对所学的知识进行总结与归纳，不仅形成深入且独到的理…
阅读更多...
基于控制台的购书系统(JAVA基础案例教程-黑马程序员编著-第三章-课后作业)

基于控制台的购书系统(JAVA基础案例教程-黑马程序员编著-第三章-课后作业)

【案例介绍】 案例描述 伴随互联网的蓬勃发展&#xff0c;网络购书系统作为电子商务的一种形式&#xff0c;正以其高效、低成本的优势逐步成为新兴的经营模式&#xff0c;人们已经不再满足互联网的用途仅仅局限于信息的浏览和发布&#xff0c;更渴望着能够充分享受互联网所带来…
阅读更多...
mpls专线与MSTP专线区别在哪里？

mpls专线与MSTP专线区别在哪里？

首先我们要知道什么是MPLS和MSTP&#xff0c;MPLS&#xff1a;“多协议标签交换机制”。是一种数据传输的机制&#xff0c;可以基于多种不同的3层协议来生成2.5层的标签信息&#xff0c;通过为数据包上分配标签交换替代IP转发&#xff0c;这种标签是短而定长、只具有本地意义的…
阅读更多...
代码随想录【Day15】｜102. 二叉树的层序遍历、226. 翻转二叉树、101. 对称二叉树

代码随想录【Day15】｜102. 二叉树的层序遍历、226. 翻转二叉树、101. 对称二叉树

102. 二叉树的层序遍历 题目链接 题目描述&#xff1a; 给你一个二叉树&#xff0c;请你返回其按 层序遍历 得到的节点值。 &#xff08;即逐层地&#xff0c;从左到右访问所有节点&#xff09;。 难点&#xff1a; 思路&#xff1a; 需要借用一个辅助数据结构即队列来实现…
阅读更多...
传输层重要协议之UDP协议和TCP协议详解

传输层重要协议之UDP协议和TCP协议详解

更多关于UDP协议和TCP协议请移步官网&#xff1a;https://www.rfc-editor.org/standards#ISUDP标准协议文档-RFC 768TCP标准协议文档-RFC 793UDP协议详解UDP协议的特点&#xff1a;无连接、不可靠传输、面向数据报和全双工。UDP协议报文结构&#xff1a;关于端口号&#xff1a;…
阅读更多...
Ubuntu系统为程序创建桌面快捷方式

Ubuntu系统为程序创建桌面快捷方式

为了不用每次都要进入命令行启动应用程序&#xff0c;为程序创建快捷方式是一个很方便的方法&#xff0c;尤其是你的程序需要在团队外部使用的时候。桌面创建快捷方式一般使用.desktop为后缀的文件实现&#xff0c;该文件的内容格式基本要素如下&#xff1a;[Desktop Entry] Na…
阅读更多...
Git与IDEA强强联合（HTTPS协议连接）

Git与IDEA强强联合（HTTPS协议连接）

最近在写项目的时候&#xff0c;在台式机和笔记本之间频繁切换&#xff0c;竟然还是用qq传压缩包&#xff0c;我自己都感觉无语&#xff0c;有git这样强大的版本管理工具&#xff0c;我竟然没想起来。然后也没有相关的博文就想来更新一篇。 那么如何使idea和git强强联合呢&…
阅读更多...
果实可采摘点论文汇总

果实可采摘点论文汇总

文章目录2019基于Mask R-CNN的芒果实例分割及采摘点检测研究与实现2021A mango picking vision algorithm on instance segmentation and key point detection from RGB images in an open orchard2022基于深度学习的多品种鲜食葡萄采摘点定位Method for Identifying Litchi Pi…
阅读更多...
webpack(高级)--Prefetch和Preload shimming

webpack(高级)--Prefetch和Preload shimming

webpack Prefetch和Preload webpack v4.6.0 增加了对预获取和预加载的支持 在声明import时 使用下面这些内置指令 来告知浏览器 prefetch(预获取):&#xff1a;将来某些导航下可能需要的资源 preload(预加载)&#xff1a;当前导航下可能需要资源 import(/* webpackChunkName…
阅读更多...
Leetcode详解JAVA版

Leetcode详解JAVA版

目录1. 两数之和14. 最长公共前缀15. 三数之和18. 四数之和19. 删除链表的倒数第 N 个结点21. 合并两个有序链表28. 找出字符串中第一个匹配项的下标36. 有效的数独42. 接雨水43. 字符串相乘45. 跳跃游戏 II53. 最大子数组和54. 螺旋矩阵55. 跳跃游戏62. 不同路径70. 爬楼梯73.…
阅读更多...
Jenkins连接Maven自动化部署构建SpringBoot

Jenkins连接Maven自动化部署构建SpringBoot

目录1.首先下载maven拉取到服务器2.解压maven并进入解压文件修改setting.xml2.拉取jdk18到服务器并解压3.将jdk还有maven移动到jenkins的挂载目录4.进入jenkins容器5.在jenkins的全局配置中配置jdk与maven6.jenkins安装插件 Publish Over SSH7.jenkins服务器创建一个jar包存放目…
阅读更多...
ArcGIS API for JavaScript 4.15系列（6）——Dojo中的事件绑定

ArcGIS API for JavaScript 4.15系列（6）——Dojo中的事件绑定

1、前言 在Web界面中&#xff0c;用户点击按钮、选择下拉选项、移动鼠标都涉及到dom元素的事件机制。下面就来介绍一下Dojo中的事件绑定操作。 2、dojo/on模块绑定事件 我们就从最简单的按钮click事件入手&#xff0c;Dojo中的dojo/on模块可以实现dom元素的事件绑定&#xf…
阅读更多...
高性能办公娱乐迷你主机——Maxtang大唐AMD5600U

高性能办公娱乐迷你主机——Maxtang大唐AMD5600U

今天给大家介绍一款AMD5600U迷你主机&#xff0c;说起这款处理器大家应该并不陌生&#xff0c;像联想小新、YOGA以及ThinkBook等很多款用的都是这个型号&#xff0c;不过笔记本的价格基本都在3999-4999这个价位区间&#xff0c;同样的处理器&#xff0c;笔记本卖那么贵&#xf…
阅读更多...
内网渗透(二十八)之Windows协议认证和密码抓取-Windows RDP凭证的抓取和密码破解

内网渗透(二十八)之Windows协议认证和密码抓取-Windows RDP凭证的抓取和密码破解

系列文章第一章节之基础知识篇 内网渗透(一)之基础知识-内网渗透介绍和概述 内网渗透(二)之基础知识-工作组介绍 内网渗透(三)之基础知识-域环境的介绍和优点 内网渗透(四)之基础知识-搭建域环境 内网渗透(五)之基础知识-Active Directory活动目录介绍和使用 内网渗透(六)之基…
阅读更多...
帮公司面试了一个30岁培训班出来的程序员，没啥工作经验...

帮公司面试了一个30岁培训班出来的程序员，没啥工作经验...

首先&#xff0c;我说一句&#xff1a;培训出来的&#xff0c;优秀学员大有人在&#xff0c;我不希望因为带着培训的标签而无法达到用人单位和候选人的双向匹配&#xff0c;是非常遗憾的事情。 最近&#xff0c;在网上看到这样一个留言&#xff0c;引发了程序员这个圈子不少的…
阅读更多...
Python程序设计-第5章Python面向对象

Python程序设计-第5章Python面向对象

第5章Python面向对象一.预习笔记 1.类的相关概念 类的定义&#xff0c;类对象&#xff0c;实例对象&#xff0c;类属性 类属性是跟类绑定的&#xff0c;如果要修改类的属性就必须使用类对象访问&#xff0c;只使用实例对象是无法修改的。 权限访问&#xff1a;name与age是公…
阅读更多...
【每日随笔】手指训练 ( 产品需求探索、技术无关 | 手指训练作用 | 哪些人需要手指训练 | 手指操 | 手指康复训练器材 )

【每日随笔】手指训练 ( 产品需求探索、技术无关 | 手指训练作用 | 哪些人需要手指训练 | 手指操 | 手指康复训练器材 )

文章目录一、手指训练作用二、哪些人需要手指训练三、手指操四、手指康复训练器材产品需求探索 , 研究下手指训练的市场 , 前景 , 是否可以开发 ; 一、手指训练作用 手指训练作用 : 改善 上肢协调性手眼 协调性训练提高 手指 抓握 能力提高 手指 灵活性提高 上肢运动 准确性 和…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023