TraceofLight (ZH)

2026 年团结路演的收获

Sun, 19 Apr 2026 13:17:51 GMT

内存基础知识

基本内容

我们使用虚拟内存 (Virtual Memory, 以下 VM)、不直接控制物理内存
VM 由页面构成，根据操作系统不同可能有差异
- Window / Linux 4kb
- iOS, macOS, Android 16kb
与页面对应的物理内存帧存在
根据内存压力等级，把虚拟内存合并到物理内存

Page Fault

当需要的页面没有加载在物理内存中时被称为 Page Fault

Clean Page: 原始数据未变化的页面，OS 可以随时释放，回收容易
Dirty Page: 应用程序新写入或修改后信息的页面，无法直接从内存退出

Memory Footprint

表达实际内存压力的指标，是把所有 dirty page 大小相加的结果

Memory Footprint != 物理内存使用量、常驻内存使用量

内存管理方法 (Windows vs Linux)

预约: 不使用物理内存、只分配虚拟内存
提交: 分配与实际虚拟内存等量的物理帧
取消提交: 保留预约空间的同时释放物理帧

Windows: 提供显式 API (virtual alloc, virtual free)

UNIX Like: 预约和提交没有显式分离

mmap 调用是隐式预约内存

直接访问页面时会发生延迟提交

没有显式 API、取消提交以提示形式工作

OS 决定何时回收页面

Unity GC 中的处理

Managed Heap

C# 内存分配全部在这里进行
由 Garbage Collector 管理
在 Unity Profiler 中显示为 GC.Alloc

Garbage Collector

定期从 Heap 中回收没有有效引用的 Object
执行 GC 也不会减少虚拟内存的总使用量
已回收的对象空间，从 OS 角度也是 Dirty

Segment

把连续的页面集合定义为 Segment

Managed Heap 使用的是 Segment、不是 Raw Page
一个 Segment 中可能分配多个 Object
把它分配后再释放，内部即使有未使用的状态，也会显示为 RAM 使用 (因为是 Dirty)
大多数情况完全没有问题、并且会很快被复用
太久空着的情况会浪费常驻内存，所以 Unity GC 间歇性地处理

Unity GC 所做的工作

使用 remap 战略
在 GC 多次执行之后，对 Old Empty Segment 执行 Drop、然后分配同样大小的 New Segment
Windows Remap 战略: 不释放 Segment、仅 Decommit (因为可以显式处理)
UNIX Like Remap 战略: 通过 munmap & mmap 实现 Remap (Hot Page 效果使缓存命中率高)
通过这种方式可以减少常驻内存的使用，是优点

不应反复执行 GC.Collect 的理由

不要强行执行 segment release
Collect 的开销大、可能导致应用冻结
它本身的意图是 decommit 长时间空闲的 segment
短暂空着的 segment decommit 与意图不符
强制 decommit 不会带来性能改善、只会产生 CPU 成本
- 反正下一帧就会被复用的 segment 也会被 decommit

Managed Heap 的 VM 使用量只增不减

Heap 只会增大、不会缩小
Boehm GC 本来的特性
没有理由 Trim 虚拟内存的分配量
- 大的虚拟内存 != 大的物理内存使用量
- Segment 反正会被复用
- 游戏对象每帧都频繁创建和销毁
- 每次对象销毁就缩小 segment、只会浪费 CPU 性能

Unity Boehm GC

Unity 的 Incremental Boehm GC 是保守 GC (Conservative GC)
这是因为 Unity 提供了用于把过去写的 C# 代码转换为 C++ 的 IL2CPP，从那时起开始主要被使用
- 通过 IL2CPP 可以支持各种环境，但与 C# 不同，内存 GC 不会自动化，所以采用了开源 GC Boehm GC 看起来如此
以稳定性为中心而不是性能，把所有看起来像指针的值都视为引用
在 GC 期间不改变对象的位置 -> 没有 Compaction、容易出现内存碎片

关于 Compaction

有利于解决内存碎片的内存压缩工作。把所有未使用的空间清空并重新排列

由于需要精确的引用信息、保守的 GC 中无法实现

移动对象的位置会产生成本 (Stop The World + 实际移动)

CoreCLR GC

CoreCLR GC 是 Precise GC、是准确知道内存栈和寄存器中哪些值是引用的方式的 GC

而 .NET 把 CoreCLR 作为核心引擎使用 (CLR: Common Language Runtime)

CoreCLR 支持的内容

CoreCLR GC

JIT 编译器

Excecption Control

misc...

该 CoreCLR GC (以下 .NET GC) 使用基于代际的内存管理方式

把 Heap 分为 3 代来管理
Gen 0: 主要包含刚创建的新对象、频繁且快速的 GC 在这里发生 (大多数对象都在这里消亡)
Gen 1: 在 Gen 0 中存活下来的对象转移到这里、起 Buffer 作用
Gen 2: 长期存活的较重的对象所在的位置、GC 整理这里的成本相对较大
LOH: 非常大的对象会放到这个空间

在晋升过程中处理 memory Compaction、可以减少碎片化

LOH 由于 STW 较长，过去不进行 Compaction、但现在以显式选项化方式进行处理

转换的价值？

基本上 Unity 转向 .NET 时发生的副作用是 GC 改变、并且强调 GC 不是主要内容。但寻找其价值的话…

支持 Compaction、可以减少内存碎片化
可以让 GC 成本变得可预测

关于容器环境的简要说明

Thu, 02 Apr 2026 06:58:20 GMT

容器的工作原理

共享主机操作系统的内核，但像进程一样隔离它

内核不兼容怎么办？

当然无法运行，但它之所以能在 MAC、WINDOW 等操作系统上运行，是因为它增加了一层额外的虚拟机。

为什么在 Windows 上安装 docker desktop 会告诉你要安装 wsl2？这似乎是因为你需要安装 MS 的 Linux 虚拟机才能让这个基于层的容器运行。

即使问题出在内核版本上，它也会崩溃（试图使用因版本差异而不存在的功能等）。

结论。

内核类型必须匹配，功能支持必须没有问题，CPU 架构必须匹配，容器才能运行。

虚拟机

带有管理程序的独立系统，使用单独的内核。有裸机/托管之分，我们使用的主要是托管，由于管理程序位于操作系统之上，因此会有性能损失。

卷绑定

用于确保数据的持久性，通过在主机上挂载特定目录来处理。Linux 本机直接写入 VFS，其他操作系统烧录内部虚拟网络，速度可能相对较慢。

为什么 Windows 会忽略 chmod

Windows 使用 ACL（访问控制列表）管理权限，不了解 chmod 如何工作。

来自卡夫顿丛林游戏技术实验室的感言

Thu, 26 Mar 2026 18:02:12 GMT

in

完成课程后，我推迟了大约半年才开始真正的生活，所以我有点担心何时写这篇评论。

不过，我想在我的记忆变得有点模糊之前，我应该把它写下来，所以就写在这里了。

我还在上面的媒体中加入了演讲的重播，因为我相信读到这篇文章的人一定还在回味。

口腔和口腔前的忧虑

首先，我不知道自己是否想直接上牙科学校。我对 2025 年下半年的工作有很多计划。

但是，我选择了入学，因为我觉得这些计划一般都没有结果，而我有一个相当不错的选择。

我有几次面试都不太顺利，所以我一直在想如何弥补自己经验上的不足。

我以前从未接触过市面上的实时 3D 引擎，因此无法解释其整体功能，更不用说内部逻辑了。

因此，当我带着从与人工智能斗争中获得的所有知识站在面试官面前时，我只能做出肤浅的解释。

现在回想起来，面试官听到这些答案时一定会怎么想，我觉得非常尴尬。

当时，我认为参加课程有两方面的风险。

我不知道课程是什么样的，也不知道结果会怎样，因为我之前只参加过一次课程，而且还没有完成。

第二个风险是我不得不放弃这个课程，因为我感兴趣的游戏公司通常在下半年招聘实习生。

权衡再三之后，我决定留在系里。现在回想起来，我觉得我参加的信息交流会影响很大。

丛林课程中有一个游戏实验室，所以我一直在考虑是否要选修这门课程，如果要选修，又应该报考哪门课程。

关于课程

我不确定课程的结果如何，但到目前为止，我对这次经历非常满意。

我不会太详细地介绍我们在课程中做的事情和遇到的情况，因为用教练的话来说，这会 "扫了丛林战士的兴"。

不过，我可以告诉大家，TechLab 并不是一个简单的过程。几乎不可能同时兼顾其他任务，而且整个课程期间教室里很少熄灯。

不过，可以肯定地说，在离开课程时，您将掌握大量的知识，并对商用实时 3D 引擎有深刻的了解。

谁应该参加？

带一份演示文稿可能是最直观的做法。

我觉得想更多了解这些事情的人应该来。你会有更多的了解。

我知道我说过我不会涉及这些，但对这里的一些图形和开发环境感到好奇的人应该考虑参加技术实验室。

上完课之后，你至少能背诵农历，还能分享关于它们的简单提卡。

最后的想法

现在我已经完成了课程，我很高兴我完成了课程，但我还有很多事情需要在未来安排，因为我在这么短的时间内经历了很多事情。

不过，在消化了所有内容之后，我想我将成为一名更加成熟的开发人员。

很多人都在谈论人工智能的发展会导致行业劳动力的萎缩，但我会尽我所能。

最近也有很多关于成长气馁的议论，但我肯定看到了我周围的人不断成长的好事，所以我认为我们将能在一段时间内保持这种势头。

构建 Windows / macOS 统一终端环境

Thu, 26 Mar 2026 12:18:01 GMT

前言

由于最近升级了MacBook Air，我感到有必要重新配置系统环境。

虽然从M1到M5的性能提升令人满意，但在尝试恢复原有使用环境时，我发现这需要花费大量精力，因此决定借此机会将整个过程记录下来，以便日后能更轻松地进行配置。

[2026 Mac 终端完美配置（Ghostty + Starship + AI 编程环境）](https://blog.dnd.ac/settings-mac-terminal-2026/

)

在这个过程中，给我留下深刻印象的文档就是该链接中的资料，作者将整洁且精心配置的环境以脚本形式留存下来，对我帮助很大。

先说结论，最终我成功构建了如下形式的终端环境：

。其内部架构主要基于 Wezterm + Nushell + LazyVim 进行配置。

您可以在 [Github 链接](https://www.github.com/TraceofLight/global-terminal-settings

) 中查看完整的配置指南，该指南旨在帮助您在 Windows 和 MacOS 上构建完全一致的环境。

目标设定

该项目的目标非常明确：

在 Windows / MacOS 上使用相同的终端环境
基于 LazyVim 的编辑器能够无障碍运行
与现有使用环境差异不大
使用 tmux 等多窗口管理工具时

不会遇到困难为了实现这些目标，我着手进行了相关工作。

实施过程

首先需要选择技术方案。目前终端模拟器的趋势是具备GPU加速渲染能力的GUI工具，这类工具之所以备受青睐，正是因为其运行速度快且支持自定义主题。正如上文链接所示，构建终端环境需要这些特性，因此我最终选择了其中的Wezterm。

终端模拟器

由于需要在跨平台环境下提供一致的用户体验，我认为具备成熟生态系统的跨平台终端模拟器主要有Alacritty和Wezterm。追求极简风格的Alacritty在扩展性上略显不足，因此最终选择了Wezterm。它内置多路复用器也是一大优势。
Shell

为了确保在两个平台上提供一致的使用体验，我最初计划统一使用支持 Unix 命令的环境，因此决定在 Windows 上使用 bash，在 macOS 上使用 zsh。但随后遇到了一些问题，最终方案是基于 Nushell 进行统一。
LazyVim

实际上，这部分我原本就已使用相关工具，且在大部分环境下都能无缝集成，因此并不困难。虽然原本使用的是SpaceVim，但该工具已[停止维护](https://wsdjeg.net/why-spacevim-is-archived/

)，且我转用LazyVim已有段时间。加上我主要使用IDE，LazyVim仅作为辅助工具，因此安装过程相当顺利。

遇到的问题

在此过程中存在几个问题，其中两个都与转用Nushell有关。

在 Windows 上，bash 的运行速度慢得令人难以忍受

事实上，后来确认这似乎是意料之中的结果。我发现，在 Windows 环境下，为了处理 POSIX 风格的操作，系统会额外增加一层兼容性处理机制。因此，虽然也曾考虑过切换到 WSL2 环境，但那最终与直接使用 Linux 并无二致，所以被排除在外。

-> 为解决这一问题，引入了 nushell 作为工具。考虑到了它与 Unix 命令有大量兼容之处、基于 Rust 设计因此在性能上有所保障，以及在 macOS 上也能进行相同的环境配置。
Windows 版 nushell 中 navi 插件无法运行

navi是一款用于参考终端命令速查表的插件。虽然使用频率不高，但如果该工具的功能完全无法运行会带来不便，因此我们尝试了多种解决方法。最终，我们通过分叉navi来解决该问题，并改用重新构建的插件。
- 原因：即使用户shell发生变更，内部仍会应用基于bash的语法，导致在使用nushell时出现故障
- 解决方案：不再通过 shellscript 命令处理该部分，而是通过以下方式移除相关依赖：在原本需要使用 wget 的地方改用 Rust HTTP 客户端，在原本需要使用 bash 的地方改用 pwsh，以此消除内部辅助程序对 bash 的依赖
- [详细修改记录](https://github.com/TraceofLight/navi/tree/fix/nushell-usability

)

结论

开发人员使用终端的频率相当高，如果环境能够统一，使用起来自然会更方便。因此，支持跨平台且保持一致使用体验的 JetBrains IDE 难道不具有优势吗？同样地，如果自己在终端方面追求的是在各种环境下保持统一的使用体验，那么尝试这种方式似乎也不错。

std::variant & std::visit

Mon, 28 Jul 2025 14:13:37 GMT

其他信息

)

上述链接中介绍了从 C++17 开始新增的 Variant 及其添加原因。简而言之，由于 Boost 库中相关功能已被使用太久，因此有人提议不要再拖延，应尽快将其纳入标准，将其作为 std::optional 引入。

内部结构

1. Variant

数据缓冲区用于存储模板参数中最大类型所需的足够大内存空间，通常通过 Union 实现
标识符用于表示当前数据缓冲区中存储了何种类型的对象的索引或标识符。通过使用该标识符，std::variant 能够保证类型安全性

凭借充足的内存空间，variant 类型能够实现如下行为。


	struct Tracer
	{
		std::string name;

		Tracer(const std::string& n) : name(n)
		{
			std::cout << "  [+] '" << name << "' Tracer created (Constructor)\n";
		}

		// Copy Constructor
		Tracer(const Tracer& other) : name(other.name)
		{
			std::cout << "  [*] '" << name << "' Tracer copy-constructed (Copy Constructor)\n";
		}

		~Tracer()
		{
			std::cout << "  [-] '" << name << "' Tracer destroyed (Destructor)\n";
		}
	};

	// 1. Initialize the variant with a Tracer type.
	std::cout << "1. Initializing variant with Tracer(\"Apple\").\n";
	std::variant<int, Tracer> var = Tracer("Apple");
	std::cout << "   Variant now holds Tracer(\"Apple\").\n\n";

	// 2. Assign a value of a different type (int).
	std::cout << "2. Assigning integer 100 to the variant.\n";
	var = 100;
	std::cout << "   Variant now holds integer 100.\n\n";

	// 3. Assign another Tracer type value again.
	std::cout << "3. Assigning Tracer(\"Banana\") to the variant.\n";
	var = Tracer("Banana");
	std::cout << "   Variant now holds Tracer(\"Banana\").\n\n";

	std::cout << "4. main function is about to end.\n";
	return 0;

执行此类代码将得到如下结果。

1. Initializing variant with Tracer("Apple").
  [+] 'Apple' Tracer created (Constructor)
  [*] 'Apple' Tracer copy-constructed (Copy Constructor)
  [-] 'Apple' Tracer destroyed (Destructor)
   Variant now holds Tracer("Apple").

2. Assigning integer 100 to the variant.
  [-] 'Apple' Tracer destroyed (Destructor)
   Variant now holds integer 100.

3. Assigning Tracer("Banana") to the variant.
  [+] 'Banana' Tracer created (Constructor)
  [*] 'Banana' Tracer copy-constructed (Copy Constructor)
  [-] 'Banana' Tracer destroyed (Destructor)
   Variant now holds Tracer("Banana").

4. main function is about to end.
  [-] 'Banana' Tracer destroyed (Destructor)

可以观察到，先调用原有值的析构函数，随后在栈上创建临时对象，最后将复制生成的值移入自身内存缓冲区。

因此，如果内部通过联合体（union）保留存储最大尺寸类的空间，无论variant类型中传入什么，都能确保其正常使用！

2. 访问机制

虽然不同库的实现各异，

函数指针表
Switch 语句

但通常可分为这两种形式。实际上，除了实现方式、开销以及编译器优化方面存在些许差异外，基本都可以理解为：通过检查标识符，根据激活的类型调用相应的函数。

[钟曼手册] 02.故障排除策略

Wed, 18 Dec 2024 04:27:16 GMT

故障排除过程

阅读并理解问题。
用熟悉的术语重新定义问题。
计划如何解决问题。
验证你的计划。
将其作为一项计划加以实施。
反思你是如何解决问题的，并寻找改进方法。

1) 阅读并理解问题

为了避免犯误读问题的错误，你应该积极阅读问题，并努力充分理解问题的要求。如果你错过了一个小的限制条件，往往就无法解决这个问题，而竞赛往往不会放过任何一个小错误。

2) 重新定义和抽象

使用你容易处理的概念，用你自己的语言重新表述问题，这是直观理解问题对你的要求所必需的，问题越复杂，这一点就越重要。对于做同样事情的程序，不同的人可能会有不同的理解，这取决于你如何重构问题的本质。可以说，抽象化决定了程序的发展方向，因为它可以让难题变得更容易解决，让容易解决的难题变得更难解决。

抽象：将现实世界的概念转化为我们更容易处理的数学/计算概念的过程。

3) 规划

决定如何解决问题，选择要使用的算法和数据结构。这是整个过程中最重要的部分，如果你不能立即找到问题的解决方案，你将在这部分花费最多的时间。

4) 验证你的计划

在开始实施之前，我们需要验证我们的计划。我们需要证明，我们设计的算法在所有情况下都能正确执行要求，并且执行所需的时间和使用的内存都在问题的限制范围内。

5) 实施计划

在执行计划时，要始终牢记效率和准确性。

6) 进行回顾总结

这一步可能不会立即产生直接影响，但从长远来看影响最大。当你重新解决以前解决过的问题时，你可能会找到更高效的算法，写出更简洁的代码，甚至找到更直观的方法来推导相同的算法。进行回顾的最有效方法是写下每次解决问题的经验。

记录下你的方法、关键的顿悟、错误答案的原因等，可以减少错误，有助于形成模式。查看其他人解决过的代码也能提供你可能没有想到的见解。

一段时间后，即使你还没有解决它，也可以参考其他人的代码或解决方案，但一定要回顾它。

疑难解答策略

1) 直觉和系统方法

你以前解决过类似的问题吗？
- 你应该能够理解和转换原理，而不仅仅是解决原理。
你能从简单的方法入手吗？
- 能在不知道的情况下求解吗？还有一种方法，可以从最简单的算法入手，并对其进行优化，从而实现
- 能否建立算法效率基线？
能否制定解决问题的过程？
- 在解题过程中举例说明，等等。
我能简化问题吗？
- 先解决给定问题的一个较容易的变式
能否举例说明？
- 几何图形更直观易懂
能否用公式表示？
- 纯文本 → 公式有助于解决问题
问题能否分解？
- 如何将问题转化为更易解决的形式，如分解约束条件
能否通过逆向思维解决问题？
- 典型例子：梯子游戏
- 你能从下往上而不是尝试前面的所有路径来减少阶梯的数量吗？
能否强制执行顺序？
- 如何在没有顺序的问题中执行顺序？
- 举例说明：对一个变量而言，是否存在两种情况/顺序无关紧要 → 决定是否按顺序变换。
能否只考虑某些形式的答案？
- 规范化技术
- 如何将形式不同但结果相同的答案分组，并只考虑组中的代表。

[有效 C++] 项目 02

Tue, 12 Mar 2024 14:40:14 GMT

优先选择 Const、枚举和 Inline，而不是 #define

表示编译器优于预处理

#define FOO 1.024

上述情况是预处理器在编译前替换字符串。
上述符号 FOO 可以在编译器不知道其存在的情况下被移除，因此它可能在错误中作为常量出现，所以如果存在与此相关的 bug，追查起来会很费时间。

const double FOO = 1.024；

解决方法是用常量替换宏。
编译器可以清楚地观察到常量，也可以清楚地在符号表中输入常量。此外，如果通过预处理器进行批量替换，可能会创建多个对象副本，但如果是常量，创建的副本不会超过一个。

[有效 C++] 项目 01

Tue, 12 Mar 2024 14:01:04 GMT

C++ 是多范式编程语言

最初是从加入面向对象功能的 C 开始的
目前支持过程式、面向对象、函数式、泛型乃至元编程

泛型编程: 不受数据类型束缚、让一个值可以拥有多种数据类型从而最大化复用性的编程范式

元编程: 把自身或其他程序作为数据来对待并编写、修改程序的方式。也指把运行时需要执行的部分工作放到编译期完成的方式

需要把 C++ 看作不是一门单独的语言、而是语言的联合体，并按照各自的规则去使用
- C: 很多东西源自 C，但 C++ 提供更好方案的情况很多，所以可以在更受限且更安全的范围内使用
- 面向对象 C++: 类存在的 C++ 核心，是面向对象设计最直接作用的部分
- Template C++: 不是经常接触的部分，与主流 C++ 几乎不相互作用，但催生了 TMP 这种强大的范式
- STL: 虽然是 Template 库但属于非常特殊的情况，使用 STL 时有特定的方式，必须遵循其规则
一旦在上述子语言之间切换，可能会面临要改变策略的情况
如果理解 C++ 不是单一规则、而是各自拥有专属规则的子语言的集合体，就会更容易理解 C++

[有效 C++] 进入

Tue, 12 Mar 2024 12:45:19 GMT

好久没发学习相关的帖子了。

我还没有全部誊写，但我目前在一家公司从事系统开发工作，在与我写及格推荐信的公司进行比较后，我认为这家公司会更好。

公司里有人说要学习这本书，所以我觉得在学习的同时利用现有的平台也不错，我会继续写下去。我想通过对这本书的学习，把工作做得更好，但感觉还有点遗憾，因为这本书离我还很远......

我将为每个项目发布一篇文章。화이팅！

42Seoul 拉菲辛体验分享

Sat, 23 Sep 2023 17:19:05 GMT

前言

在求职过程中，今年年中SSAFY即将结束之际，出于对备考周期可能延长的不确定性，我在向企业投递简历的同时，也花时间了解了各种编程训练营和培训课程。

最终，我认为最适合我的课程是42Seoul，于是决定报名参加。

虽然理由有很多，但其中最吸引我的是：相比其他编程训练营，它更注重自主学习且时间安排灵活，并且主要涉及相对底层的编程语言。

拉菲辛课程进行中

在完成报到并成功申请拉菲辛课程后，我一边等待课程开始，一边收到了几家企业的最终录用通知。原本打算放弃课程，但考虑到在职42学员的经验分享以及42的教学体系，我认为完全可以兼顾，于是初期全力投入，之后便开始边工作边学习。

了解过42课程的人应该都知道，入学前有一段被称为“拉菲辛”的预备课程。这段课程相当严苛……

如果是非专业背景且毫无基础的人，恐怕连跟上进度都会很吃力；而对于具备一定编程知识的非专业人士，只要努力的话，应该能取得预期的成果。至于专业背景的人，只要不是因为其他原因无法集中精力，或者没有遭遇不公对待，我认为进入正式课程应该并不困难。

虽然只是个人看法，但我认为42提供的教育与大学课程有相当大的相似性，因此对非专业背景的人来说可能反而更好。如果已经在大学里系统地学过相关课程，那么对专业背景的人来说，除了42提供的助学金和其他制度外，其优势似乎比其他编程训练营相对不足。

我之所以考虑入学，除了资助金之外，还因为认为这是一个能弥补专业知识缺失的优质课程；而且这一基本前提在就业后也没有改变，所以我才能坚持完成拉菲辛课程。

（当然，就业后就无法再领取资助金了……）

结果

幸运的是，我取得了好成绩，得以作为42Seoul第10期学员参加本课程。由于课程使用的技术栈与我目前在公司负责的岗位相似，预计能形成良性循环，对此我充满期待。

问答

针对大家常问的一些问题，我来回答一下：

1. 零基础的非专业背景者能通过吗？

虽然早期批次可能有例外，但现在可以重新挑战，而且随着信息的大量公开，几乎是不可能的

2. 你会向什么样的人推荐这个课程？

还有大量本科学习时间的专业学生，以及不考虑就业、打算长期积累基础知识的非专业人士。

3. 报名前最好了解哪些内容？

了解C语言的基础概念以及初次接触时可能难以理解的指针等知识，知道得越多越好。虽然大家都强调Shell的使用方法，但我还想补充一条建议：务必掌握Git的使用方法。

4. 在课程进行过程中，有什么特别想让大家尝试的吗？

就我个人而言，第一届Rush的团队成员都是非常棒的人，作为和他们一起坚持到最后的成员，虽然与他人交流并非绝对必要，但如果机会来了，请务必把握住并积极融入……对于开发者来说，沟通能力与编程能力同样重要！

[术语表] 文件系统

Thu, 14 Sep 2023 14:36:39 GMT

在

我意识到，在我目前的工作中，我对基础术语的了解还有些欠缺，因此我决定做一点研究，并将我所知道的术语做一个简要总结。

文件描述符

在 Linux 和类 Unix 系统中进程处理文件时使用的一种类型的值

当进程打开一个文件时，内核会为其分配处理器文件描述符编号中最小的未使用值，以便后续使用系统调用访问打开的文件时可以使用描述符值来引用该文件。

默认分配的描述符

标准输入（标准输入）标准输出标准错误

Inode

索引节点的简称，是快速定位文件的节点。

Inode 是一个节点，它为 Linux 中的所有文件编制索引，并保存这些文件的元数据。Inode 保存着 list 命令输出的元数据。

符号链接

带有指向源文件 inode 信息的文件。

在内部，通过 inode 号访问文件
有一个新的 inode，其中不包含任何有关原始文件的信息

cf) 硬链接

具有新 inode 的文件，而不是具有新 inode 的文件，只是逐字复制了 inode
与真正拷贝的区别在于没有写入额外的数据，与复制不同

块设备和字符设备

根据数据传输方法的不同对设备进行分类
块：以块或扇区等量化单位传输数据，IO 传输速度快
字符：以字节为单位传输数据，IO 传输速度可能稍慢，但通过应用阶段的缓冲控制，性能会有差异。

###原始设备

未设置文件系统的设备

操作系统内核没有缓冲，数据直接从设备传输，如果设备有自己的缓存系统，则使用此方法
磁盘 IO 性能好，CPU 开销低。
避免操作系统文件系统开销，并可减少操作系统缓冲区大小。
作为原始设备使用，因为在系统中配置为共享磁盘时，无法进行并发访问。

IO 调度器

系统中负责排序、合并和确定请求处理顺序的部分，以提高磁盘 I/O 效率。

对硬盘等设备特别有用，因为在这些设备上，寻道时间很昂贵，合并同一位置的请求很有效；在固态硬盘上，效率减半。
类型
- noop：无操作，用于高性能磁盘
- cfq （完全公平队列）：给每个进程一个 IO 队列，并尽可能均匀地调度，用于大量进程产生细粒度 IO 的情况
- deadline：优先处理更接近阈值的进程，优化延迟，平衡所有 I/O，适用于少数进程产生大量 I/O 的环境。
- 预期性：预测未来 I/O 请求的位置，并优先处理最近的 I/O 请求；传统硬盘采用的结构是输入和输出汇总，可能会增加延迟。

[日本银行 9519，中国人民银行]昏昏欲睡

Mon, 04 Sep 2023 14:32:38 GMT

问题链接

boj 9519

分类

实现, 字符串, 模拟

描述

这个问题最初是通过全面探索解决的。

首先测量字符串的长度
分配一个与字符串长度相等的数字向量
根据问题条件重复并翻转
如果翻转了一定次数，则使用相应的哈希值将它们按相反顺序排列
你将看到原始图像！

这里最重要的一点是，你可以根据问题的条件反复翻转，而循环返回的结果将始终与初始数组相同。

找到上述规则后，你可以使用

先测量字符串的长度
0 ~ 指定一个与字符串长度相等的数字向量
- 检查从 1 到（字符串长度 - 1）的循环次数
- 重复翻转总次数除以循环次数，得出哈希值
如果翻转了一定次数，则使用该散列值按相反顺序排列
你可以看到原始图像！

看起来像这样

    for (int i = 1; i <= target_length - 1; i++)
    {
        for (int j = 0; j < target_length / 2; j++)
        {
            temp = result.back();
            result.pop_back();
            result.insert(result.begin() + 2 * j + 1, temp);
        }

		if (start_vector == result)
		{
			cycle = i;
			break ;
		}
    }

起初，我们如上图所示直接移动数组，但这造成了一些开销，因为插入后的数组也要移动，所以花费的时间稍长。

    for (int i = 1; i <= target_length - 1; i++)
    {
		temp_vector.clear();
		temp_vector.resize(target_length);
        for (int j = 0; j < target_length; j++)
        {
			if (!(j % 2))
				temp_vector[j] = result[j / 2];
			else
				temp_vector[j] = result[target_length - 1 - (j / 2)];
        }

		if (start_vector == temp_vector)
		{
			cycle = i;
			break ;
		}
		else
			result = temp_vector;
    }

因此，我们使用上述方法提前创建数组，然后逐个插入数值，这样时间只用在数组的最大长度上。

求解代码

// 졸려

#include <iostream>
#include <vector>

using namespace std;

vector<int> flicker_action(int target_length, int count);

int main(void)
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    int flicker_number;
    string result_string, init_string;
    vector<char> string_vector;
    vector<int> idx_vector;

    cin >> flicker_number;
    cin.ignore();
    getline(cin, result_string);

    for (int i = 0; i < (int) result_string.length(); i++)
        string_vector.push_back(result_string[i]);
    

    idx_vector = flicker_action(result_string.length(), flicker_number);
    init_string.resize(result_string.length());

    for (int i = 0; i < (int) result_string.length(); i++)
        init_string[idx_vector[i]] = result_string[i];

    cout << init_string << endl;
    return (0);
}

vector<int> flicker_action(int target_length, int count)
{
    vector<int> result, temp_vector, start_vector;
	int cycle;

    for (int i = 0; i < target_length; i++)
        result.push_back(i);

	start_vector = result;
	cycle = 1;

    for (int i = 1; i <= target_length - 1; i++)
    {
		temp_vector.clear();
		temp_vector.resize(target_length);
        for (int j = 0; j < target_length; j++)
        {
			if (!(j % 2))
				temp_vector[j] = result[j / 2];
			else
				temp_vector[j] = result[target_length - 1 - (j / 2)];
        }

		if (start_vector == temp_vector)
		{
			cycle = i;
			break ;
		}
		else
			result = temp_vector;
    }

	result = start_vector;

    for (int i = 0; i < (count % cycle); i++)
    {
		temp_vector.clear();
		temp_vector.resize(target_length);
        for (int j = 0; j < target_length; j++)
        {
			if (!(j % 2))
				temp_vector[j] = result[j / 2];
			else
				temp_vector[j] = result[target_length - 1 - (j / 2)];
        }

		result = temp_vector;
    }

    return (result);
}

[BOJ 4821，CPP] Page counting

Sat, 26 Aug 2023 15:04:16 GMT

问题链接

boj 4821

分类

实现, 字符串, 解析

包括

我最近加入了一家新公司，工作相当繁忙。作为一名新员工，刚进公司就感觉压力很大......不过，我一直在写下各种故事，相信迟早会讲出来的。

最近，我有一个学习 C 语言的好机会，每当学习 Python 或 Java 遇到时间墙时，我总是很失望，所以我想借此机会用 C++ 解决问题。

从我使用 C++ 的短暂经历来看，我有一种很好的感觉，那就是它的很多实现都相当繁琐，但速度却能弥补这一点。一旦我掌握了它的诀窍，是否就能利用它的速度优势......？我很期待。

说明。

向量：动态数组结构，类似于数组，但最大的优点是大小可以灵活改变，内存分配是自动的！

npos：无位置，当位置无效时检查索引值。

stringstream: 将字符串视为流的设备，允许将其视为输入和输出，常用于解析

基本逻辑是创建一个可以覆盖整个页面限制范围的 bool 数组，然后检查所有输入的页面范围，最后输出计数值。

不过，值得注意的是，问题中给出的数值范围可能超出 int 值，因此需要设置一个变量来控制，而且如果给出的范围顺序相反，也有不检查的例外情况。

这在 Python 中相当容易实现，但当我尝试用 C++ 实现时，代码变得非常长...

解决方案代码

// 페이지 세기

#include <iostream>
#include <vector>
#include <sstream>

using namespace std;

int main(void)
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);

	int				total_page, seperator, start, end, result;
	string			temp, each_range;
	vector<string>	line_info;
	vector<bool>	print_info;
	vector<int>		result_vector;

	while (true)
	{
		cin >> total_page;

		if (!total_page)
			break ;
		else
		{
			print_info.assign(1001, false);
			cin.ignore();
			getline(cin, temp);
			stringstream range_stream(temp);

			while (getline(range_stream, each_range, ','))
			{
				if (each_range.find('-') == string::npos)
				{
					if (each_range.length() < 5 && stoi(each_range) <= 1000)
						print_info[stoi(each_range)] = true;
				}
				else
				{
					seperator = each_range.find('-');
					if (each_range.substr(0, seperator).length() < 5
						&& stoi(each_range.substr(0, seperator)) <= 1000)
						start = stoi(each_range.substr(0, seperator));
					else
						start = 1001;
					if (each_range.substr(seperator + 1, each_range.size()).length() < 5 
						&& stoi(each_range.substr(seperator + 1, each_range.size())) <= 1000)
						end = stoi(each_range.substr(seperator + 1, each_range.size()));
					else
						end = 1001;
					if (start <= end)
					{
						for (int i = start; i <= end; i++)
						{
							if (i <= total_page)
								print_info[i] = true;
						}
					}
				}
			}

			result = 0;
			for (int i = 1; i <= total_page; i++)
			{
				if (print_info[i])
					result++;
			}
			result_vector.push_back(result);
		}
	}

	for (int i = 0; i < (int) result_vector.size(); i++)
		cout << result_vector[i] << endl;

	return (0);
}

零散的Shell记录 (3)

Tue, 25 Jul 2023 18:05:52 GMT

23-07-26 修正错误内容

23-07-27 添加命令

BC

Basic Calculator的缩写，是根据POSIX标准提供的、可在Unix系统上使用的计算器。

其特点包括：

采用栈式结构
支持逆波兰表示法 (Reverse Polish notation)

echo '2 + 3' | dc
dc <<< '2 3 + p'

TR

用于字符转换、删除、压缩等的命令。通常通过管道与其他处理步骤结合使用

*tr [문자열1] [문자열2]

：使用两个长度相同的字符串，通常将字符串1中对应位置的字符替换为字符串2中相同索引位置的字符。

：使用两个长度相同的字符串，通常将字符串1中对应位置的字符替换为字符串2中相同索引位置的字符。
-c：用第二个字符串的最后一个字符替换所有不在该字符串中的字符
-s：移除所有重复出现的序列，并替换为指定的字符
-d：删除指定字符
-t：在执行命令前，将两个字符串截断至相同长度

SED（

，流式编辑器）

支持多种编辑功能的命令，基本基于缓冲区运行，因此在修改前不会影响原始文件。

命令选项

以 /[模式]/ 的形式表示模式。
添加 g 时，对所有匹配的模式进行操作
通过逗号 (,) 调整范围。
p：输出所有行，若匹配模式则额外输出一次
- 添加 -n 选项：排除默认输出，仅输出匹配模式的行
d：删除匹配的模式
s：替换匹配的模式
e：多行编辑

*n;

：下一行

y：转换
i：插入
c：更改
a: 追加

# 약간의 응용

sed -n 'n; p': 짝수 줄 출력
sed -n 'p; n': 홀수 줄 출력

WC

词数统计

-l: 查看文件的行数
-c: 查看文件的字节数
-m: 查看文件中的字符数
-w: 查看文件中的单词数

贝壳历史杂项 (2)

Thu, 20 Jul 2023 16:49:40 GMT

列表

通常与 ls 一起使用的命令。您可以使用这些命令查看目录的内容。附加命令非常有用，因为它们允许您出于适当目的调出列表。

我们将留下最常用的命令和用于特定目的的命令，如果您需要更多命令，可以使用 man 获取手册或参考下面链接的文档。

-l: 长默认格式。 working john 2008-07-25 11:56 csrc 1 alias.c-4.5 27

-al: 显示全文。

-t: 按修改时间排序。

-m：输出用逗号和空格（, ）分隔的每个元素 this, is, example

-r：以与当前顺序相反的方式输出

-R：递归打印子目录的内容

-h：单位的人可读输出（使用 m、k、g 等单位）

列表手册

查找

该命令用于搜索文件，搜索指定位置的所有子目录并打印结果。它提供的功能远不止输出这么简单，如果你真的想充分利用它，就应该学习一下正则表达式。

-name: 这是一条添加搜索名称信息的命令，可以使用正则表达式对搜索名称进行限制。

-o：该命令的作用类似于 or 运算符，因此如果你想在条件 A 的情况下执行操作 a，在条件 B 的情况下执行操作 b，请使用该命令。

-exec：允许应用附加命令的命令。

-delete：删除找到的文件。

-print: 打印找到的文件的命令

同样，你也可以在这里搜索其他命令。

查找手册

Echo & Printf

我在 shell 中经常使用 echo，但除了 echo 之外，你还可以使用 printf。老实说，除了换行符的默认值，我对它们了解不多，所以我向 ChatGPT 求助！

令人惊讶的是，printf 比我经常使用的 echo 更复杂一些。我不认为我在少量使用时会注意到有什么不同，所以我暂时就使用这些信息了......

贝壳历史杂项 (1)

Mon, 17 Jul 2023 17:25:08 GMT

文件创建相关

touch：创建文件
mkdir：创建文件夹
chmod：设置文件权限
chown：设置文件所有者
mv：移动和重命名文件

检查文件信息

-rwxr-xr-x部分：检查文件权限

第一个数字表示文件类型（-、d、l）； 2. 2. 读写执行权限以三位数的形式表示用户、组和其他、 rwx 的值可以改为 7，-xr 的值可以改为 4，因为在二进制数形式中，r 是 4，w 是 2，x 是 1。

chmod 744 Slack.lnk

这类命令可用于设置权限。 3.链接数（其中写入 1） 4.关于所有者（空）和所有者组（197609）的信息 5.文件大小 6.最后修改时间信息 7.文件名

ssh-keygen

在许多情况下用于通过安全壳公钥进行 Git 验证
包含在 Window 和 Linux 软件包中
生成密钥时，会生成一个密钥和 .pub 文件，通过向服务器提供 .pub 文件的内容将其用作密钥锁

如何在 shell 中调整文件的容量

mkfile -n 10k test.sh
fallocate -l 10k test.sh
truncate -s 10k test.sh

使用该命令可以调整现有文件的大小或创建新文件。

更改文件修改历史记录

touch -t 2301011234 timefile.sh

以下命令可更改文件的修改历史，使其显示最后修改时间为 1 月 23 日 12:34，作为触摸应用。

硬链接和符号链接

符号链接（软链接）

使原始文件在特定文件夹中可用的链接，如 Windows 中的快捷方式，如果原始文件被删除，链接将失效。

硬链接

与符号链接不同，区别在于它复制了原始文件并创建了一个副本；当原始文件被删除时，符号链接将无法使用，但硬链接仍可使用，因为它毕竟是同一个文件；链接涉及的链接数。

代码

ln [대상 폴더] [만들 링크 파일명] # Hard Link
ln -s [대상 폴더] [만들 링크 파일명] # Symbolic Link

使用 rm 可以解除擦除命令，就像擦除文件一样

Diff & Patch

diff a b > difference.patch

diff 命令逐行比较两个文件，而 patch 命令允许你根据 diff 的比较结果修改文件。

patch -p{패치 경로의 depth} [원본] [patch 파일] # 패치 파일 적용
patch -p{패치 경로의 depth} -R [원본] [patch 파일] # 적용된 패치 파일을 되돌림

与上述形式相同，你可以从现有文件中应用或删除由 diff 确定的内容。

2023 年韩亚 IDT 暑期招聘回顾

Sat, 15 Jul 2023 09:23:14 GMT

在

由于经济原因，招聘轮次和招聘人数都比去年少了很多。最后，谁能在时机成熟时得到工作，谁就是赢家，所以我认为我需要更加坚持不懈。

###文件筛选和能力测试

与其他公司一样，文件方面没有什么特别之处，但与财务招聘类似的能力测试却不同寻常。

我以为我的回答都很正常，但我很担心，因为出现了（注意），但摄像头和麦克风都没有问题，所以我就照原样提交了、

我顺利通过了考试。如果时间充裕，我会再检查一次能力测试。

编码测试

难度和题型让我想起了金融专业的编码测试。总的来说，难度一般，与 SQL 类似。

我通过了考试，并获得了在韩亚 IDT 面试的机会！

最终面试

我在大楼入口处领取了面试官的访客通行证，然后去参加面试。面试内容与我在准备过程中读到的其他评论类似，都是讨论和性格面试。

我没想到自己会在讨论面试中扮演重要角色，但我认为这是一个筛选出有沟通问题的人的过程。

在性格面试中，我被问到的问题是基于文件、编码测试结果等的综合。

我认为应聘这样一份工作的人并不多，但我认为对公司研究不够的人可能会在问题上遇到困难。
通过询问面试者的意见，我感觉公司在思考公司的发展方向。

最终结果。

我认为我在面试中的回答比平时要好，尽管竞争激烈，我还是成功获得了这份工作！

###感想

在进入 IT 行业时，很多人都会因为听到的各种故事而对 SI/SM 产生一种模糊的恐惧感，而我正是如此。

~~超级现实主义

但我认为，国内IT行业的大部分人都在关注SI/SM，而不是IT服务，如果忽略了这一点，就可能做出非理性的选择。

由于现在的就业市场已经今非昔比，所以现在应该有一种意识，考虑现在最好的选择是什么，而不是去追求过于狭隘的目标，只要牢记这一点，就一定会取得好的结果！

[面试问题] 什么是面向对象编程？

Wed, 12 Jul 2023 07:28:03 GMT

在

昨天，我去一家大公司面试，遇到了一个情况，我必须回答一个关于面向对象编程的问题，我以为我很清楚，但当我试图回答时，却磕磕绊绊。

多亏了这件事，我想我已经找到了自己的弱点，决定花时间重新整理一下！

什么是 ### 对象？

让我们从一般定义开始

一般理论：实际存在的东西计算机科学：根据类的定义在内存中创建的东西。

面向对象的语言定义如下

Java：类的实例或数组 Python：具有属性值或行为的数据。

Java 中的类不是实例，但 Python 中的类是实例。

面向对象编程

通过定义对象的角色和关系来构建交互式程序。

我们可以这样定义

面向对象语言的特点

抽象

可以在对象之间推导出共同特征
定义类的部分是

多态性

可以对行为略有不同的函数进行相同的调用
为同一命令向链接对象传递解释
覆盖（覆盖内部源）、重载（根据参数调用另一个同名函数）

封装

允许你隐藏部分实现而不向外界暴露
如果需要与外界通信，则通过方法发送和接收信息

从 #### 继承

从一个类继承另一个类的功能。
除已创建的类外，还允许创建新类

[BOJ 11689, Python] GCD(n, k) = 1

Fri, 07 Jul 2023 06:49:25 GMT

问题链接

boj 11689

分类

数学, 数论, 欧拉函数

描述

最近，我一直在练习解决不分类的 Backzun 问题，以提高我的实际能力。然而，当我遇到像这样的问题时，就变得相当头疼。

就这个问题而言，我起初认为至少应该尝试将其求解到 O(N) 以下，因为我需要在 1 秒钟内检查 10¹² 以下的数字。我使用了下面的代码，因为我认为如果是质因数分解，而且没有重叠的数字，就不会有问题。

def factorize(target_number: int) -> list:

    result = []
    prime_list = find_prime(target_number)

    now_number = target_number
    while now_number > 1:
        for each_prime in prime_list:
            if each_prime > now_number:
                break

            elif not now_number % each_prime:
                while not now_number % each_prime:
                    now_number //= each_prime
                result.append(each_prime)

然而，根据这段代码计算出的时间复杂度并不令人满意，于是我决定检查一下标签，结果发现了一个新朋友 오일러 피 함수。

原来，问题本身是一个使用

φ(n) = {n 是小于或等于 n 的自然数的个数}。

我是这样实现的


def euler_phi(number: int) -> int:
    '''
    오일러 피 함수를 활용한 자연수 n과 서로소인 수의 갯수를 구하는 함수
    '''

    checker = 2
    result = number

    while pow(checker, 2) <= number:
        if not number % checker:
            while not number % checker:
                number //= checker

            result -= result // checker

        checker += 1

    if number > 1:
        result -= result // number

    return result

从 2 开始，一直除下去。
如果这个数能被整除，就尽可能多地整除它。(质因数分解）
从得到的数中减去，因为这个数的倍数不能是质数。
如果最后还剩下一个数，就从结果数中减去它，因为它是一个质数，而这个质数的倍数不能是质数。

这就是有点棘手的地方。

结果 -= 结果 // 校验

我曾想过为什么我们要从结果中移除除数，而不是移除 number // checker，但这是有道理的。如果我们去掉 n 的倍数，然后再去掉相同数目的 m 的倍数，最后就会得到两个 n * m 的倍数！

为了处理这些重复的数字，我们要从已经删除过一次的数字中减去该数字的倍数。

总之，一旦你明白了解决方法，这个问题就变得非常简单了。数论问题似乎都是这样，这对学习很有帮助，但有点令人沮丧，因为第一种方法总是很难

解题代码

# GCD(n, k) = 1

def euler_phi(target_number: int):
    result = target_number
    check_number = 2

    while pow(check_number, 2) <= target_number:
        if not target_number % check_number:
            while not target_number % check_number:
                target_number //= check_number
            result -= result // check_number
        check_number += 1

    if target_number > 1:
        result -= result // target_number

    return result

target = int(input())
print(euler_phi(target))

[面试问题] 依赖注入

Thu, 06 Jul 2023 11:46:58 GMT

依赖注入

依赖关系：一个对象使用另一个对象的关系。 → 依赖注入：建立关系的东西

为什么需要依赖注入？

public class Product {

	private Apple apple;
    
    public Product() {
    	this.apple = new Apple();
	}

}

在本示例中，如果一个名为 Product 的类使用了 Apple 构造函数，那么我们就是在使用它，而没有注入它。当使用 Product 时，可以将其理解为 Apple 附带的依赖关系。在这种情况下，它不是对象之间的连接，而是类之间的关系。

另外，如果我想使用一个名为 Orange 的额外类，我就必须修改 Product 类的构造函数，而这是不灵活的。

最后，总结一下依赖注入的必要性

类之间的强耦合 + 代码不灵活

我们可以说，依赖注入解决了这些问题，所以它是必要的！

解决方案的应用

public interface Fruit {

}

public class Apple implements Fruit {

}

public class Product {

	private Fruit fruit;
    
    public Product(Fruit fruit) {
    	this.fruit = fruit;
    }
    
}

可以看出，每个类都保证是独立的。

添加一个新的 "水果 "不会改变 "产品"； 2.
对象之间形成关系，而不是类之间的关系

[面试问题] Java 堆栈和堆的结构

Sun, 02 Jul 2023 17:19:40 GMT

Java 内存结构

参见 JVM 结构和原理

我们为运行应用程序而构建的 Java 运行时数据区位于内存中

所有线程共享 PC 寄存器、本地方法堆栈和方法区。
只有堆栈和堆区域是线程专用的

堆的结构

伊甸园 → 幸存者 → 旧的

对象按上述格式移动，这基本上是创建的顺序。

垃圾回收器的作用

伊甸园（Eden）：Java 对象创建后立即存放的地方。
Survivor & Old：根据引用程度移动对象的空间
标记和扫描：使用标记和扫描算法。

小型垃圾收集器

负责根据对象引用移动 Eden 和 Survivor 区域（年轻一代），如果它们的内存超过允许的数量。

主要垃圾收集器

当旧区域（长期一代）的内存超过允许上限时，它将删除所有未引用的对象并回收内存。

在删除过程中，停止除运行垃圾回收器的线程以外的所有线程（"Stop-The-World"）。

堆栈结构

基本类型 + 局部变量 + 参数

在参数的情况下，它用作对堆区对象的引用，并带有对象的地址值。

→ 如果参数指向不同的对象，地址值也会不同，存储在堆中的对象也不会立即消失！（保持到主要 GC 执行为止）

另请参见。

编码工厂的文章

[日本央行 27231，蟒蛇] 我为何期待 2023 年

Fri, 30 Jun 2023 10:32:49 GMT

问题链接

boj 27231

分类

暴力算法, 逆向追踪

描述

很高兴看到我能够解决以前无法解决的问题，所以我觉得我进步了。

就拿这道题来说，最后一次尝试是在五个月前提交给比赛的，但在此期间我已经把解题思路写了好几遍。

之所以会有多次尝试，是因为只缺少一个条件，但我还是不清楚为什么缺少这个条件会超时。整理博客是最棒的！

让我来介绍一下解决问题的方法

对 *+ 符号之间的坐标进行位屏蔽，检查是否为整数

在不允许重复的列表中设置或排序
计数直到最初输入的数字（因为无论如何切分，都不会大于该数字），方格尺寸不断增大

这里我们遇到了一个问题。

对于一个由 0 和 1 组成的数字，我们应该输出 Hello, BOJ 2023!，因为如果我们把它分割成一个数字，那么无论平方多少次，数值都不会改变，但我只是排除了 1 的情况。

为了检查这一部分，我通过检查是否有大于 2 的单个数字来处理边缘情况，如果没有大于 2 的项，则打印 Hello, BOJ 2023!，这就是正确答案。

求解代码

# 2023년이 기대되는 이유

import sys

input = sys.stdin.readline

def pow_target(target_num: int, exponent: int) -> int:

    result = 0

    now_number = target_num

    while now_number:
        result += pow((now_number % 10), exponent)
        now_number //= 10

    return result

testcase = int(input())
result_dict = dict()
output = []

for _ in range(testcase):

    target_number = input().rstrip('\n')

    if result_dict.get(target_number) is not None:
        output.append(result_dict[target_number])

    else:

        is_under_limit = True

        for each_element in list(target_number):
            if int(each_element) > 1:
                is_under_limit = False
                break

        if is_under_limit:
            result_dict[target_number] = 'Hello, BOJ 2023!'
            output.append('Hello, BOJ 2023!')
            continue

        length = len(target_number)

        check_list = []
        check_list.append(int(target_number))

        for i in range(1, 1 << length):

            calc_result = 0

            now_start = 0
            now_end = 0

            for j in range(length):

                if i & (1 << j):
                    now_end = j
                    if now_end:
                        calc_result += int(target_number[now_start : now_end])
                    now_start = now_end
                    
            calc_result += int(target_number[now_start : length + 1])

            if calc_result not in check_list:
                check_list.append(calc_result)

        else:
            result = 0

            check_amount = len(check_list)
            check_list.sort()

            max_value = check_list[-1]
            pointer = 0
            counter = 1

            while pointer < check_amount:
                now_result = pow_target(int(target_number), counter)

                # 종료 조건 1
                if now_result > max_value:
                    break

                while pointer < check_amount and now_result > check_list[pointer]:
                    pointer += 1

                # 종료 조건 2
                if pointer >= check_amount:
                    break

                if now_result == check_list[pointer]:
                    result += 1

                counter += 1

            result_dict[target_number] = result
            output.append(result)

for result in output:
    print(result)

[BOJ 13325, Python] 二进制树

Wed, 28 Jun 2023 12:58:52 GMT

问题链接

boj 13325

分类

动态程序设计, 树, 树中的动态程序设计

描述

如果你和我一样，是那种即使不能马上解决问题，也会长期坚持的人！

于是，那些我尝试了却无法解决的问题，那些我努力了却无法解决的问题，就这样和竞赛题一起堆积起来......

为了摆脱它们，我有时会通读试题，细细咀嚼，真庆幸今天终于在这篇文章中找到了解决办法！

距离我第一次尝试已经过去 8 个月了，上次尝试后我又修补了几次，但似乎都没有效果。


def pre_order_detail(graph_dict: dict, target_node: int = 1) -> list:

    result = [target_node]

    if len(graph_dict[target_node]) >= 1:
        for each_element in pre_order_detail(graph_dict, graph_dict[target_node][0]):
            result.append(each_element)
        result.append(target_node)

    if len(graph_dict[target_node]) >= 2:
        for each_element in pre_order_detail(graph_dict, graph_dict[target_node][1]):
            result.append(each_element)
        result.append(target_node)

    return result

我最初的想法是使用类似上述递归函数形式的潜在遍历的变体，拍摄访问节点的图片，将其放入类似堆栈的数据结构中，然后遍历每个主干。

不过，经过思考，我意识到如果将比较对象限定为来自同一父节点的树干，那么只需将两个值中较大的一个加到父树干上，这样会更简洁！

后来，我解决了这类问题，并将其归类为树形 DP。我认为它与 DP 非常相似。

解题代码

# 이진 트리

import sys

input = sys.stdin.readline

tree_height = int(input())
node_number = pow(2, tree_height + 1)

edges = [0] + list(map(int, input().split()))
edge_sum = sum(edges)

now_start = node_number // 2 - 1
now_end = node_number - 1

while now_end:

    for i in range((now_end - now_start) // 2):

        child_edge = now_start + (2 * i)
        next_node = child_edge // 2

        edges[next_node] += max(edges[child_edge], edges[child_edge + 1])
        edge_sum += abs(edges[child_edge] - edges[child_edge + 1])

    now_end = now_start
    now_start = now_start // 2

print(edge_sum)

代码长度和时间复杂度比我们最初想象的要简单。现在我们把代码编排成这样，肯定是自下而上的。

[存档]什么是 IaaS、PaaS 和 SaaS？

Mon, 26 Jun 2023 05:21:36 GMT

普通话中的 "aaS "是什么意思？

服务 "的缩写

由第三方提供的云计算服务！

有什么区别？

以服务形式提供不同的基础设施、平台和软件。 → 不同的管理级别

1. IaaS

从内部基础设施演变而来
向云提供基础设施服务
提供商负责管理和访问网络、服务器、虚拟化和存储
例如 AWS、Azure、GCP 等。

2. PaaS

责任范围比 IaaS 更广
允许用户开发、运行和管理自己的应用程序
提供构建和部署环境

3. SaaS

所有应用程序均由提供商管理
提供商管理所有软件维护、升级和安全工作

注意

IaaS vs. PaaS vs. SaaS

[面试问题]什么是连接池？

Sun, 25 Jun 2023 17:05:44 GMT

什么是 DB 连接池？

在池中存储已连接到数据库的对象。客户请求时借用连接处理后，返回连接并将其保存回池中。

我想你可以理解为，这就像一个事先连接好的连接对象，需要时再取出来。

为什么要使用它？

对于 Java Spring 来说、

如果你使用直接连接到数据库的方式进行处理，你可以使用
每次都需要加载 JDBC 驱动程序并获取连接对象
每次请求都要重复加载驱动程序、创建对象和连接

→ 这样做效率很低，因此我们使用连接池来解决这些问题。

+ 其他框架也使用它。

功能

WAS 运行时在连接对象池中预先创建
根据 HTTP 请求获取、写入和返回对象
每个连接请求不消耗连接和创建时间 → 减少连接负载

当并发连接数多于池中对象数时？ → 如果没有足够的预创建连接对象，则按顺序等待，直至返回

较大的池会消耗更多内存并减少延迟。

[碎片] 关于主要功能的位置

Sun, 18 Jun 2023 11:50:50 GMT

在

我决定将 자투리 类别用于简短的经验教训！

将主要功能的位置移到顶部

CS50我在听讲座，这就是我组织代码的方式。


def example():
	print('hello')
    
def main():
	example()
    
main()

例如，我会先列出我需要的所有函数的详细定义，然后再列出主函数。

不过，我觉得主函数应该放在开头，这样别人在阅读代码时会更清楚。


def main():
	example()
    this_function()

def example():
	print('hello')
    
def this_function():
	print('function')
    
main()

我们应该把显示代码整体实现的主函数移到页面顶部，把详细定义放在它后面，这样代码的作用就更清楚了。

SSAFY 第 8 年回顾，无特别之处

Fri, 16 Jun 2023 17:28:37 GMT

在

历时一年的第八期三星青年 SW 学院（SSAFY）终于结束了。虽然付出了很多，但这是一段令人惊叹的旅程，所以我想现在就写下来。如果你看一下 SSAFY 的评论，就会发现他们中的大多数人都以优秀或更高的成绩完成了课程，甚至还获得了一两张证书......

我想，大家可以把这篇评论看作是某位SSAFY学员的故事，而不是某位获得了很多奖项的SSAFY式的优秀人物的故事。我也希望这篇评论能对今后参加SSAFY课程的学员有所帮助。

입과

我莫名其妙地闯过了 SSAFY 这一关，众所周知，SSAFY 对于非专业学生来说是很高的。我通过了自我介绍，但没有通过面试......不过，我还是收到了非专业录取通知，进入了首尔校区。因为我是最后才被录取的，所以可以不用参加开学训练营，但听说只有参加过开学训练营的人才知道。

当你被SSAFY录取时，你会得到一个名牌，但就连名牌上也把我的名字贴在了其他先期录取者的名字上面......事后我不得不用胶带把它粘起来，因为它老是掉下来。

现在回想起来，我觉得名牌实际上让我更加努力地工作。我认为它让我充满动力，并不断提醒我，我所获得的机会是无价的！

###第 1 学期，Python 方向

虽然我知道自己想学 Java，但我还是选择了 Python 方向。我在第一学期学到了很多东西...

在第二学期，我认为我真正学到并用得好的东西只有算法、Git 和 Python。即便如此，Python 和 Algorithm 在编码测试中的使用率远远高于在项目中的使用率...

(我在学习前端，但我主要是在重新学习 React，所以它并不存在）

尽管如此，如果你加入这个赛道，就会发现几乎每个人都对学习充满热情，就像 SSAFY 一样。我觉得我在班上花了很多时间，一起做研究，一起在咖啡馆学习。

对于我来说，编程几乎是零基础，因为我所知道的编程知识都是在大学里学的，我觉得自己不可能样样精通，所以我觉得需要有所选择，有所侧重，所以我觉得应该先看看招募流程，一步步尝试突破。

文档筛选 → 编码测试 → 性格面试 → 技术面试 → 录用

我发现大多数公司都在这个范围内。因此，我想，“如果你不能通过编码测试，那你就没有前途。” 这就是算法技术树的开端。

为了提高算法技能，我投入了大量时间学习，但最终，在取得白金 5 后，我几乎耗尽了自己的精力。从那时起，为了通过三星软件能力评估 B 类，我还在中间学习了 Java 语言，但遗憾的是，我最终没有通过。复习资料在这里，如果你拿到了B类，你将优先获得SSAFY提供的各种福利、经验和人脉，所以如果你能拿到，就去做吧！

(不过，我认为即使是低级问题也要坚持解决，这样才不会失去方向感）

在几乎每周都艰难地通过理论和实践测试后，我进入了最终项目。这是一个为期 7 周的项目，事后看来，它要求我们用压倒性地更少的人和更少的时间完成第二学期的挑战！我确信我在某个地方看到过一些很酷的代码，但最终，奖项归属于完成了其他人无法完成的任务（例如部署）的团队。

第二学期，项目一个接一个。

在第二学期，你一直在做项目，我认为这是 SSAFY 最重要的部分。

在第一学期，即使你想应聘一家公司，如果对方问你 "你做过什么？"，你也没有什么可以回答的，所以你在自我介绍或面试时可以诉说的部分很有限，但随着第二学期的逐步推进，无论结果如何，只要你忠实地参与了项目，你就可以说 "我做了这样那样的事情，我在这样那样的事情上遇到了困难，但我在这样那样的事情上得到了改进 "这样的话！

项目的主题似乎是一成不变的，但如果不是专门的项目，我就可以按照团队的要求开展工作，而不会被某个主题所束缚。就我而言，我参与了两个应用程序开发项目和一个具有移动规格的网络开发项目。至于岗位，不同的人在第二学期可能有不同的想做的事情，但我想在所有岗位上都获得经验，所以我选择了一个后台、一个前台和一个应用程序的经验。

如果你是 Python 方向的学生，你大部分时间都在用 Java 构建一堵墙，而由于第二学期 99% 的项目都使用 Spring Boot，你不可避免地会在前端工作，这也是你获得职位固定的地方。因此，如果你是 Python 方向的学生，如果你知道自己想在后端工作，最好单独选修 Java。就我而言，我单独选修了 Java 课程，以便为后端职位留出选择余地，结果，我获得了一个后端职位。

###求职和各种面试

当我幻想着从第一学期到第二学期都能有所表现时，一小群有准备的人却荣幸地一直尝试着与公司取得联系，结果，在这中间得到了SSAFY的逃脱。看到他们时，我的第一个想法是：'我还没准备好...'但结果是，在两个学期后，你自然而然地开始通过观察各种逃脱的领导者来做准备。

看到自己接受并完成了第二学期的证书，而别人却拿到了员工证书，你可能会很失望，所以你应该继续努力。我申请了很多地方，最后还是接受了第二学期的证书，但我觉得我很庆幸自己这么做了。

一旦你通过了编码测试和文件筛选，了解了 SSAFY 的各种好处和你所掌握的技能，还有面试。你往往要通过性格面试和技术面试才能知道自己的不足之处，所以我觉得如果能在培训期间体验一下就非常好了。

面试绝对是越做越好的事情。我认为，如果你不身临其境，不紧张，你就无法体验如何应对面试官，所以如果你有能力，就继续参加比你实际想要的级别低的公司的面试，这样你就可以在你实际想要的公司取得更好的成绩！

完成后...

那么在 SSAFY 之后我们要做什么呢？

我花了很多时间思考这个问题，现在仍在努力寻找答案。基本上，我想花时间静下心来反思一下我所参与的项目，但我也想总结一下我所学到的东西，而且我还想尽快找到一份工作......

最后，我想我会继续一切。我相信，最好的办法是自下而上，因为我目前所学到的东西不会丢失。我在 SSAFY 的第 8 年旅程即将结束，但我的开发人员生涯不会就此结束！我相信更好的日子在等着我，我会继续努力。

2023 年 LG CNS H1 招聘回顾

Fri, 16 Jun 2023 08:27:19 GMT

在

今年上半年，我参加了 LG CNS 的初级招聘，并进入了最后的面试。最后，很遗憾，我没有取得好成绩。不过，与其掩盖自己的失败，不如写下自己的不足，下次做得更好。希望对今后参加招聘的人有所帮助。

文件筛选

我不认为筛选过程有什么不正常的地方。唯一不正常的地方是自我介绍的篇幅比其他公司要少。不过，也有被拒之门外的情况，所以我认为有意想不到的歧视因素。如果通过了，就可以进入编码测试。

编码测试

总的来说，我认为难度并不高。如果你能随机解决 Silver~ Gold 5 级的问题，我想你就能做得很好。如果非要给一个方向的话，我认为练习能够应对该领域的任何问题而不是要求创造性的算法会很有帮助。

当你把问题解决到一定程度后，就可以进入面试了，我顺利通过了面试。

###第一次面试

通过编码测试后，我收到了第一轮面试的信息。基本上是视频面试，我想他们问了我求职信中的问题和一般的面试问题。我不记得面试官说了什么，但他说他们对新员工的期望不高，也不评估能力。他之后还说了一些话，但我当时很紧张，就从记忆中删除了。我想，如果我们少看能力，就会把重点放在个性、自我介绍验证、诚信和文化契合度等方面！

话说回来，如果你在编码测试中表现出色，你可能会得到面试官对测试的小小赞美。我感觉很好，因为我注意了可能遇到的反例和边缘情况，感觉就像得到了结果的确认。

因为对面试不熟悉，所以我的动作很僵硬、很笨拙，我以为我失败了......但我还是得到了第二次面试的机会。毕竟，卖面也是一门学问。

第二次面试

与其他公司的筛选类似，如果你真的被录用了，有权决定你在哪个部门工作的人也会亲自来面试你。一开始，他们做了自我介绍，但我太紧张了，根本记不住。我想他们是想让我感觉舒服一些，但我只记得当我觉得和第一次面试差不多时，他们开始问我技术问题，我就开始胡言乱语。最后，我问他如果带着雄心壮志加入公司，会有什么样的态度，我记得他笑着说了一些好话。还有...

说实话，当我得到这个答案时，我真的很伤心。不过，面试结束后仔细想想，这个结果也不是没有道理的，因为让我失望的地方有很多，我觉得有些方面我回答得太差了，比如面试官问我的技术问题和对应聘公司的认知程度，所以我没有任何让面试官觉得我想打动并录用的长处。

最后的想法

很遗憾，因为我是上半年招聘过程中最接近被录取的。不过，我相信现在收到的成绩单给了我前进的方向，我会继续努力，改进自己不足的地方。

我希望以这次经历为跳板，成为更好的自己。我会更加努力，在下一次 CNS 招聘中成为选择组织的人，而不是可以选择组织的人。

[面试问题] JVM 的结构和原理

Thu, 15 Jun 2023 16:30:41 GMT

23-06-27 填充未完成的内容 23-07-01 完成并填写内容

Java 概述

1. Java 的开发理念

一次编写，随处运行

以平台无关的语言为目标
开发的重点是能够在任何操作系统上运行用相同语言编写的代码（跨平台）。

2. JDK

Java 开发工具包它是 Java 开发工具，包括 JRE 和 JVM。与默认情况下只需运行用 Java 编写的程序的用户不同，开发人员需要安装 JDK。JDK 包括一个编译器。
Java 运行时环境 Java 运行时环境包括 Java 类库、Java 类加载器和 JVM。使用类加载器和类库编写的 Java 代码可与类库结合在 JVM 上运行。
Java 虚拟机

什么是 JVM？

Java Virtual Machine，Java 虚拟机。
为运行 Java 程序提供环境的软件。

Java 代码 → 编译器 → 机器语言

通过为应用程序的执行分配内存来构建 Java 运行时数据区。

运行时数据区

堆区
方法区域

以上两个区域由所有线程共享

PC 寄存器
本地方法堆栈
堆栈区域

上述三个区域在每个线程启动时创建，并在终止时销毁。

每个区域的详细信息

1. 堆

存储类实例和数组的空间

垃圾回收 * 动态内存管理系统 "垃圾回收

2. 方法

存储类、接口结构的空间

3. 堆栈

类似于 C 语言的堆栈结构，存储局部变量和函数执行结果
它负责调用和返回函数，并有一个堆栈框架。
什么是堆栈框架？

每个函数的分隔空间，包含函数的调用信息。以后进先出的方式处理堆栈框架如果在没有空闲空间时添加了一个框架，就会发生堆栈溢出。指针法使用序幕和尾声检查堆栈返回位置

4. 本地方法堆栈

用 C、CPP 编写的方法的执行堆栈
执行代码时分配本地方法栈
可能导致堆栈溢出错误或内存不足错误
可动态调整堆栈大小

5. PC 寄存器

每个线程都有一个 PC 寄存器
记录线程执行当前指定指令时的指令地址
从一条指令到另一条指令，该值会稳步波动，以确保所指向的值被执行

注释

JVM文档 고랭이님의블로그 sgwon1996的velog

[面试问题] 什么是 DB 索引？

Tue, 13 Jun 2023 15:20:25 GMT

加快数据库表搜索速度的数据结构

使用索引的优势

由于加快了表的查找速度，因此提高了性能
可减少系统负荷

使用索引的缺点

数据库索引需要额外的存储空间
数据库管理的额外工作和开销

索引管理

索引需要保持更新和排序，这样才能快速浏览到所需的值，因此在数据经常被修改的属性上挂起索引可能会因开销而导致性能下降。

INSERT：在插入数据时添加索引。
DELETE：应禁用已删除数据上的索引
更新：禁用现有索引 + 为更新数据添加索引

使用的数据结构

B+ 树

B 树增强规范

只在叶节点中存储数据

叶节点之间有一个链接列表

哈希表

以键-值对形式存储数据可以快速浏览数据不常用，因为它不适合不等式操作（排序 X）

索引的分类

1. 按键分类

主索引：包含主键（键的顺序 = 记录的顺序）
二级索引：不含主键（键的顺序 != 记录的顺序）

2. 根据文件组织分类

重点索引
非重点索引

3. 按数据范围分类

密集索引
稀疏索引

注意

内森的早午餐故事

[1天-1CS] 处理各层的设备

Mon, 05 Jun 2023 15:08:16 GMT

2023-06-18 合并以前帖子的内容，使内容保持一致

###处理应用层的设备

L7 交换机：也称为负载平衡器，是一种平衡服务器负载的设备

交换机：连接多个设备并调解数据通信的电信网络设备，仅向与之相连的端口发送电信号以传输数据。
旨在增加系统可处理的流量
根据 URL、服务器、缓存、cookie 等分配流量。
具有过滤功能，可过滤掉不必要的外部数据
允许流量监控

= 健康检查将失败的服务器排除在流量分配之外

L4 和 L7 交换机之间的区别

L4 交换机是处理传输层的设备，不能用于流媒体相关服务。
基于消息的不可知性、基于 IP 和端口的流量分配
在云服务中，L7 交换机的负载平衡是通过 ALB（应用负载平衡器）组件完成的，而 L4 交换机的负载平衡是通过 NLB（网络负载平衡器）组件完成的。

健康检查

通过设置传输周期和重传次数等，反复向服务器发送请求。

适当，以避免服务器超载
以不同方式发送请求，并确定它们是否得到正确处理。

使用负载平衡器实现服务器冗余

基于 2 个或更多服务器提供虚拟 IP，并以此为基础提供稳定的服务

服务器冗余是必要的，因为即使特定服务器发生错误，服务也必须继续。

处理互联网层的设备

路由器：连接、划分和分离多个网络。 L3 交换机：L2 交换机 + 路由器

处理数据链路层的设备

L2 交换机：管理设备的 Mac 地址并传输数据包网桥：允许两个局域网互连的电信网络连接设备。

处理物理层的设备

网络接口卡（NIC）：局域网卡，唯一标识的 Mac 地址就在这里。中继器：放大输入信号并将其传递到另一端。接入点：复制数据包的设备；连接有线局域网和无线网络。

[面试问题] 框架和库 (Feat. ChatGPT)

Sat, 03 Jun 2023 13:45:20 GMT

简介

在一次面试中，我第一次被问到这个问题，虽然我很诚实地认为自己知道答案，但却无法清楚地回答，最后给出了一个校友的答案......所以我写了这篇文章，以确保我下次能更好地了解这个问题！

图书馆

将开发中常用的功能模块化，旨在执行特定功能的程序。

框架

具有多种功能的类和库的组合，以实现特定的结果。

ChatGPT 的回答

上述定义是我阅读各种文章后得出的，个人认为这些定义已经接近正确答案。不过，我觉得有些地方不够完整，想得到更详细的答案，所以决定试试 ChatGPT！

图书馆的定义
框架的定义

那么有什么区别呢？

如果我们回到上面的答案，看看框架和库，就会发现

可重用代码和资源的集合由函数、类、方法、数据类型等组成。

框架

开发软件的结构化框架或平台。由预定义代码和库组成

这就提出了几个问题。如果框架可以包含库，为什么库不能包含框架？

不出所料，事实证明框架可以包含库，反之亦然。这篇文章还强调了框架和库之间的一个重要区别。

这就是代码流的控制。在库的情况下，开发人员调用库的函数并使用它们，但在框架的情况下，开发人员的方法被框架调用。

框架中出现的这种形式被称为 IoC（控制反转）。由于它与依赖注入（Dependency Injection）有关，我就不多写了，因为我觉得还会有其他内容要写。

结语

库是可重用代码和资源的集合，而框架则是结构框架或开发平台。就功能而言，它们的工作原理大致相同，区别在于如何使用。
框架可以包含库，但库不能包含框架。代码流的控制权掌握在框架和开发人员手中，因此开发人员一般不可能对框架进行修改，而库则可以由开发人员根据需要进行定制。

另请参见。

Kareyu 的博客 ChatGPT 3.5

[面试问题] Fork 和 Exec 有什么区别？

Wed, 31 May 2023 07:48:53 GMT

fork() 和 exec() 有什么共同点？

一个进程用来执行另一个进程

fork()

为新进程分配内存
进程被添加（我们有一个不同 PID 的进程）

exec()

不会为新进程分配额外内存
通过覆盖现有进程（相同 PID）来加载新进程

→ 新进程将在调用后运行，因此在现有程序执行点之后的程序将无法运行

注意

U-chan Seon's Blog

[BOJ 2887，蟒蛇]行星隧道

Tue, 30 May 2023 15:33:18 GMT

问题链接

boj 2887

分类

图论, 排序, 最小生成树

描述

我很惊讶这个问题距离我第一次遇到这个问题已经过去半年多了，但我认为这个问题值得记录下来，因为它得到了令人满意的解决，这与我最近对白金问题的忽视相比是一个很好的改变。

要正式解决这个问题，可以使用联合查找 + 克鲁斯卡尔算法的组合，即从最多 100,000 个坐标中挑选两个坐标，将它们的值从小到大列出，然后将最小的主干线包括在内。

但是，这将导致求解时间为 10⁵ * 10⁵，即大约 100 亿例，这将需要大约 100 秒的求解时间，因此这是一种不可行的求解方法。

提示：如果考虑每 1 亿次操作耗时 1 秒，则很容易计算！

因此，这个问题的关键在于如何将案例数从 O(N²) 减少到 O(N)。

总之，在当前问题中，为任意点构建生成树时，我们不需要考虑相邻点以外的其他点。

假设我们有任意点 A、B，需要将它们连接到一个点 C。

如果 x 值之差（|X_A - X_B|）是小于 y 的最小值，则 z → 假设点 C 的 x 值位于 A 和 B 的 x 值之间。

如果 |X_A - X_C| + |X_B - X_C|，则差不存在。任何任意的 |X_A - X_B| 保留 |X_A - X_C| 或 |X_B - X_C| 进一步连接 C 的 |X_A - X_B| 必须大于现有生成树 → 不能作为反例存在。

因此，如果在当前问题的最小生成树中包含一条连接两个任意点的干线，则证明这两个点一定是邻居！

解决这个证明是关键，我认为问题的其余部分与典型的联合查找问题并无太大区别。

***]

补充）在使用 PriorityQueue 而不是 heapq 时，我遇到了超时问题，我找到了这个问题的答案。

[在 python 中，heapq 和 PriorityQueue 有什么区别？

答案是 PriorityQueue 更慢，因为它保证了线程安全。

解决方案代码

# 행성 터널

import sys
from heapq import heappush, heappop

input = sys.stdin.readline

def check_union(union_info: list, now_target: int) -> int:
    """
    해당 노드의 현재 유니온을 조회하는 함수
    """

    if union_info[now_target] == -1:
        union_info[now_target] = now_target

    elif union_info[now_target] != now_target:
        union_info[now_target] = check_union(union_info, union_info[now_target])

    return union_info[now_target]

def make_union(union_info: list, target_1: int, target_2: int) -> None:
    """
    두 점이 같은 유니온인지 확인하고 아니라면 합쳐주는 함수
    """
    union_1 = check_union(union_info, target_1)
    union_2 = check_union(union_info, target_2)

    if union_1 == union_2:
        return True

    else:
        if union_1 > union_2:
            union_info[union_1] = union_2
        else:
            union_info[union_2] = union_1

        return False

planet_number = int(input())
coord_list = []

for i in range(planet_number):
    coord_list.append([i] + list(map(int, input().split())))

cost_queue = []

for i in range(1, 4):
    coord_list.sort(key=lambda x: x[i])
    for j in range(planet_number - 1):
        heappush(
            cost_queue,
            (
                coord_list[j + 1][i] - coord_list[j][i],
                (coord_list[j][0], coord_list[j + 1][0]),
            ),
        )

union_info = [-1 for _ in range(planet_number)]

total_length = 0
line_number = 0

while cost_queue:
    if line_number == planet_number - 1:
        break

    now_length, nodes = heappop(cost_queue)
    node_a, node_b = nodes

    if not make_union(union_info, node_a, node_b):
        total_length += now_length
        line_number += 1

print(total_length)

[面试问题] 进程与线程、多线程之间的区别

Mon, 29 May 2023 17:44:03 GMT

~~ 我还在写这篇文章！~~ >~23. ~~23. 05. 30. 写作完成~~ → 23. 06. 09. 添加内容

计划

为计算机执行特定任务而编写的一组可执行指令。

它有许多不同的定义，但我在阅读时是这样理解的！我之所以先检查程序的定义，是因为进程的定义是一个范围较窄的程序。

流程

'运行中'的程序的'实例' （几乎可与任务互换使用）

在内存中运行的基于操作系统的工作单元

耗费大量时间和资源来创建（高开销）

我认为有特点的部分是，可以同时拥有一个程序的多个实例，而不是程序本身。

线程

在进程中执行工作的基于 CPU 的执行单元。

所有处理器都至少有一个线程

线程有自己的寄存器和堆栈

堆内存空间是共享的

那么两者之间有什么区别呢？

进程可被视为一个更大的分类单元

不过，我想如果我就这么简单地回答，那就太全面了，所以我参考了一些条理清晰的文章，补充说明了一些问题！

工作原理

1. 对于流程

进程运行时，操作系统会为其分配一个单独的内存区域。
内存区域的格式如下：代码/数据/堆栈/Heap
不能访问其他进程的内存区域

2. 对于线程

进程的堆栈区域被分割并拥有自己的区域
代码区、数据区和堆区的其余部分是共享的

一个进程的错误不会扩散到其他进程的区域

但如果一个线程失败，所有线程都会终止。 → 因为它们共享内存区域

摘要

进程（Process）和线程（Thread）有什么区别？

进程是动态使用的程序，线程是任务的执行单位，但概念不同。
一个进程至少包含一个线程
进程通常不共享内存空间，但线程可以
进程在每次出错时都会单独宕机，而线程则会在同一进程内全部宕机

***]

+ 关于多线程

在一个进程中同时运行多个线程。

上下文切换（上下文切换）

默认情况下，可同时处理的最大任务数为内核数。如果运行的线程数多于内核数，则每个内核会交替执行多个任务。线程切换时，会保存并读取任务的当前状态或下一个任务所需的数据。

多线程和进程的优缺点

1) 多线程的优点

创建进程和分配资源的系统调用处于休眠状态，可有效管理资源。
线程之间发送和接收数据的处理成本较低，因为除堆栈外，它们在一个进程内共享内存空间。
由于线程之间的通信方法不那么复杂，程序响应时间缩短。

2) 多线程的缺点

增加调试难度和设计难度
其他进程线程的不可控性
内存共享（同时访问相同资源）导致的同步问题
一个线程的问题会影响整个进程

3) 多进程的优势

如果一个进程出现问题，其影响不会扩散到该进程之外

4) 多进程的缺点

上下文交换开销大
进程间通信比线程间通信更加困难和复杂

注意

维基百科关于进程和线程的词条进程与线程的区别进程与线程的区别 by heejeong Kwon

[CI/CD] 从实例到 DooD 部署的流程（特点：Nginx、Jenkins）

Sat, 27 May 2023 14:55:17 GMT

23-06-16 修改路径，使音量安装更清晰 23-07-05 调整设置，方便开发

简介

[CI/CD]使用 Docker + Jenkins + Git Webhook 组织 FastAPI 服务器的自动部署

之所以写这篇文章，是因为上面的最后一篇文章包含了我当初努力学习的内容，但我想把需要修正的部分修正一下，把需要打磨的部分打磨一下，完成成一篇整齐的文章。

从上次开始，我已经掌握了一定的诀窍，并将部署任务条理化，也帮助了身边的人进行部署，所以我希望可以将其记录下来，作为下次部署的统一流程！如果你按照本帖的顺序进行部署，我想你不会觉得有什么困难。

###第 1 部分后我学到的其他东西

为什么要在 Docker 之外而不是 Docker 之中实施？

默认情况下，Docker 不鼓励在 Docker 容器上执行命令。

Docker 中的 Docker 赋予安装了 Docker 的容器强大的权限，这可能是一个安全风险

Docker 外的 Docker 允许你通过与容器外的 Docker 共享套接字来运行 Docker 命令。

使用 Docker API 如何？

实际上，我就是用它来解决第 1 部分中的问题的，而且成功了。但我认为，如果你已经成功地从 Docker 中构建了系统，那么在 CI/CD 程序中就不需要它了......

关于应用程序接口的一些内容，我觉得太含糊，无法单独写出来，所以就写下来了。

Docker 使用 REST API 在引擎和客户端之间进行通信，该 API 大部分未被使用，但可用。

  docker --tlsverify --tlscacert=/.docker/ca.pem \
  --tlscert=/.docker/cert.pem --tlskey=/.docker/key.pem \
  -H={server_ip}:{port_number} exec nginx \
  sed -i '4s/.*$/ server {container}:8000;/' /etc/nginx/sites-available/default.conf

这段代码通过带有 TLS 证书的 Docker 客户端修改位于任意服务器上的 Nginx 配置文件的内容。它通过 -H 命令，通过服务器上的端口与守护进程（Docker 引擎）通信，代码的其余部分是通过证书确保访问安全的程序。

如果不使用证书而开放端口，就会有人通过该端口撞毁你的容器！

容器干扰的真实体验。我在没有安全认证的情况下打开了一个 Docker 常用的端口...

通过证书确保安全是必须的，如果因为某些不可避免的原因而无法确保安全，就必须限制通过该端口运行的命令。

详情请参见 [Docker应用程序接口文档] (https://docs.docker.com/engine/api/v1.43/)！

构建 All in One 部署基础的步骤

1. 访问和更新实例

ssh -i {secure shell key 경로} {사용자 이름}@{IP 주소}

sudo apt-get update
sudo apt-get upgrade

如果设置的是 ubuntu，用户名通常是 ubuntu。

2. 防火墙设置

sudo ufw allow ssh    # ssh를 22로 대체할 수 있다.
sudo ufw allow http   # http를 80으로 대체할 수 있다.
sudo ufw allow https  # https를 443으로 대체할 수 있다.

sudo ufw enable 	  # 방화벽 가동
sudo ufw status 	  # 방화벽 상태 확인

如果你使用的是云，云默认有自己的端口安全设置，所以需要在设置中单独打开。 UFW 是 Ubuntu 的防火墙，如果第一次设置时关闭了，则需要允许端口后再打开。通过上述设置，你可以打开防火墙，并默认打开 HTTP(80)、HTTPS(443) 和 SSH(22) 端口。

建议先打开端口允许设置。如果在 SSH 端口 22 关闭的情况下打开防火墙，将无法连接到防火墙。

3. 安装 Docker 和 Docker Compose

# Docker 설치

sudo apt-get update
sudo apt-get install ca-certificates curl gnupg

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
https://download.docker.com/linux/ubuntu \
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Docker Compose 설치

sudo apt install docker-compose

Ubuntu Docker 安装文件

截至 2023 年 5 月，我只从文档中摘录了我需要的内容。

sudo usermod -aG docker $USER

该命令允许你在没有 sudo 的情况下使用 docker 命令。如果不包含它，你会得到 /var/run/docker.sock: connect: permission denied。

4. 编写 docker-compose.yml

version: '3.8'

networks:
  {원하는 네트워크 이름}:
    driver: bridge

services:

  # Jenkins Container 설정
  jenkins:
    container_name: jenkins
    image: jenkins/jenkins:lts
    restart: unless-stopped
    ports:
      - "{원하는 포트 번호}:8080"
    volumes:
      - ./mount/jenkins:/var/jenkins_home
      - /var/run/docker.sock:/var/run/docker.sock
    user: root
    environment:
      - TZ=Asia/Seoul
    networks:
      - {원하는 네트워크 이름}

部署管道工具的编写方式就像利用 Jenkins 一样。

如果没有需要添加的网络，可以完全省略网络部分，直接从 Docker 中为要使用的套接字进行卷绑定。你可以根据需要设置时区或其他卷绑定。

5. 为要使用的域设置 DNS

不同的域名提供商使用不同的方法。您需要查看域名提供商的注册说明，注册您要使用的服务器的 IP，并将其与您的域名关联起来。

我的 DNS 是什么

您不能注册后立即开始使用，DNS 服务器会有一个反映时间差。我在上面附上了一个网站，您可以轻松查看它的受欢迎程度。

6. 使用 Let's Encrypt 签发证书

1) docker-compose.yml

# Nginx 설정
  nginx:
    container_name: nginx
    image: nginx:latest
    restart: unless-stopped
    volumes:
      - ./mount/nginx/nginx.conf:/etc/nginx/nginx.conf 			# Nginx 설정을 위한 바인딩
      - ./mount/nginx/sites-available:/etc/nginx/sites-available
      - ./data/certbot/conf:/etc/letsencrypt				# 인증서 공유를 위한 바인딩
      - ./data/certbot/www:/var/www/certbot
    ports:
      - 80:80
      - 443:443
    environment:
      - TZ=Asia/Seoul
    networks:
      - {원하는 네트워크 이름}

  # Certbot 컨테이너 설정
  certbot:
    container_name: certbot
    image: certbot/certbot
    restart: unless-stopped
    volumes:
      - ./data/certbot/conf:/etc/letsencrypt
      - ./data/certbot/www:/var/www/certbot
    environment:
      - TZ=Asia/Seoul

将此添加到 docker-compose.yml，但不要处理它。

2) mount/sites-available/default.conf

server {
     listen 80;
     listen [::]:80;

     server_name my_domain.org; 

     location /.well-known/acme-challenge/ {
             allow all;
             root /var/www/certbot;
     }
}

文件，并在其中加入 server_name 后跟上您的域名。

3) mount/nginx.conf

user nginx;
worker_processes auto;
worker_priority 0;

pid /run/nginx.pid;
include /etc/nginx/modules-enabled/*.conf;

events {
        worker_connections 1024;
        multi_accept off;
}

http {

        sendfile on;
        tcp_nopush on;
        tcp_nodelay on;
        keepalive_timeout 65;
        types_hash_max_size 2048;
        server_tokens off;

        include /etc/nginx/mime.types;
        default_type application/octet-stream;
        log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                          '$status $body_bytes_sent "$http_referer" '
                          '"$http_user_agent" "$http_x_forwarded_for"';

        ssl_protocols TLSv1 TLSv1.1 TLSv1.2 TLSv1.3; # Dropping SSLv3, ref: POODLE
        ssl_prefer_server_ciphers on;

        access_log /var/log/nginx/access.log main;
        error_log /var/log/nginx/error.log debug;

        gzip on;

        include /etc/nginx/sites-available/*;

}

这是一个相当基本的配置，基于首次安装nginx时所包含的内容。

4) 通过 Let's Encrypt 签发证书，这是一个过程

curl -L https://raw.githubusercontent.com/wmnnd/nginx-certbot/master/init-letsencrypt.sh -o init-letsencrypt.sh
chmod +x init-letsencrypt.sh
vi init-letsencrypt.sh			# 여기서 도메인과 메일 주소를 입력해야 함
sudo ./init-letsencrypt.sh

从外部获取帮助你完成证书签发过程的文件，并设置权限。然后，你可以在文件中输入你的域名和电子邮件地址，并运行文件来签发证书。如果签发失败，你可以查看日志找出失败原因，修复后再试一次。

7. 为证书更新设置 Nginx

# Nginx 설정
  nginx:
    container_name: nginx
    image: nginx:latest
    restart: unless-stopped
    volumes:
      - ./mount/nginx.conf:/etc/nginx/nginx.conf
      - ./mount/sites-available:/etc/nginx/sites-available
      - ./data/certbot/conf:/etc/letsencrypt
      - ./data/certbot/www:/var/www/certbot
    ports:
      - 80:80
      - 443:443
    environment:
      - TZ=Asia/Seoul
    networks:
      - {연결을 원하는 네트워크 이름}
    command: "/bin/sh -c 'while :; do sleep 6h & wait $${!}; nginx -s reload; done & nginx -g \"daemon off;\"'"

  # Certbot 컨테이너 설정
  certbot:
    container_name: certbot
    image: certbot/certbot
    restart: unless-stopped
    volumes:
      - ./data/certbot/conf:/etc/letsencrypt
      - ./data/certbot/www:/var/www/certbot
    environment:
      - TZ=Asia/Seoul
    entrypoint: "/bin/sh -c 'trap exit TERM; while :; do certbot renew; sleep 12h & wait $${!}; done;'"

Let's Encrypt 签发的证书有效期有限，当证书即将过期时可以重新签发。你可以在 certbot 和 nginx 容器中添加与补发相关的命令，以自动处理证书更新。这样，nginx 就不会因为证书已签发而在构建容器时出错。

8.在 Jenkins 容器内安装 Docker

已添加）我原本直接列出了命令，但我意识到这并不直观，所以我修正了它！

# /jenkins-docker-install.sh

apt-get update
apt-get install ca-certificates curl gnupg

install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
chmod a+r /etc/apt/keyrings/docker.gpg

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
https://download.docker.com/linux/debian \
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
tee /etc/apt/sources.list.d/docker.list > /dev/null

apt-get update
apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

我创建了一个 sh 文件，可以从现有的 docker 安装方法中移除 sudo 命令。你可以通过挂载把这个文件放进去，然后运行它，就能实现干净利落的单间安装了！

9. 处理 Docker Compose

version: '3.8'

networks:
  {네트워크 이름}:
    driver: bridge

services:

  # Jenkins Container 설정
  jenkins:
    container_name: jenkins
    image: jenkins/jenkins:lts
    restart: unless-stopped
    ports:
      - "{포트 번호}:8080"
    volumes:
      - ./mount/jenkins:/var/jenkins_home
      - /var/run/docker.sock:/var/run/docker.sock
      - ./mount/jenkins-html:/var/lib/jenkins
      - ./jenkins-docker-install.sh:/jenkins-docker-install.sh
    user: root
    environment:
      - TZ=Asia/Seoul
    networks:
      - {네트워크 이름}

# Nginx 설정
  nginx:
    container_name: nginx
    image: nginx:latest
    restart: unless-stopped
    volumes:
      - ./mount/nginx/nginx.conf:/etc/nginx/nginx.conf
      - ./mount/nginx/sites-available:/etc/nginx/sites-available
      - ./data/certbot/conf:/etc/letsencrypt
      - ./data/certbot/www:/var/www/certbot
    ports:
      - 80:80
      - 443:443
    environment:
      - TZ=Asia/Seoul
    networks:
      - {네트워크 이름}
    depends_on:
      - {선행 컨테이너}
    command: "/bin/sh -c 'while :; do sleep 6h & wait $${!}; nginx -s reload; done & nginx -g \"daemon off;\"'"

  # Certbot 컨테이너 설정
  certbot:
    container_name: certbot
    image: certbot/certbot
    restart: unless-stopped
    volumes:
      - ./data/certbot/conf:/etc/letsencrypt
      - ./data/certbot/www:/var/www/certbot
    environment:
      - TZ=Asia/Seoul
    entrypoint: "/bin/sh -c 'trap exit TERM; while :; do certbot renew; sleep 12h & wait $${!}; done;'"

添加这些 Jenkins 配置后，运行

docker-compose -f {yml 파일 위치 및 파일명} up -d

命令调出所有容器。

docker exec -it jenkins bin/bash
sh /jenkins-docker-install.sh

通过在 Jenkins 容器内安装 Docker，我们可以通过 Jenkins 内部 Shell 命令控制 Docker 引擎。我们遵循了现有的 Docker 文档，但不同之处在于我们没有使用 sudo，而且我们安装的是 Debian 版 Docker。

可选

1. 设置交换内存

# swap memory 설정

sudo fallocate -l {설정 용량} /swapfile   # 설정 용량은 대체로 G 단위로 설정한다.
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

# 재부팅 시에도 지속 사용을 원할 경우

sudo vi /etc/fstab 			# '/swapfile swap swap defaults 0 0' 내용을 해당 파일에 삽입

# swap 비활성화

sudo vi /etc/fstab 			# '/swapfile swap swap defaults 0 0' 내용을 제거
sudo swapoff -v /swapfile
sudo rm /swapfile

根据实例性能和需求，您可能需要设置交换内存，以防止实例弹出。

2. 如果 Jenkins 插件安装错误，应尝试哪些方法

<解决方案 1 转到 Jenkins 管理 > 插件管理器 > 高级设置 > 更新站点部分将 https://updates.jenkins.io/update-center.json 更改为 http://updates.jenkins.io/update-center.json

<解决方案 2 安装名为 skip-certificate-check 的插件

这不是一个完美的解决方案，但我看到所有这些解决方案都取得了一些成功。

结论

关于 Docker，我就写到这里吧，除了稍后的一些框架部署。如果有机会，我以后会写更多关于部署的内容，因为在真实网络上看到自己的工作是一种很棒的感觉。

[面试问题] 什么是 RESTful API？

Sun, 21 May 2023 17:27:57 GMT

RESTful API

指 RESTful API。

不言自明，但听起来就是那么回事！让我们来看看每个单词的意思，你就会明白 RESTful API 是怎么回事了。

###应用程序接口

应用程序编程接口的简称。允许两个软件组件使用一套定义和协议相互通信的机制。

我是这样定义的。我对它的理解是，不同的软件组件有不同的方法来处理对象等，为了处理这种差异，需要建立一种约定，使它们能够相互通信和交互。

REST

表征状态转移。分布式超媒体系统（如万维网）的软件架构之一。

REST 最初是作为在互联网等复杂网络中管理通信的指南而创建的，据说它对于大规模通信是可靠的，而且易于实施和修改。

REST 架构的原则

统一接口（Uniform Interface）
- 服务器以标准格式发送信息
- 标准格式可能与服务器上资源的内部表示不同
- 对同一资源的所有应用程序接口请求都是一样的，与具体语言、平台等无关。
无状态
- 每个请求都独立于所有其他请求
- 服务器无需额外信息就能完全理解并满足请求
分层系统
- 不同的应用程序协同工作，以满足客户的要求
- 多层服务器，在服务器和客户端之间可能存在不同的授权中间人
- 额外的中介机构，如代理和网关、加密、负载平衡层等。
- 客户端不可见
可缓存（Cacheable）
- 支持缓存，以存储某些响应，从而缩短服务器响应时间
- 在客户端或服务器端实施缓存
按需代码（On Demand Code）
- 交付通常是静态的资源
- 在按需响应中包含可执行代码，允许您临时扩展或定制客户端功能

使用 RESTful API 的好处

可扩展性
- 可扩展性，因为它优化了客户端与服务器之间的交互
灵活性
- 支持客户端与服务器完全分离
- 简化和分离服务器组件，使每个部分都能独立发展
独立性
- 独立于所使用的技术
- 能够使用各种编程语言和变更技术编写客户端和服务器应用程序，而无需考虑应用程序接口的设计

摘要

什么是 RESTful API？它是指使用 REST 架构的应用程序编程接口，是一种组织遵守 REST 架构原则的程序之间交互的约定。

那么有什么好处呢？使用这些 API 的好处是可扩展性、灵活性和独立性！

另请参见。

[什么是 RESTful API？"(https://aws.amazon.com/ko/what-is/restful-api/)

[1天-1CS] 网络设备覆盖范围

Fri, 19 May 2023 17:06:42 GMT

2023-06-18 编辑内容范围

分级处理范围

应用层：L7 交换机
互联网层：L3 交换机、路由器
数据链路层：L2 交换机、网桥
物理层：网卡、中继器、接入点

开始整理您的面试问题！（问题历史记录）

Tue, 16 May 2023 22:32:46 GMT

仪器

我不知道从我开始认真地向公司投简历到现在有多久了......我想大概有三个月了吧，但我并没有通过所有的编码测试，但我通过了其中的不少测试，而且我最近还得到了几个面试机会！

但是，即使我去面试，即使我学过 CS，面试中出现的问题和我学过的 CS 知识还是有区别的......所以，我想在博客上写写面试中出现的问题和我在 Pinpoint 学习的内容。

问题列表

总体

什么是 RESTful API？](/blog/restful-api)
进程和线程的区别](/blog/process-thread)
- Fork和Exec的区别
框架与库](/blog/framework-library)
什么是事务？
关于 OSI 第 7 层
子网、网关和专用 IP

后台

什么是 DB 索引](/blog/db-index)
什么是连接池](/blog/connection-pool)
jvm의 구조와 원리
Java Heap & Stack의 구조
依赖注入](/blog/dependency-injection)
Spring IoC 容器如何管理 Bean + 代理模式、Spring Beans 如何成为代理以及如何实现多线程行为。
单例模式和Spring依赖注入

前端

在地址栏中输入访问 URL 时会发生什么情况

[1 天-1CS] 跨层数据传输与接收课程和 PDU

Sun, 07 May 2023 17:02:23 GMT

封装和解封过程

封装：将上层的报头和数据嵌入下层的数据部分，并插入该层的报头。

应用 → 传输 → 互联网 → 传递到链路层
分段或数据编排 + 添加 TCP（第 4 层）报头，因为它传递到传输层
转发到互联网层，添加 IP（第 3 层）报头 = 数据包
转发到链路层，添加帧头 + 帧拖尾 = 帧

解封装：从低层到高层时删除各层报头部分的过程

解封装反向进行
帧 → 数据包 → 网段、数据报 → 信息
最后在应用程序中作为传输数据单元（TDU）报文传送

协议数据单元

数据在层与层之间传递时的大块单位

不同层有不同的名称，如消息、段、数据报、数据包、帧、位等。
以比特为单位传输速度最快，效率最高
应用层基于字符串的发送和接收（因为易于扩展）

[1天-1CS] 半双工通信（2）、无线通信和以太网帧

Thu, 04 May 2023 14:01:28 GMT

半双工通信的类型

CSMA/CD: 发送数据，如果数据发送后发生碰撞，则在一段时间后重发
CSMA/CA：在发送数据前主动检测载波，尽可能避免碰撞。
- 发送数据前检查无线介质
- 确定线路是否空闲（载波检测）
- 如果忙，则根据随机值（IFS）以增加的间隔检查可用性

无线通信

Wifi：允许电子设备连接到无线局域网信号的技术；需要无线接入设备。
BSS（基本服务集）
- 代表基本服务集
- 通过路由器进行简单访问 + 接入点和同一 BSS 内的设备可相互通信
扩展服务集（ESS）
- 一组或多组已连接的 BSS
- 提供远距离无线通信
- 与 BSS 相比，具有更高的可用性和移动性
- 允许您从一个地点移动到另一个地点，并不间断地与网络保持连接

以太网帧

数据链路层使用的传输机制

序言：宣布以太网帧开始
SFD（起始帧分隔符）：表示 MAC 地址字段从下一个字节开始。
DMAC、SMAC：发送和接收 MAC 地址
以太类型：定义 IP 协议
有效载荷：接收到的数据
CRC：错误检查位

[BOJ 2473，Python] 三种解决方案

Thu, 04 May 2023 13:15:05 GMT

问题链接

boj 2473

分类

分段、排序、两个指针

描述

这是经典的双指针问题的稍高级版本。

当我第一次解这道题时，我认为一定有不同的解法，因为我必须把三种解法结合起来，所以我出乎意料地没有使用精确法，导致实际解题速度减慢。

这个问题最重要的一点是，解的总数必须在 5000 个以内。如果没有这个条件，这个问题就永远无法及时解决......可惜我一开始没有注意到这个条件，导致我一直在寻找其他解法。

因此，这个问题的解决方案可以表述如下。

排序→固定一个解→对其余解使用双指针算法，与该解求和，得到最接近 0 的解→当所有解都遍历或到达 0 时停止

求解代码

# 세 용액

import sys

input = sys.stdin.readline

solution_number = int(input())
solution_list = list(map(int, input().split()))

solution_list.sort()
characteristic_value = 3000000000

for idx in range(solution_number):

    pointer_1 = 0
    pointer_2 = solution_number - 1

    while pointer_1 < pointer_2:

        if pointer_1 == idx:
            pointer_1 += 1
        if pointer_2 == idx:
            pointer_2 -= 1

        if pointer_1 >= pointer_2:
            break

        now_value = sum([solution_list[idx], solution_list[pointer_1], solution_list[pointer_2]])

        if abs(now_value) < characteristic_value:
            characteristic_value = abs(now_value)
            result = [solution_list[idx], solution_list[pointer_1], solution_list[pointer_2]]

            if not characteristic_value:
                break

        if now_value < 0:
            pointer_1 += 1
        elif now_value > 0:
            pointer_2 -= 1

    if not characteristic_value:
        break

result.sort()

print(*result)

[1 天 1CS] 全双工和半双工通信 (1)

Mon, 01 May 2023 16:24:13 GMT

全双工通信

两台设备可同时发送和接收信号的方法。

发送和接收数据的发送路径和接收路径分开
现代快速以太网使用这种方法

半双工通信

两个设备可以相互通信，但不能同时通信基于一条路径，一次只能进行一个方向的通信

如果发送数据后发生碰撞，则会在一段时间后重新传输。
有线局域网
- 双绞线：电缆绞在一起以减少噪音（串扰）
- 光纤电缆：利用芯线和电缆的折射率差异传输光的电缆。
无线局域网
- 半双工通信，使用同一信道进行传输和接收。

[1天-1CS] 互联网层和链路层

Thu, 27 Apr 2023 03:32:49 GMT

互联网层

用于将从设备接收到的网络数据包传输到其 IP 地址指定的目的地的层。

链路层

建立设备间数据和信号实际传递规则的层，也称为网络接入层。

物理层：在局域网上发送由 0 和 1 组成的数据的层。
数据链路层：负责通过以太网帧进行错误检查、流量和访问控制。

[1天-1CS] 传输层

Tue, 25 Apr 2023 17:14:48 GMT

传输层

提供连接发送方和接收方的通信服务。提供面向连接的数据流支持、可靠性和流量控制充当应用层和互联网层之间的数据传输中介

TCP：保证顺序，使用面向连接的协议，并确认收到（虚拟线路数据包交换）
UDP：排序 X、确认 X、简单数据传输（数据报数据包交换）

虚拟线路数据包交换方法

每个数据包包含一个虚拟线路标识符
虚拟线路在所有数据包发送完毕后释放，数据包按发送顺序到达

数据报数据包的交换方式

数据包独立移动，选择最佳路径
可按不同路径和顺序发送

TCP 如何建立和中断连接

连接到 ####：三方握手

客户端发送带有 ISN 的连接请求标志； 2. 服务器发送服务器的 ISN 和客户端的 ISN + 1 以及授权号； 3.
客户端回复服务器的 ISN + 1 和授权号

断开连接：4 路握手

客户端发送 FIN 设置段并进入 FIN\WAIT 接收数据的服务器向客户端发送 ACK 确认段并进入 CLOSE_WAIT
在发送 ACK 一段时间后发送 FIN 段客户端收到 ACK，进入 TIME/WAIT（等待），并将 ACK 重新发送回服务器； 5. 接收服务器发送 CLOSE

使用 TIME_WAIT 的原因：可能出现延迟包，确认断开连接

[BOJ 7490，Python] 创建 0

Mon, 24 Apr 2023 16:15:36 GMT

问题链接

boj 7490

分类

回溯, 强制算法, 实现, 字符串

描述

我认为这是一个典型的反向追踪问题。不过，我发现处理过程有点深奥，ASCII 排序有点不寻常。

我看到可以用 Python 的 Eval 函数轻松解决这个问题，但我没有用它，而是用了一种困难的方法。

基本上，我取了一个数字和两个之前未处理的数字之和，然后进行回溯，以为它会检查 "加法"、"减法 "和 "无操作 "这三种情况，结果我得到了正确答案。

已解决代码。

# 0 만들기

import sys

input = sys.stdin.readline

def make_sum_zero(
    result_arr: set,
    target_arr: list,
    last_index: int,
    now_index: int = 0,
    sum_now: int = 0,
    now_calc: int = 0,
    log=[],
) -> None:
    """
    백트래킹을 활용하여 숫자들의 합이 0이 되도록 만드는 함수
    """
    if last_index == now_index:
        if not sum_now + now_calc:
            result_arr.add("".join(log))

    else:
        if not now_index:
            make_sum_zero(
                result_arr,
                target_arr,
                last_index,
                now_index + 1,
                0,
                target_arr[now_index],
                [str(target_arr[now_index])],
            )

        else:
            new_number = target_arr[now_index]

            make_sum_zero(
                result_arr,
                target_arr,
                last_index,
                now_index + 1,
                sum_now + now_calc,
                new_number,
                log + ["+", str(new_number)],
            )
            make_sum_zero(
                result_arr,
                target_arr,
                last_index,
                now_index + 1,
                sum_now + now_calc,
                -new_number,
                log + ["-", str(new_number)],
            )

            if now_calc < 0:
                make_sum_zero(
                    result_arr,
                    target_arr,
                    last_index,
                    now_index + 1,
                    sum_now,
                    10 * now_calc - new_number,
                    log + [" ", str(new_number)],
                )
            else:
                make_sum_zero(
                    result_arr,
                    target_arr,
                    last_index,
                    now_index + 1,
                    sum_now,
                    10 * now_calc + new_number,
                    log + [" ", str(new_number)],
                )

testcase = int(input())
output = []

for _ in range(testcase):
    arr_length = int(input())
    result = set()

    # 함수를 통해 결과 확인
    target_arr = [i for i in range(1, arr_length + 1)]
    make_sum_zero(result, target_arr, arr_length)

    # 혹여라도 겹치는 결과가 있다면 Set을 통해 배제, ASCII 순으로 정렬
    sort_result = sorted(list(result), key=lambda x: ascii(x))
    output.append(sort_result)

# 문제 조건에 맞춰 출력
for idx in range(testcase):
    for element_idx in range(len(output[idx])):
        print(output[idx][element_idx])

    if idx != testcase - 1:
        print("")

[1Day-1CS] TCP/IP 四层模型与应用层

Mon, 24 Apr 2023 15:18:37 GMT

互联网协议套件 (Internet Protocol Suite)

互联网中计算机之间用于交换信息的协议集合

可用TCP/IP四层模型或OSI七层模型进行说明

TCP/IP四层

根据网络范围，由四个抽象层组成
- 应用层
- 传输层
- 互联网层
- 链路层
OSI模型的特点是将应用层和链路层进一步细分

应用层

应用FTP、HTTP、SSH、SMTP、DNS等应用程序的协议层
- FTP：设备间的文件传输
- SSH：安全外壳协议（Secure Shell Protocol），一种加密网络协议
- HTTP：通过万维网（World Wide Web）访问网站所使用的协议
- SMTP：用于电子邮件传输的互联网标准通信协议
- DNS：负责将域名与IP地址进行映射的服务器
实际上是向用户提供服务的层

[BOJ 25542, Python] 约会地点

Sun, 23 Apr 2023 18:10:04 GMT

题目链接

[BOJ 25542](https://www.acmicpc.net/problem/25542

)

分类

暴力搜索算法、实现、字符串

说明

最初在比赛中遇到这道题时，我以为思路本身并不难。但这道题的实现比想象中要费工夫，而且7个月前的我连写Python代码都觉得非常吃力，因此没能解出这道题。

3个月前的我也曾试图解决这道题，但最终得出结论：构思的思路还需要额外的剪枝，结果再次受挫，只能暂时搁置这道题。

最近有了些空闲，加上想重新挑战之前没解出的题目，于是再次尝试，终于解出来了！不过，我仍然对这道题被归类为银牌题感到疑惑……

起初，我尝试仅使用已有的字符串来输出结果，但这显然存在反例，因此以失败告终。

之后尝试的代码虽然在实现上稍作改进，但依然只使用了已知的字符串，因此无法解决使用其他字符串的反例。附上代码如下。

import sys
from itertools import product

input = sys.stdin.readline

def is_similar(checker: str, target: str) -> bool:
	'''
    두 문자열이 비슷한지 확인하는 함수
    '''
    
    length = len(checker)
    counter = 0

    for idx in range(length):

        if checker[idx] != target[idx]:
            counter += 1

    if counter <= 1:
        return True
    
    else:
        return False

# 입력
store_number, name_length = map(int, input().split())

# 각 문자열의 동일 인덱스를 집합화
name_list = []
store_chr_arr = [set() for _ in range(name_length)]

for _ in range(store_number):
    each_name = list(input())
    name_list.append(each_name)

    for idx in range(name_length):
        store_chr_arr[idx].add(each_name[idx])

result = None

# 겹치지 않는 문자열의 Product를 비교
for each_name_combination in product(*store_chr_arr):
    target_name = ''.join(each_name_combination)
    
    is_answer = True

    for check_name in name_list:
        if not is_similar(target_name, check_name):
            is_answer = False
            break

    if is_answer:
        result = target_name
        break

if result is None:
    print('CALL FRIEND')

else:
    print(result)

虽然起初曾尝试使用未使用的字符，但因实现能力不足未能付诸实践，但通过该方法最终获得了“正解”判定。

解法代码

# 약속 장소

import sys

input = sys.stdin.readline

def is_similar(checker: str, target: str) -> bool:
    '''
    두 문자열이 비슷한지 확인하는 함수
    '''

    length = len(checker)
    counter = 0

    for idx in range(length):

        if checker[idx] != target[idx]:
            counter += 1

    if counter <= 1:
        return True
    else:
        return False

# 정보 입력
store_number, name_length = map(int, input().split())

name_list = []
first_checker = True

# 첫 문자열만 따로 분류하고 나머지는 이름 리스트에 기록
for _ in range(store_number):
    each_name = list(input().rstrip('\n'))

    if first_checker:
        target_name = each_name
        first_checker = False

    else:
        name_list.append(each_name)

# 첫 문자열을 통해 문자열 변형된 후보를 양산
result_set = set()

for idx in range(name_length):
    for alpha in range(65, 91):
        temp = target_name[:]
        temp[idx] = chr(alpha)
        result_set.add(''.join(temp))

# 확인하면서 후보를 소거
while result_set and name_list:

    now_check_name = name_list.pop()
    remove_target = set()

    for each_result in result_set:
        if not is_similar(now_check_name, each_result):
            remove_target.add(each_result)

    for each_target in remove_target:
        result_set.remove(each_target)

# 후보가 안 남았다면 문구를 출력, 후보가 남았다면 후보 중 하나를 출력한다.
if not result_set:
    print('CALL FRIEND')

else:
    print(result_set.pop())

[1 天-1CS]瓶颈、分类和网络分析

Sun, 23 Apr 2023 13:06:14 GMT

瓶颈

整个系统的性能或容量受到一个组件的限制。

在服务器上打开事件时，由于流量大且管理不善而造成
需要有关网络拓扑结构的信息，以正确排除瓶颈故障。
瓶颈的主要原因
- 网络带宽
- 网络拓扑结构
- 服务器 CPU、内存使用情况
- 网络配置效率低下

网络分类

网络根据规模分类

局域网
- 局域网
- 传输速度快且不受干扰
城域网
- 城域网
- 传输速度一般，比局域网更拥挤
广域网（WAN）
- 广域网
- 传输速度较慢，比城域网更拥挤

网络性能分析命令

ping
- 向要检查其状态的目标节点发送一定大小的数据包
netstat
- 显示连接服务的网络状态
- netstat * 显示网络连接、路由表、网络协议等列表。
nslookup
- 用于查找 DNS 相关内容
- nslookup * 用于查看哪些 IP 映射到特定域
tracert （跟踪路由）
- 用于验证到目标节点的网络路由
- 可用于查看响应时间变慢的位置等。
还有许多其他命令，可使用 wireshark、netmon 等程序。

[1天-1CS] 网络拓扑结构

Thu, 20 Apr 2023 12:56:24 GMT

网络拓扑结构

节点和链接的排列方式以及连接方式。

树状拓扑

分层拓扑结构，即以树形布局的网络组织。

易于添加和删除节点
流量集中在某个节点上会影响子节点

总线拓扑

将多个节点连接到一条中央通信线路上

用于局域网
安装成本低，可靠性高，易于在中央通信线路上添加和删除节点
存在欺骗问题

欺骗：在LAN上向未参与传输的另一台主机。 瘫痪或欺骗交换机，使其无法将数据包发送到指定节点。 将数据包当作来自特定节点的数据包。

星形拓扑

每个人都连接到中心节点的网络配置。

易于添加节点或检测错误
数据包不易碰撞
中央节点故障时整个网络不可用
安装成本高

环形拓扑

在节点之间移动数据，通过环形路径处理数据包

随着节点数量的增加，网络损耗很小
不易崩溃，更容易发现节点故障
难以更改网络配置
故障会影响整个网络

网状拓扑

网状拓扑，一种网状连接结构

存在多条路径，因此即使一个终端出现故障，网络仍可使用
流量可以分配
难以增加节点，建设和运营成本高昂

[1Day-1CS] 网络启动、吞吐量和延迟

Mon, 17 Apr 2023 14:32:41 GMT

简介

现在是自助书籍的季节，我觉得自己最近太忙了，但我认为继续学习是有帮助的，所以我要尽力而为！

网络

一组只相互连接或共享连接和资源的节点和链接。

节点：服务器、路由器、交换机等设备。链接：无线或有线

吞吐量和延迟

吞吐量和延迟 > 吞吐量大、延迟低、故障少、安全性好的网络。

吞吐量：链路中成功传递的数据量。
流量：任何给定时间内链路中流动的数据量。 → 更多流量 = 更多数据流。 → 更多吞吐量 = 处理更多流量。

吞吐量受流量、带宽、网络引起的错误和设备规格的影响

延迟：处理请求所需的时间，以往返次数衡量。

延迟受介质类型、数据包大小和路由器数据包处理时间的影响。

[1Day-1CS]设计模式与范例简述

Mon, 10 Apr 2023 16:56:14 GMT

简介

我现在写的所有东西都是基于《CS 专业面试知识笔记》。其实，我觉得我应该在第一天 CS 的开头就提到它，但我现在还是要写。

设计模式

通过对象之间的相互关系等来解决在设计程序时出现的问题的约定。

单例模式：1 类 1 实例/依赖注入器，解决模块耦合问题

工厂模式：父类提供框架，子类通过继承来完善框架。

策略模式：使用封装算法，并在上下文中进行交换

观察者模式：观察状态变化，并通过方法等传达变化。

代理模式：作为接口，在访问目标对象前拦截流程。

迭代器模式：使用迭代器访问集合中的元素，允许通过单个接口进行遍历。

ExposureModule 模式：创建一个访问控制器。

MVC 模式：由模型、视图和控制器组成，允许以分隔的方式开发应用程序的各个组件。

MVP 模式：用演示器取代控制器。

MVVM 模式：仅用视图模型代替控制器

编程范式

声明式与命令式 → 什么是声明式，什么是命令式？
声明式
- 函数式编程：堆叠纯函数来实现逻辑
命令式
- 面向对象编程：表达对象之间的交互，利用对象方法
- 面向过程的程序设计：包括连续计算，通过逐字执行代码来实现

[1Day-1CS] 过程式编程与范式的混合

Sat, 08 Apr 2023 15:32:23 GMT

过程式编程

由需要执行的连续计算过程构成
代码按照流程顺序实现，因此可读性好且运行速度快
存在难以模块化、可维护性较低的缺点

编程范式的选择

编程范式之间并不存在绝对的优劣之分
应根据服务特性或业务逻辑选择合适的编程范式
根据具体逻辑进行灵活选择也是可行的

[1Day-1CS] 面向对象编程的设计原则

Thu, 06 Apr 2023 12:27:00 GMT

单一职责原则

Single Responsibility Principle

每个类都应只承担一项职责。

开闭原则

Open Closed Principle

在维护时，应尽量减少对现有代码的修改，并确保代码易于扩展。

里斯科夫替换原则

Liskov Substitution Principle

对象应能够被替换为其子类型的实例，且不破坏程序的正确性。这意味着继承机制必须能够正常运作，确保没有问题。

接口隔离原则

Interface Segregation Principle

应创建多个具体的接口，而非一个通用的接口

依赖倒置原则

Dependency Inversion Principle

上层应独立于下层的变更，应使用上层类或抽象接口，以避免受到比自身更易变的事物的影响。

三星软件能力评估 B 类审查

Thu, 06 Apr 2023 12:08:47 GMT

简介

我先说结论：迄今为止，我错过了三次机会中的两次。因此，我想给大家留下一些关于如何在未来取得成功的建议。

资质

我参加了三星青年软件学院的模拟能力评估，获得了 A 级资格。

回顾

过去，我觉得自己不仅在实现方面花了太多时间，在优化方面也有所欠缺。我还有一次考试机会，我想我应该多学习优化方面的知识。

1. 对象使用不佳

也许是因为我来自 Python 的缘故，我不习惯用对象来编码，我也尝试着掌握了很多，但还是觉得自己不够好。特别是，我发现很难覆盖和使用 Comparator 等部分...

2. 熟悉数据结构

如果你听 B 类通过者的故事，他们非常强调材料结构，但如果你问我是否已经掌握了足够的材料结构，我认为在最终测试之前我仍然需要有足够的时间来复习。

+ 更多

四月底标志着我为期三个月的 B 型旅程的结束。结果，我没有拿到 B 类资格证书，我很失望，因为我离最后一题很近，却没能迈出最后一步。

但我努力了，所以我尝试了，我很高兴我做到了，而且我能够取得一些进展。

在参加企业工作的编码测试时，这绝对是一个优势。

我现在取得的资格可能是临时 A 级，所以 SSAFY 之后我就没有机会再考 B 级了，但能再考一次也不错！

[1天-1CS]执行程序设计与面向对象程序设计

Fri, 31 Mar 2023 11:39:05 GMT

命令式编程的类型

面向对象编程

将程序的交互作用表示为对象集合，并在对象内部声明方法。
设计需要大量时间，比其他编程范式慢。

面向对象编程的特点

抽象：从复杂系统中提炼出关键概念、特征和功能。
封装：将对象的属性和方法捆绑在一起，并对外界隐藏其中的一些属性和方法。
继承：允许子类继承父类的特征，使其可以重复使用、添加和扩展。
多态性：一个方法或类可以有多种不同的行为方式。
重载：拥有多个同名方法；在 "编译 "过程中出现的 "静态 "多态性
重载：重载：子类重载从父类继承的方法，"动态 "多态性发生在 "运行时"。

[1天-1CS]声明式编程

Fri, 31 Mar 2023 11:36:56 GMT

编程范式

让程序员获得编程视角的开发方法论

声明式 vs 命令式

声明式: 关注解决什么的范式 (What)
命令式: 关注如何解决的范式 (How)

例) 声明式: 家的地址 (准确指定位置) 命令式: 到家的路线 (提示如何到达位置的方法)

声明式编程的种类

函数式编程

把小的纯函数像积木一样叠起来构建逻辑、通过实现高阶函数提升复用性的编程范式

纯函数: 输出仅依赖于输入的函数

高阶函数: 把函数作为值通过参数接收并构建逻辑的函数

如果语言支持一级对象 (First Class Object) 就可以使用高阶函数

一级对象的特征

可以把函数赋值给变量或方法

可以把函数作为参数嵌入到函数中

函数可以返回函数

[1天-1CS] MVC 模式和类似模式

Thu, 30 Mar 2023 16:36:43 GMT

MVC 模式

由模型、视图、控制器组成的设计模式

将应用程序的组件分为三部分，使您可以专注于每个组件并分别进行开发
促进可重用性和确定性
缺点是随着应用程序复杂性的增加，模型和视图之间的关系也会变得更加复杂

模型

应用程序中的数据，指数据库、常量、变量等。

视图

指用户界面元素，即用户根据模型可以看到的屏幕。

不存储模型的任何信息，只存储屏幕显示信息

发生变化时，将变化传递给控制器。

控制器

充当模型和视图之间的桥梁

负责事件等主要逻辑，并管理生命周期

当模型或视图发生变化时，它会向所需组件发送相应的内容。

类似模式

MVP 模式：用演示器代替控制器，由于视图和演示器之间的关系是 1:1，因此耦合度更高
MVVM 模式：用视图模型取代控制器，具有命令和数据绑定功能，实现了用户界面的可重用性，并简化了单元测试

[1Day-1CS] 代理模式、迭代器模式和暴露模块模式

Tue, 28 Mar 2023 23:30:10 GMT

代理模式

一种设计模式，在访问目标对象之前，通过拦截目标对象的流程，在目标对象前充当接口。
用于安全、数据验证、缓存、日志记录，以及作为服务器而非对象使用。

代理服务器

在服务器和客户端之间工作
允许客户通过它间接访问其他网络服务的系统或程序。

例如 Apache、Nginx、CloudFlare 等。

代理服务器使用示例

通过代理，可以隐藏实际使用的端口
可以通过 Nginx 压缩静态资源，或登录到主服务器的前端
CloudFlare 可轻松部署 HTTPS 并抵御 DDOS 攻击
前端代理服务器可用于防止跨源资源共享（CORS）错误

迭代器模式

通过迭代器访问集合元素的设计模式

无论数据类型的结构如何，都可以通过一个接口：迭代器来遍历它们。
通常情况下，可迭代对象可以通过迭代器协议进行遍历

公开模块模式

通过立即执行函数创建访问控制器（如 private 和 public）的模式

在 JS 的情况下，没有单独的访问控制器，因此也可以通过执行来建立访问控制器

[1Day-1CS] 工厂模式 & 策略模式 & 观察者模式

Mon, 27 Mar 2023 22:36:03 GMT

工厂模式

一种将对象创建部分从使用对象的代码中抽象出来的模式
父类决定重要的框架结构
子类决定对象创建的具体细节

工厂模式的特点与优点

通过类分离实现松耦合确保父类的灵活性并提高可维护性

策略模式

若不想改变对象的行为，则不直接修改
通过在上下文中更换作为策略的封装算法，使其设计为可替换

上下文

指开发人员完成某项工作所需的相关信息
存在为使某种行为发生而必不可少的必要上下文，以及为有效执行该行为而存在的可选上下文。

观察者模式

主体观察特定对象的状态变化
状态发生变化时，通过方法等方式向观察者提供变化信息
有时不将主体与对象分离，而是基于可变对象进行构建
该模式也应用于 MVC 模式中

[1天-1CS] 单件模式

Mon, 27 Mar 2023 15:29:32 GMT

什么是设计模式？

设计程序时遇到问题

→ 利用对象之间的相互关系等创建一个约定来解决它。

单例模式

一个类 = 一个实例
我们可以为每个类创建多个独立的实例，但我们不会这样做，我们只使用一个实例
通常用于 DB 模块
生产力 ↑，依赖性 ↓

单例模式的缺点

在 TDD（测试驱动开发）过程中进行单元测试时可能出现问题

由于单例模式的高度依赖性，很难为每个测试创建一个独立实例

依赖注入

解决单例模式模块间耦合性强的缺点的一种方法
主模块不直接向其他子模块提供依赖关系，而是通过依赖关系注入器（解耦）间接注入依赖关系。

优点

更容易替换模块、更容易测试和迁移、依赖关系方向一致、更容易推理应用程序、关系清晰等。

缺点

模块的解耦程度更高 → 由于类的数量增加，运行时的惩罚增加了复杂性

依赖注入原则

父模块不从子模块导入任何内容
两者都必须依赖抽象 + 抽象不依赖细节

[CI/CD] 基于 Docker + Jenkins + Git Webhook 的 FastAPI 服务器自动部署总结

Fri, 24 Mar 2023 02:08:12 GMT

内容整理中 > 截至 2023 年 5 月、第 1 次更新完成关于部署的内容，建议参考整理得更好的第 2 篇。

序言

在当前进行的项目中，我正在构建一个利用 AI 模型提供输出的服务。

我原本想用 Firebase Cloud Function 来构建这一功能，但加载模型时由于使用 nodeJS + tensorflow.js 不得不转换模型，且其本身就比较重，导致不断超时等，被各种方式卡住，于是决定构建一个简单的服务器来返回 AI 模型的结果。

因此服务器的构建与部署便落到我身上，第一阶段目标是实现自动部署，之后的追加目标是用自己的手实现零停机部署。

本文仅涉及基于 AWS 等实例构建系统并实现自动部署为止的内容。

前置概念学习

CI: Continuous Integration (持续集成)

这是面向开发者的自动化流程，代码变更经过构建和测试后定期合并到共享仓库的过程，把这个过程自动化能够减少开发过程中的风险，因此被广泛采用

由 CI Server, Source Control Management, Build Tool, Test Tool 等组成

CD: Continuous Delivery / Deployment (持续交付 / 持续部署)

指部署自动化流程，通过对管线后续阶段的自动化，变更可以无须人工干预自动部署到 product。需要持续集成的支撑，构建可信赖的环境后甚至每天都能进行多次发布

由此可见，通过这种 CI/CD 过程，可以缩短产品上市的时间、提升人力效率，且都是渐进而持续的过程，因此能够降低出现重大问题的概率。

Docker 环境配置

实例信息

没有使用 EC2 免费层，而是选择条件相对更好的 Oracle Cloud 免费层分配并使用基于 arm64 的 Ampere A1 Compute 2 核与 12GB RAM

此外它也免费提供一定程度的备份等选项，可以参考！

Linux 配置使用 password 连接 EC2 的方法 - 介绍 ssh 配置以提升登录便利性的文章 Docker 安装 - 基于 Ubuntu 的 Docker 安装官方 DOCS

我整理了自己参考过的资料，关于 Docker 安装过程和实例配置的文章很多，可以一边查阅一边配置 Docker。

Docker in Docker 配置 (失败 > 改用通过 API 的 Docker out of Docker 进行)

使用理由

在 Docker 之上再操作 Docker 的理由是为了通过容器来控制容器，从而让该容器拥有非常强的权限，虽然会带来安全风险，但本身仍然很有吸引力。

曾尝试的配置方法

1. 在 Docker 上构建 Jenkins 容器

首先在 Docker 中构建 Jenkins 容器。使用 Docker Compose 可以更轻松地构建，可以参考。

docker pull jenkins/jenkins:lts

首先拉取 Jenkins LTS 版本的容器。

vim docker-compose.yml

通过此命令创建或打开 yml 文件。

version: "2.5.0" # 输入 compose 版本

services:

  jenkins:
    container_name: jenkins
    image: jenkins/jenkins:lts # 使用 Jenkins LTS 版本
    restart: always # 自动重启选项

    ports:
      - "8181:8080" # 把 host 的 8181 端口映射到 Jenkins 的 8080 端口

    volumes: # 通过此选项可以共享 host 的 volume
      - /home/opendocs/jenkins:/var/jenkins_home
      - /var/run/docker.sock:/var/run/docker.sock

    user: root
    privileged: true # 实现 Docker In Docker 的关键选项

按示例代码所示在 yml 文件中写入所需内容。

docker-compose -f {文件名} up

通过此命令可以基于 docker-compose.yml 进行配置；若沿用 docker-compose.yml 作为文件名，则无需 -f 选项。具体内容请参考 Docker Compose Docs！

Docker Compose Documents

+ 不使用 sudo 操作 docker 的方法 → 把当前用户加入 Docker 组

# 通过此命令把当前用户加入 Docker 组
sudo usermod -aG docker $USER

2. Jenkins Container 配置

通过浏览器访问已配置 IP 上 Docker 分配的 Port Number
把 Jenkins 安装日志中的 key 输入到页面中

# 通过此命令可以查看容器日志
docker logs jenkins

安装推荐插件

可能会出现问题，但先把安装收尾，再处理后续问题。不收尾的话，未安装插件造成的依赖错误会持续出现…

插件安装 Time Out 解决方法

安装 GitHub API Plugin

这是协助 Webhook 触发器工作的插件。安装吧。安装后把 Git ID/PW 注册为 Secret。

3. Github 配置

在 Settings 的 Developer Settings 中创建 Token。截至撰写本文，使用 Classic token，权限只需 repo, admin:repo_hook 即可。
在自动部署 Repo 的设置中向 Webhooks 添加 Webhook。大致设置为 http://{jenkins_url}/github-webhook/ 即可。去掉最后的 / 可能会有问题，老实地保留它吧。

4. Jenkins 项目配置

添加项目。
构建配置 - 在源代码管理选 Git 并选择已经注册的 Secret，就可以接收 webhook 信号。
必须选择 GitHub hook trigger for GITScm polling 选项，触发器才会工作。
视情况进行分支选定后完成配置并进行测试。

[BOJ 4803, Java] 树

Tue, 28 Feb 2023 00:26:49 GMT

题目链接

[BOJ 4803](https://www.acmicpc.net/problem/4803

)

分类

数据结构(data_structures)、深度优先搜索(dfs)、不相交集合(disjoint_set)、图论(graphs)、图遍历(graph_traversal)、树(trees)

说明

这是一道利用树的性质来统计树的数量的问题。本题可以通过排除由连接元素构成的结构中的环来解决。

检查所有节点是否已被访问
对于未访问的节点，将其纳入树中并进行深度遍历
若形成环，则将构成该环的所有节点标记为已访问
若未形成环，则该集合为树，计数为1

通过上述逻辑进行了实现，在思考如何在深度遍历过程中进行计数处理后，最终编写了如下代码：


    public static int dfs(int nowNode, int parent, boolean[] visitLog, HashMap<Integer, ArrayList<Integer>> graph) {

        for (int nextNode : graph.get(nowNode)) {

            if (nextNode != parent && !visitLog[nextNode]) {

                visitLog[nextNode] = true;

                int result = dfs(nextNode, nowNode, visitLog, graph);
                if (result == 0) {
                    return 0;
                }

            } else if (nextNode != parent && visitLog[nextNode]) {
                return 0;
            }

        }

        return 1;

    }

该代码从起始点开始以递归形式进行访问和检查，当出现环时，默认遍历所有节点后返回0。

如果未出现环路，则正常结束遍历并返回1，通过持续累加该函数的返回值，即可得知树的数量！

解法代码


import java.io.*;
import java.util.*;

public class Main {

    public static int dfs(int nowNode, int parent, boolean[] visitLog, HashMap<Integer, ArrayList<Integer>> graph) {

        for (int nextNode : graph.get(nowNode)) {

            if (nextNode != parent && !visitLog[nextNode]) {

                visitLog[nextNode] = true;

                int result = dfs(nextNode, nowNode, visitLog, graph);
                if (result == 0) {
                    return 0;
                }

            } else if (nextNode != parent && visitLog[nextNode]) {
                return 0;
            }

        }

        return 1;

    }

    public static void main(String[] args) throws IOException {

        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));

        int testCase = 0;

        ArrayList<String> outputArr = new ArrayList<>();

        while (true) {

            StringTokenizer treeInfo = new StringTokenizer(input.readLine(), "[ ]");
            int nodeNumber = Integer.parseInt(treeInfo.nextToken());
            int edgeNumber = Integer.parseInt(treeInfo.nextToken());

            if (nodeNumber == 0 && edgeNumber == 0) {
                break;
            }

            testCase += 1;

            int treeCount = 0;
            boolean[] isVisited = new boolean[nodeNumber + 1];

            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append("Case ");
            stringBuilder.append(testCase);
            stringBuilder.append(": ");

            HashMap<Integer, ArrayList<Integer>> treeGraph = new HashMap<>();
            for (int i = 1; i < nodeNumber + 1; i++) {
                treeGraph.put(i, new ArrayList<>());
            }

            for (int i = 0; i < edgeNumber; i++) {

                StringTokenizer edgeInfo = new StringTokenizer(input.readLine(), "[ ]");
                int startNode = Integer.parseInt(edgeInfo.nextToken());
                int endNode = Integer.parseInt(edgeInfo.nextToken());

                treeGraph.get(startNode).add(endNode);
                treeGraph.get(endNode).add(startNode);

            }

            for (int i = 1; i < nodeNumber + 1; i++) {

                isVisited[i] = true;
                treeCount += dfs(i, 0, isVisited, treeGraph);
            }

            if (treeCount == 0) {
                stringBuilder.append("No trees.");
            } else if (treeCount == 1) {
                stringBuilder.append("There is one tree.");
            } else if (treeCount > 1) {
                stringBuilder.append("A forest of ");
                stringBuilder.append(treeCount);
                stringBuilder.append(" trees.");
            }

            outputArr.add(stringBuilder.toString());

        }

        for (int i = 0; i < testCase; i++) {

            if (i != testCase - 1) {
                output.write(outputArr.get(i) + "\n");
            } else {
                output.write(outputArr.get(i));
            }

        }

        output.flush();
        output.close();

    }

}

[BOJ 1485, Python] 正方形

Sat, 25 Feb 2023 03:05:13 GMT

题目链接

BOJ 1485

分类

几何(geometry), 排序(sorting)

说明

通过该流程即可判断是否为正方形。

检查连接4个点的6条边的长度
排序
检查前4条边的长度是否相同
检查后2条边是否符合正方形的对角线长度
仅当所有条件均满足时，才判定为可绘制正方形

解法代码

# 정사각형

import sys
from math import sqrt, isclose
from itertools import combinations

input = sys.stdin.readline

def distance(coord_1: list, coord_2: list) -> int:
    return sqrt(pow(coord_1[0] - coord_2[0], 2) + pow(coord_1[1] - coord_2[1], 2))

testcase = int(input())

output = []

for _ in range(testcase):

    is_square = True

    coord_info = []

    for _ in range(4):
        coord_info.append(list(map(int, input().split())))

    edge_info = []

    for edge_distance in combinations(coord_info, 2):
        edge_info.append(distance(edge_distance[0], edge_distance[1]))

    edge_info.sort()

    for idx in range(1, 4):
        if not isclose(edge_info[0], edge_info[idx]):
            is_square = False
            break

    if is_square:
        for idx in range(4, 6):
            if not isclose(pow(edge_info[0], 2) * 2, pow(edge_info[idx], 2)):
                is_square = False
                break

    if is_square:
        output.append(1)

    else:
        output.append(0)

for result in output:
    print(result)

[BOJ 12850, Java]漫步主校园 2

Wed, 22 Feb 2023 14:05:40 GMT

问题链接

boj 12850

分类

exponentiation_by_squaring, graph theory, maths, divide-and-conquer

描述

除法与征服（Devide and Conquer）

一种通过将难以解决的问题分解成更小问题来解决的算法。

这个问题可以通过绘制邻域矩阵来解决，并知道到达目的地的次数就是对邻域矩阵进行 n 次平方运算的次数。

这确实需要学习一些分而治之和矩阵运算的知识，但我认为这是一个结合了几个较低层次问题的合理难度。

解题代码

import java.io.*;
import java.util.*;

public class Main {

    public static HashMap<Integer, int[][]> matrixRecord = new HashMap<>();

    public static int[][] matrixCalculation(int[][] matrix1, int[][] matrix2) {
        /* 행렬 연산 함수 */

        int[][] resultArr = new int[8][8];

        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {

                long sum = 0;

                for (int k = 0; k < 8; k++) {
                    sum += ((long) matrix1[i][k] * (long) matrix2[k][j]) % 1000000007;
                }

                resultArr[i][j] = (int) (sum % 1000000007);

            }
        }

        return resultArr;
    }

    public static int[][] matrixDivision(HashMap<Integer, int[][]> matrixInfo, int calculationCount) {
        /* 분할 정복을 통한 행렬 연산 함수 */

        int halfCount = calculationCount / 2;

        int[][] halfMatrix;
        int[][] otherHalfMatrix;

        // 기존 값이 존재할 경우 불러오기
        if (matrixInfo.containsKey(halfCount)) {
            halfMatrix = matrixInfo.get(halfCount);
        } else {
            halfMatrix = matrixDivision(matrixInfo, halfCount);
        }

        if (matrixInfo.containsKey(calculationCount - halfCount)) {
            otherHalfMatrix = matrixInfo.get(calculationCount - halfCount);
        } else {
            otherHalfMatrix = matrixDivision(matrixInfo, calculationCount - halfCount);
        }

        // 연산 후 행렬 반환
        int[][] calculationResult = matrixCalculation(halfMatrix, otherHalfMatrix);
        matrixInfo.putIfAbsent(calculationCount, calculationResult);

        return calculationResult;
    }

    public static void main(String[] args) throws IOException {

        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));

        int walkTime = Integer.parseInt(input.readLine());

        // 기본 행렬 및 본대 인접 행렬 선언
        int[][] baseMatrix = {
                {1, 0, 0, 0, 0, 0, 0, 0},
                {0, 1, 0, 0, 0, 0, 0, 0},
                {0, 0, 1, 0, 0, 0, 0, 0},
                {0, 0, 0, 1, 0, 0, 0, 0},
                {0, 0, 0, 0, 1, 0, 0, 0},
                {0, 0, 0, 0, 0, 1, 0, 0},
                {0, 0, 0, 0, 0, 0, 1, 0},
                {0, 0, 0, 0, 0, 0, 0, 1},
        };

        int[][] graph = {
                {0, 1, 1, 0, 0, 0, 0, 0},
                {1, 0, 0, 1, 0, 0, 0, 0},
                {1, 0, 0, 1, 1, 0, 0, 0},
                {0, 1, 1, 0, 1, 1, 0, 0},
                {0, 0, 1, 1, 0, 1, 1, 0},
                {0, 0, 0, 1, 1, 0, 1, 1},
                {0, 0, 0, 0, 1, 1, 0, 1},
                {0, 0, 0, 0, 0, 1, 1, 0},
        };

        // 해시맵에 초기값들 등록
        matrixRecord.put(0, baseMatrix);
        matrixRecord.put(1, graph);

        // 함수를 통해 분할정복 연산 실행
        matrixDivision(matrixRecord, walkTime);

        // 결과 출력
        output.write(Integer.toString(matrixRecord.get(walkTime)[7][7]));

        output.flush();
        output.close();

    }

}

重构 1 - 1.类型"... "不能分配给类型"..."

Tue, 21 Feb 2023 16:40:07 GMT

<Button
onClick={handleLogin}
variant="contained"
  >
    LOGIN
</Button>
<Button onClick={handleGoogleLogin}>
  <img
src={logoSrc}
alt="alternative image"
/>
  <p>Social Login</p>
</Button>

问题

在 TypeScript 中使用 map 重建此代码时，发生了错误。

Type 'string' is not assignable to type '"text" | "outlined" | "contained" | undefined'"。

我使用的是 MUI，它在 MUI 按钮的变体属性值中出现了错误。为了解决这个问题，我挣扎了一段时间，在通过 StackOverFlow 和 ChatGPT 进行大量搜索后，我终于找到了答案。

解决方案。


type Variant = "text" | "outlined" | "contained" | undefined;

interface SubmitButtonProps extends ButtonProps {
  variant?: Variant;
  onClick?: () => Promise<void>;
  contains?: React.ReactNode;
}

{loginButtonSettings.map(
  ({ onClick, contains, variant }: SubmitButtonProps, index: number) => (
    <SubmitButton
    key={index}
  	onClick={onClick}
	contains={contains}
	variant={variant}
	/>
  )
)}

如上所示，我们需要通过 type 值为变量预先定义属性值，还需要将其附加到接口上。事实上，这一部分比我们下面要写的内容更重要。

const loginButtonSettings = [
  {
    onClick: loginHandler,
    contains: <div>Login</div>,
    variant: "contained" as Variant, // 바로 여기!
  },

正如你所看到的，"contained（包含）"一般被识别为字符串，因此我们需要确保它是变量属性值中包含的值！

进入重构

Tue, 21 Feb 2023 16:26:20 GMT

记录原因

我已经为一个项目工作了大约 7 周，时间有长有短，我想我已经有一些时间来了解 React 了。但和我想的不一样，我想让这位朋友长得整整齐齐，但不知怎么的，就像看着胡须乱长一样......

于是我想，"让我们来修正这段代码吧！"我打算写一个简短的项目历史，并借此机会尝试一下 TypeScript。

为什么选择 React？

在我之前的项目中，我有机会使用 VueJS，所以我有过基于 Vue 编写代码的经验，但我没有足够的经验来比较优缺点，而且我之前甚至没有使用过 React，所以我想，"它是现在最热门的框架，让我们试试吧！"。我认为这是一个体验 React 优点而不是 Vue 缺点的机会。

生态系统广泛

我认为这是一个众所周知的优势，无论是在数量上还是在其他方面，但我在 Vue 中使用的大多数库在 React 中也有，我觉得这才是最主要的，而 Vue 只是一个免费赠品。

直观

我不知道是不是因为我还没有用过很多 Hooks，但在如何处理 Props 和如何编写代码方面，我感觉更得心应手。

在 UE 中，我感觉代码之间的区别感是通过编写模板、脚本以及头部、胸部和腹部等样式来实现的，但 React 基本上是以一种不区分 JavaScript 代码的方式来编写 Fuction Components 的，因此我感觉在访问变量等方面要方便得多。

当然，如果像 Vue 那样将它们分开，可能会更容易阅读代码，但在编写标准方面还是有明显区别的，即使是现在，如果要问 "我应该使用什么？"我也会使用 React。

事件处理很方便

这与上文有点相似，但我记得编写 EventHandlers 比使用 Vue 时要直观得多。在 Vue 的情况下，我认为有很多部分都将函数和变量分开了，但 React 允许你当场声明和处理变量，就像使用一般的编程语言一样，所以这种感觉就像我以前每天吃的白癜风能治好吗一样，温暖而舒适。

为什么要使用 TypeScript？

虽然 React 的利弊可能与实际行业中的利弊不同，但我个人能够指出 React 的上述优点，在重构过程中还是选择了 React。

同样，我认为在重构时写下我想使用 TS 而不是 JS 的原因也是不错的，所以就留在这里吧。

错误捕获

我认为 TS 的很多优点都是针对 JS 的缺点的。基本上，我认为 JS 是一种非常松散的语言，而事实也是如此，因此有时错误会发生在奇怪的地方，而且很难解决，我希望 TS 能很好地捕获这些错误。

熟悉性

作为一种编程语言，JS 有很多我个人不喜欢的地方，这是因为它不可避免的发展历史。然而，TS 显然是基于 JS 的，但它提供了一种非常严密的结构，解决了我对 JS 感到失望的问题！当然，我还可以做得更多，但熟悉稳定的结构所带来的舒适感是我使用 TS 的动力...

结论

我将继续写下我的心得，并在今后的文章中与我以前的代码进行比较。我不知道这需要多长时间，但我希望这是一个非常有意义的过程！

[BOJ 1922, Java] 网络连接

Mon, 20 Feb 2023 07:55:51 GMT

题目链接

BOJ 1922

分类

图论，最小生成树

说明

引言

最近只顾着做题，感觉对理论有些疏忽，因此想在记录解题过程的同时，哪怕只是简单地梳理一下理论。

MST（minimum spanning tree，最小生成树）

什么是生成树？

指包含图中所有顶点的树。

最小生成树

指在所有生成树中总边长最短的那棵

主要特征

包含 n 个顶点，且拥有 (n - 1) 条边由于边长最小，因此可用于企业内部网络构建等场景

普雷姆算法

选择 1 个初始顶点
从MST中包含的顶点所连接的边中，依次选择最短的边
当所有顶点均被连接时结束

克鲁斯卡尔算法

按权重对所有边进行排序
在不形成环的情况下，依次添加边
当所有顶点均被连接时结束

解题代码

import java.io.*;
import java.util.*;

public class Main {

    // 간선 정보 클래스 선언
    public static class Connection implements Comparable<Connection> {

        private final int cost;
        private final int start;
        private final int end;

        public Connection(int cost, int start, int end) {
            this.cost = cost;
            this.start = start;
            this.end = end;
        }

        // 가중치를 통한 비교
        public int compareTo(Connection other) {
            return this.cost - other.cost;
        }

    }

    // 정점의 집합을 확인하는 함수
    public static int checkUnion(int[] unionInfo, int targetVertex) {

        if (unionInfo[targetVertex] != targetVertex) {
            unionInfo[targetVertex] = checkUnion(unionInfo, unionInfo[targetVertex]);
        }

        return unionInfo[targetVertex];
    }

    // 정점 2개가 집합을 이루는지 확인하는 함수
    public static boolean isUnion(int[] unionInfo, int vertex1, int vertex2) {
        return checkUnion(unionInfo, vertex1) == checkUnion(unionInfo, vertex2);
    }

    // 집합을 합쳐주는 함수
    public static void makeUnion(int[] unionInfo, int vertex1, int vertex2) {

        int group1 = checkUnion(unionInfo, vertex1);
        int group2 = checkUnion(unionInfo, vertex2);

        if (group2 > group1) {
            unionInfo[group2] = group1;
        } else {
            unionInfo[group1] = group2;
        }

    }

    public static void main(String[] args) throws IOException {

        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));

        // 정점 및 간선의 갯수 입력
        int vertexNumber = Integer.parseInt(input.readLine());
        int edgeNumber = Integer.parseInt(input.readLine());

        // 간선 정보를 담을 우선순위 큐 선언
        PriorityQueue<Connection> costPriorityQueue = new PriorityQueue<>();

        // 간선 정보 입력
        for (int i = 0; i < edgeNumber; i++) {
            StringTokenizer connectionInfo = new StringTokenizer(input.readLine(), "[ ]");

            int startNode = Integer.parseInt(connectionInfo.nextToken());
            int endNode = Integer.parseInt(connectionInfo.nextToken());
            int cost = Integer.parseInt(connectionInfo.nextToken());

            Connection connection = new Connection(cost, startNode, endNode);
            costPriorityQueue.add(connection);

        }

        // 집합에 포함된 정점의 갯수와 최소 가중치 정보를 담을 변수 선언
        int totalCost = 0;
        int totalEdge = 0;

        // 집합 정보를 담을 배열 선언
        int[] groupInfo = new int[vertexNumber + 1];
        for (int i = 0; i < vertexNumber + 1; i++) {
            groupInfo[i] = i;
        }

        // Kruskal's Algorithm
        while (totalEdge < vertexNumber - 1 && !costPriorityQueue.isEmpty()) {

            // 가중치 순으로 확인
            Connection nowConnection = costPriorityQueue.poll();

            // 집합 관계를 확인하여 아직 집합이 아닌 경우 집합에 추가하고 가중치 가산
            if (!isUnion(groupInfo, nowConnection.start, nowConnection.end)) {
                makeUnion(groupInfo, nowConnection.start, nowConnection.end);
                totalEdge += 1;
                totalCost += nowConnection.cost;
            }

        }

        // 최종 최소 가중치값 출력
        output.write(Integer.toString(totalCost));

        output.flush();
        output.close();

    }

}

[BOJ 14503，Java] 机器人真空吸尘器

Sat, 18 Feb 2023 12:31:09 GMT

问题链接

boj 14503

Classification.

实施、模拟、仿真

描述

这是一个典型的实施问题，但问题的描述有点难以理解。我尽量只评论这一部分。

扫描当前单元
检查当前槽的方向，从逆时针旋转 90 度开始
转一圈，检查开始时的位置，如果没有要清理的东西，就往回转。
如果没有要清扫的内容，就停止。

如果你忽略了先检查前方左侧的那部分问题，你就会对执行感到困惑。一定要注意这一点！

解决方案代码

import java.io.*;
import java.util.*;

public class Main {

    public static int height;
    public static int width;

    public static boolean isNeedClean(int[][] table, int nowYIndex, int nowXIndex) {
        return table[nowYIndex][nowXIndex] == 0;
    }

    public static void main(String[] args) throws IOException {

        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));

        StringTokenizer mapSize = new StringTokenizer(input.readLine(), "[ ]");

        // 뒷 방향 등록 해시맵 선언
        HashMap<Integer, Integer> backward = new HashMap<>();
        backward.put(0, 2);
        backward.put(2, 0);
        backward.put(1, 3);
        backward.put(3, 1);

        height = Integer.parseInt(mapSize.nextToken());
        width = Integer.parseInt(mapSize.nextToken());

        int[][] mapInfo = new int[height][width];

        StringTokenizer startingPoint = new StringTokenizer(input.readLine(), "[ ]");

        int nowY = Integer.parseInt(startingPoint.nextToken());
        int nowX = Integer.parseInt(startingPoint.nextToken());
        int nowDirection = Integer.parseInt(startingPoint.nextToken());

        for (int i = 0; i < height; i++) {
            StringTokenizer mapLine = new StringTokenizer(input.readLine(), "[ ]");

            for (int j = 0; j < width; j++) {
                mapInfo[i][j] = Integer.parseInt(mapLine.nextToken());
            }

        }

        int cleanCounter = 0;

        int[] directionY = new int[]{-1, 0, 1, 0};
        int[] directionX = new int[]{0, 1, 0, -1};

        Loop:
        while (true) {

            // 현재 칸이 청소가 필요하다면 청소 실시
            if (isNeedClean(mapInfo, nowY, nowX)) {
                mapInfo[nowY][nowX] = 2;
                cleanCounter += 1;
            }

            // 주변 칸에 대해서 확인
            for (int i = 1; i < 5; i++) {

                int targetDirection = (nowDirection + 4 - i) % 4;
                int targetY = nowY + directionY[targetDirection];
                int targetX = nowX + directionX[targetDirection];

                // 청소할 칸이 있는 경우 이동 및 방향 전환
                if (isNeedClean(mapInfo, targetY, targetX)) {
                    nowY = targetY;
                    nowX = targetX;
                    nowDirection = targetDirection;
                    break;
                }

                // 청소할 칸이 없는 경우 뒷칸 확인
                if (i == 4) {
                    targetY = nowY + directionY[backward.get(nowDirection)];
                    targetX = nowX + directionX[backward.get(nowDirection)];

                    // 뒤로 이동할 수 없는 경우 청소 종료
                    if (mapInfo[targetY][targetX] == 1) {
                        break Loop;

                        // 이동할 수 있다면 뒤로 1칸 후진
                    } else {
                        nowY = targetY;
                        nowX = targetX;
                    }
                }

            }

        }

        // 이동 결과 출력
        output.write(Integer.toString(cleanCounter));

        output.flush();
        output.close();

    }

}

首次采访回顾

Tue, 07 Feb 2023 11:30:12 GMT

2023-07-06 缩略图编辑 (作者故事集，来自 Freepik)

简介

好久没写东西了。

我目前正在完成第 8 期 SSAFY 课程，所以没有时间像我想象的那样写很多东西。

不过，即使经历了面试等重要环节，我觉得如果不把这些事情整理好，对我的发展也没有什么帮助，所以就匆匆写了这篇文章。

面试过程

这是一次视频面试，我本以为会是一次性格面试，而不是技术面试，但它并不像我想象的那样是一次技术面试。

我不知道我是应该为自己的预期和准备感到高兴，还是应该为失去获得经验的机会而感到失望......

至于面试问题，我想说的是

每次 1 分钟的自我介绍

你为什么选择目前的专业而不是主修专业？

关于差距

工作环境可能和你想象的不一样，可以吗？

我写得有点抽象，但我很高兴自己能用准备好的内容来回答。特别是对于非本专业的学生来说，总会有一些问题是针对他们与本专业学生相比缺乏 CS 知识的，因此在一定程度上做好准备是很有必要的！

###个人感想

不过，由于这不是一次技术面试，所以我觉得更令人失望的是，相关的问题并不多，因为我不知道下一次编码测试什么时候才能通过。

我听说这是面试官重新评价公司的时候，就像公司在评价面试者一样，我想我在这次面试中也感受到了这一点。

就我这次面试的公司而言，我认为我将从事的工作与我所想的工作大相径庭，所以我想即使我得到了这份工作，也会有很多麻烦.....！

[BOJ 16934, Java] 游戏昵称

Wed, 28 Dec 2022 00:35:18 GMT

题目链接

BOJ 16934

分类

数据结构(data_structures)、基于哈希的集合与映射(hash_set)、字符串(string)、树(trees)、Trie(trie)

说明

我个人觉得自己在字符串题上比较薄弱，觉得应该再加把劲学习一下，而这道题正好是可以用Trie算法解决的。

因为示例很多，反例检查并不难，但如果这种题连示例都不够清晰的话，恐怕会让人头疼得多……

由于之前从未在Java中实现过树型结构，虽然花了一些时间，但能不借助外力独立实现，这一点还是值得肯定的！

解题代码

import java.io.*;
import java.util.*;

public class Main {

    public static class Node {

        char nowChar;
        String value;
        int count = 0;
        boolean isUnique = true;
        HashSet<Node> childSet;

        // 헤드에 사용하기 위한 정의 방식
        Node() {

            this.childSet = new HashSet<>();
            this.value = "";
            this.isUnique = false;

        }

        // 일반적인 서브노드들을 위한 정의 방식
        Node(char target) {

            this.nowChar = target;
            this.childSet = new HashSet<>();
            this.value = "";

        }

    }

    public static class Trie {

        // 헤드 노드 1개를 보유하고 시작
        Node head = new Node();

        /**
         * 문자열 1개를 트라이 클래스에 추가하는 메서드
         */
        public void addString(String target) {

            Node nowNode = this.head;
            int targetLength = target.length();

            for (int i = 0; i <= targetLength; i++) {

                if (i == targetLength) {

                    nowNode.count += 1;
                    nowNode.value = target;

                } else {

                    boolean hasChild = false;

                    for (Node subNode : nowNode.childSet) {

                        if (subNode.nowChar == target.charAt(i)) {

                            nowNode = subNode;
                            hasChild = true;
                            break;

                        }

                    }

                    if (!hasChild) {

                        Node madeNode = new Node(target.charAt(i));
                        nowNode.childSet.add(madeNode);
                        nowNode = madeNode;

                    }

                }

            }

        }

        /**
         * 문자열의 고유 별칭을 찾아내는 메서드
         */
        public String findUnique(String target) {

            Node nowNode = this.head;
            int targetLength = target.length();
            boolean isFirstTime = true;
            int result = -1;
            int resultCount = -1;

            for (int i = 0; i < targetLength + 1; i++) {

                // 첫 번째로 만나는 고유값이 해당 문자열의 별칭
                if (nowNode.isUnique && isFirstTime) {

                    nowNode.isUnique = false;
                    isFirstTime = false;
                    result = i;
                    resultCount = nowNode.count;

                    // 이후로도 만나는 고유값은 고유값이 아니도록 처리
                } else {

                    if (nowNode.isUnique) {
                        nowNode.isUnique = false;
                    }

                }

                // 마지막 문자까지 확인
                if (i == targetLength) {

                    // 마지막 문자까지 고유값을 체크하지 못한 경우
                    if (result == -1) {
                        result = targetLength;
                        resultCount = nowNode.count;
                    }

                    // 카운팅 갯수에 따른 값을 반환
                    if (nowNode.count == 1) {
                        return target.substring(0, result);

                    } else {
                        return target + resultCount;
                    }

                    // 마지막 문자 이전까지는 트라이 내 탐색 방식으로 진행
                } else {

                    for (Node subNode : nowNode.childSet) {

                        if (subNode.nowChar == target.charAt(i)) {
                            nowNode = subNode;
                            break;

                        }

                    }

                }

            }

            return "ERROR!";

        }

    }

    public static void main(String[] args) throws IOException {

        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));

        // Trie Algorithm

        // 트라이 인스턴스 선언
        Trie nickNameTrie = new Trie();

        // 유저 수 입력
        int userNumber = Integer.parseInt(input.readLine());

        // 모든 유저에 대해 진행
        for (int i = 0; i < userNumber; i++) {

            // 닉네임 입력 및 트라이에 추가
            String nickName = input.readLine();
            nickNameTrie.addString(nickName);

            // 함수를 호출하여 해당 닉네임에 대한 별칭 출력
            if (i == userNumber - 1) {
                output.write(nickNameTrie.findUnique(nickName));

            } else {
                output.write(nickNameTrie.findUnique(nickName) + "\n");
            }

        }

        output.flush();
        output.close();

    }

}

[BOJ 17114, Java] 超级番茄

Thu, 22 Dec 2022 04:36:35 GMT

题目链接

[BOJ 17114] (<https://www.acmicpc.net/problem/17114>)

分类

实现(implementation), 图论(graphs), 图遍历(graph_traversal), 广度优先搜索(bfs)

说明

我个人认为这是一个很好地展示了BFS可以变得多么“臃肿”的题目。

虽然我很早就知道这道题的存在，且解法本身也已广为人知，但这次我再次体会到：即使解法广为人知，将其以自己的方式实现却是另一回事。

快速输入输出是基础，而在进行广度优先搜索时，如果不剔除冗余部分，就可能导致超时。

虽然不确定在Python中能否通过sys.stdin.readline解决，但在Java中幸运的是，仅通过BufferedReader就能处理。

解完这道题后查阅资料发现，似乎另有更巧妙的解法，但这里采用的是对经典BFS进行粗暴扩展的方式来解决。

将坐标信息输入到11维数组中
未成熟的西红柿进行计数，成熟的西红柿记录坐标
遍历成熟的西红柿，将相邻的未成熟西红柿加入成熟西红柿列表的同时减少计数值，根据条件重复该过程
若计数值变为0，则表示全部成熟，输出耗时天数
若计数未归零，但在对现有未成熟的西红柿重复执行第(3)步操作时数量未发生变化，则说明无法继续催熟，因此输出-1。

在解决此题时，处理第2步和第3步时若采用其他方式——**即每次循环都重新计数，或者不移除已使用过的成熟番茄的坐标，可能会导致超时……**我在此处纠结了很久才解决。

解题代码

代码相当长……但我认为这是因为使用了11层for循环，并且需要表示相邻坐标，所以无可奈何。


import java.io.*;
import java.util.*;

public class Main {

    public static int tomatoLeft;

    /**
     * 토마토가 익는 메커니즘을 반영하여 1일 뒤의 배열로 변경하는 함수
     */
    public static void ripeTomato(int[][][][][][][][][][][] target, Queue<int[]> tomatoQueue, int[] sizeInfo) {

        int[][] movements = new int[][]{
                new int[]{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                new int[]{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                new int[]{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                new int[]{0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                new int[]{0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0},
                new int[]{0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0},
                new int[]{0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
                new int[]{0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0},
                new int[]{0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0},
                new int[]{0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0},
                new int[]{0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0},
                new int[]{0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0},
                new int[]{0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0},
                new int[]{0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0},
                new int[]{0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0},
                new int[]{0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0},
                new int[]{0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
                new int[]{0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0},
                new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0},
                new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0},
                new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
                new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
        };

        ArrayList<int[]> ripeList = new ArrayList<>();

        for (int[] nowIdx : tomatoQueue) {

            for (int[] movement : movements) {

                boolean isNotOverIndex = true;

                for (int i = 0; i < 11; i++) {
                    if (0 > nowIdx[i] + movement[i] || nowIdx[i] + movement[i] >= sizeInfo[i]) {
                        isNotOverIndex = false;
                        break;
                    }
                }

                int nextIdx00 = nowIdx[0] + movement[0];
                int nextIdx01 = nowIdx[1] + movement[1];
                int nextIdx02 = nowIdx[2] + movement[2];
                int nextIdx03 = nowIdx[3] + movement[3];
                int nextIdx04 = nowIdx[4] + movement[4];
                int nextIdx05 = nowIdx[5] + movement[5];
                int nextIdx06 = nowIdx[6] + movement[6];
                int nextIdx07 = nowIdx[7] + movement[7];
                int nextIdx08 = nowIdx[8] + movement[8];
                int nextIdx09 = nowIdx[9] + movement[9];
                int nextIdx10 = nowIdx[10] + movement[10];

                if (

                        isNotOverIndex

                                && target[nextIdx00][nextIdx01][nextIdx02]
                                [nextIdx03][nextIdx04][nextIdx05][nextIdx06]
                                [nextIdx07][nextIdx08][nextIdx09][nextIdx10]
                                == 0

                ) {

                    ripeList.add(

                            new int[]{
                                    nextIdx00, nextIdx01, nextIdx02,
                                    nextIdx03, nextIdx04, nextIdx05, nextIdx06,
                                    nextIdx07, nextIdx08, nextIdx09, nextIdx10
                            }

                    );

                }

            }

        }

        tomatoQueue.clear();

        for (int[] ripeCoord : ripeList) {

            if (

                    target[ripeCoord[0]][ripeCoord[1]][ripeCoord[2]]
                            [ripeCoord[3]][ripeCoord[4]][ripeCoord[5]][ripeCoord[6]]
                            [ripeCoord[7]][ripeCoord[8]][ripeCoord[9]][ripeCoord[10]] == 0

            ) {

                target[ripeCoord[0]][ripeCoord[1]][ripeCoord[2]]
                        [ripeCoord[3]][ripeCoord[4]][ripeCoord[5]][ripeCoord[6]]
                        [ripeCoord[7]][ripeCoord[8]][ripeCoord[9]][ripeCoord[10]] = 1;

                tomatoLeft -= 1;

                tomatoQueue.add(ripeCoord);

            }

        }

    }

    public static void main(String[] args) throws IOException {

        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));

        // 배열 사이즈 입력
        int[] storageSize = new int[11];
        StringTokenizer sizeInput = new StringTokenizer(input.readLine(), "[ ]");

        for (int i = 0; i < 11; i++) {
            storageSize[i] = Integer.parseInt(sizeInput.nextToken());
        }

        // 창고 정보 입력
        int[][][][][][][][][][][] tomatoStorage = new int[storageSize[0]][storageSize[1]][storageSize[2]]
                [storageSize[3]][storageSize[4]][storageSize[5]][storageSize[6]]
                [storageSize[7]][storageSize[8]][storageSize[9]][storageSize[10]];

        Queue<int[]> ripeTomatoQueue = new LinkedList<>();

        for (int idx10 = 0; idx10 < storageSize[10]; idx10++) {
            for (int idx09 = 0; idx09 < storageSize[9]; idx09++) {
                for (int idx08 = 0; idx08 < storageSize[8]; idx08++) {
                    for (int idx07 = 0; idx07 < storageSize[7]; idx07++) {
                        for (int idx06 = 0; idx06 < storageSize[6]; idx06++) {
                            for (int idx05 = 0; idx05 < storageSize[5]; idx05++) {
                                for (int idx04 = 0; idx04 < storageSize[4]; idx04++) {
                                    for (int idx03 = 0; idx03 < storageSize[3]; idx03++) {
                                        for (int idx02 = 0; idx02 < storageSize[2]; idx02++) {
                                            for (int idx01 = 0; idx01 < storageSize[1]; idx01++) {

                                                StringTokenizer storageInfo = new StringTokenizer(input.readLine(), "[ ]");

                                                for (int idx00Counter = 0; idx00Counter < storageSize[0]; idx00Counter++) {

                                                    int nowInput = Integer.parseInt(storageInfo.nextToken());

                                                    if (nowInput == 1) {

                                                        ripeTomatoQueue.add(
                                                                new int[]{
                                                                        idx00Counter, idx01, idx02,
                                                                        idx03, idx04, idx05, idx06,
                                                                        idx07, idx08, idx09, idx10
                                                                }
                                                        );

                                                    } else if (nowInput == 0) {

                                                        tomatoLeft += 1;

                                                    }

                                                    tomatoStorage[idx00Counter][idx01][idx02]
                                                            [idx03][idx04][idx05][idx06]
                                                            [idx07][idx08][idx09][idx10]
                                                            = nowInput;

                                                }

                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        // 지난 날짜 카운팅 변수 및 모두 익지 못하는 상황을 체크하기 위한 Flag 선언
        int dayCounter = 0;
        boolean cantComplete = false;

        // 모두 익지 않았다면 반복
        while (tomatoLeft > 0) {

            // 함수를 호출하여 기존 배열 깊은 복사 후 1일 뒤의 배열 확인
            int lastTomato = tomatoLeft;
            ripeTomato(tomatoStorage, ripeTomatoQueue, storageSize);

            // 날짜 1 카운트
            dayCounter += 1;

            // 아직 다 익지 않았지만 기존이랑 차이가 없다면 전부 익을 수 없는 상황이므로 Flag 변경 후 break
            if (tomatoLeft != 0 && tomatoLeft == lastTomato) {
                cantComplete = true;
                break;
            }

        }

        // 문제 조건에 따라서 출력
        if (cantComplete) {
            output.write("-1");
        } else {
            output.write(Integer.toString(dayCounter));
        }

        output.flush();
        output.close();

    }

}

[BOJ 3865, Java] 学会会员

Mon, 12 Dec 2022 13:50:33 GMT

题目链接

BOJ 3865

分类

广度优先搜索(bfs)，数据结构(data_structures)，深度优先搜索(dfs)，图论(graphs)，图遍历(graph_traversal)，基于哈希的集合与映射(hash_set)，语法分析(parsing)，字符串(string)

说明

最近参加的编程测试中，似乎经常出现与字符串相关的问题，因此我在寻找此类题目时发现了这道题。

由于是使用深度优先搜索的题目，我比较熟悉，但因为对Java语言的掌握还不够熟练，解题花了一点时间，不过整体思路并没有偏离深度优先搜索的框架。

这道题的关键在于对字符串数据进行妥善处理，同时持续检查学会和学生名字的访问记录集合，对于尚未访问的情况，通过递归+计数的方式处理，最终得以解决。

解题代码

import java.io.*;
import java.util.*;

public class Main {

    /**
     * 해당 학회의 총 인원수를 반환하는 함수
     */

    public static int getTotalPerson(String target) {

        // 결과값 변수 선언
        int result = 0;

        // 아직 방문하지 않은 경우에 대해서만 처리
        if (!visitLog.contains(target)) {

            // 방문 기록
            visitLog.add(target);

            // 사람이 아닌 학회일 경우
            if (clubGraph.containsKey(target)) {

                // 해당 학회의 방문하지 않은 구성원에 대해 재귀함수를 호출, 결과값에 합산
                for (String eachPerson : clubGraph.get(target)) {

                    // 구성원이 학회라면 재귀함수 호출
                    if (clubGraph.containsKey(eachPerson)) {
                        result += getTotalPerson(eachPerson);

                    // 학생이라면 아직 방문하지 않았을 경우 결과값 1 추가
                    } else {

                        if (!visitLog.contains(eachPerson)) {

                            visitLog.add(eachPerson);
                            result += 1;

                        }

                    }

                }

            }

        }

        // 결과값을 반환
        return result;

    }

    public static int strToInt(String inputString) {
        return Integer.parseInt(inputString);
    }

    // 학회 수, 첫 학회, 학회 관계 그래프, 학생 기록 집합 정적 변수 선언
    static int clubNumber;
    static String firstClub;
    static HashMap<String, ArrayList<String>> clubGraph = new HashMap<>();
    static Set<String> visitLog = new HashSet<>();

    public static void main(String[] args) throws IOException {

        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));

        // 학회의 수 입력, 입력값이 0이라면 반복 종료
        while ((clubNumber = strToInt(input.readLine())) != 0) {

            clubGraph.clear();
            visitLog.clear();

            for (int i = 0; i < clubNumber; i++) {

                // 줄 단위 입력
                StringTokenizer clubInfo = new StringTokenizer(input.readLine(),"[:,.]");

                // 학회 이름 변수 선언
                String clubName = clubInfo.nextToken();

                // 첫 학회라면 따로 변수에 기록
                if (i == 0) {
                    firstClub = clubName;
                }

                // 기존에 없던 학회라면 추가
                if (!clubGraph.containsKey(clubName)) {
                    clubGraph.put(clubName, new ArrayList<>());
                }

                // 나머지를 전부 학회의 원소로 추가
                while (clubInfo.hasMoreTokens()) {
                    clubGraph.get(clubName).add(clubInfo.nextToken());
                }

            }

            // 함수를 호출하여 결과값을 출력 스택에 추가
            System.out.println(getTotalPerson(firstClub));

        }

    }

}

SQLD 通过心得及资料

Tue, 29 Nov 2022 15:32:31 GMT

我通过了第47届SQL开发者资格考试。这是我在彻底改变职业方向后考取的第一张证书，因此感到非常自豪。

起初我本想投入一个月左右的时间，但后来被其他事情耽搁，或者过于理论化地去学习……感觉浪费了不少时间，这让我有些遗憾。在此记录下学习过程中总结的一些要点。

最后一部分记录了个人整理的概念，其中包含一些实操内容，以及为了便于记忆而进行的编辑，因此可能存在某些地方与实际情况不符！不过，考虑到或许能对他人备考有所帮助，我决定保留全部内容，日后若想起会再进行修改。

耗时及学习方法

实际花费的时间约为2周，其中解题大约耗时1周。

起初，我本想通过[Data on Air](https://dataonair.or.kr/

)提供的概念讲解，以一种近乎“王道”的方式进行学习，但发现SQLD考试本身提供的题目中，以实战SQL语句形式呈现的题目远多于概念性内容，因此我在初期就放弃了这种方式。不过，我仍然认为其内容本身很不错，如果时间充裕，建议大家去看看！

接下来，我通过YouTube上各种形式的讲座掌握了大致的框架。仅就SQLD而言，已有相当数量的系统化讲座，因此挑选看起来不错的课程即可。

最后是解题环节。关于习题，相关论坛或博客上都有复原历年真题的资料。俗称 “黄皮书”虽然不错，但切勿忽视对真题的解题练习！我仅对黄皮书的前两章进行了通读并整理了错题笔记，剩余时间全部用于真题练习。

个人推荐的真题复原合集网站是[这个博客](https://yunamom.tistory.com/category/자격증/SQLD 기출문제

)。因为只需输入答案，就能立即确认该题的正误。

概念整理

参考事项：由于第1章的习题比重小于第2章，因此被排在后序，相应地仅记录了必要内容，内容可能不够充分

第1单元

实体的分类

基本/主键实体
核心实体
行为实体

数据建模

用于构建信息系统的数据视角业务分析技术
通过约定好的表示法来表达现实世界中的数据
用于构建数据库的分析/设计过程

进行数据建模时的注意事项

冗余
缺乏灵活性
不一致

数据建模的类型

概念型：抽象层次较高，以业务为中心进行全面建模
逻辑型：准确表达键、属性、关系等，设计时注重可重用性
物理型：考虑物理特性，以便移植到实际数据库中。

数据库模式的结构

外部
概念
内部

ERD绘制顺序

绘制实体。
合理布局实体。
设定实体之间的关系。
标注关系名称。
标注关系参与度。
标注关系的必选性。

实体的特征

该业务中需要且必须管理的信息
必须是唯一的标识符。
拥有两个或以上的实例。
必须实际被使用。
必须拥有属性。
必须形成至少一个关系。

1개 엔터티: 2개 이상의 인스턴스 집합 + 2개 이상의 속성
1개 속성: 1개 이상의 속성값

根据属性特征的分类

基本属性
设计属性
派生属性

域

各属性可能取值的范围
指定实体内属性的数据类型、大小及约束条件

属性命名

必须是该业务中使用的名称。
不使用描述性属性名。
尽量避免使用缩写。
必须确保在整个数据模型中具有唯一性。

ERD中不区分存在关系和行为关系。但在类图中需进行区分，并描述关联关系和依赖关系。

关系的表示法

关系名：关系的名称
关系度：1 : 1, 1 : M, M : N
关系选定规格：必选、可选

关系解读

基准实体读作“1个”（One）或“每个”（Each）。
解读目标实体的关系参与度。
解读关系选定规格和关系名称。

标识符类型

代表性：主标识符 vs 辅助标识符
自生成性：内部 vs 外部
单一属性标识：单一 vs 复合
是否具有语义：本质 vs 人为

主标识符的特征

唯一性
稀有性
不变性
存在性

性能数据建模

以提升数据库性能为目的，将性能相关事项反映到数据建模中

第一范式规范对象

分离冗余属性
行级重复
列级重复

反规范化

通过规范化实体、属性及关系的重复、整合与分离提升系统性能，简化开发与运维当预计性能下降时，即使可能导致完整性受损，仍可执行。

流程

调查反规范化的对象
- 范围处理频率
- 大量范围处理
- 统计性处理
- 表连接（JOIN）数量
若可通过其他方法实现，则考虑引导采用该方法
- 连接（JOIN）较多的情况，使用视图表
- 处理大量数据时，采用聚簇
- 持有大量数据时，通过分区进行数据分割
- 索引维护
- 应用程序逻辑变更

超级/子类型数据模型转换技术

单独发生的事务 -> 单独的表超级 + 子类型 -> 超级 + 子表整体 -> 单一表

确定主键顺序的标准

指定以高效利用索引
位于前面的属性值应作为比较条件
尽可能使用 '=', BETWEEN, '<>'

分布式数据库的优缺点

优点

区域自治性，可逐步扩展系统容量
可靠性与可用性 / 实用性与灵活性
响应速度快，降低通信成本，更好地满足区域用户需求
提高数据可用性与可靠性，便于调节系统规模

缺点

开发成本及潜在错误增加，处理成本上升，威胁数据完整性
设计过程困难，管理复杂且成本高，响应速度不稳定，难以控制

第2单元

SQL语句的种类

DCL

数据控制语言（Data Control Language），用于管理权限的命令

GRANT

授予权限的作用
采用GRANT {permission} ON {table} TO {user};

的形式使用

```text
WITH GRANT, WITH ADMIN의 비교

GRANT: 특정 사용자에게 권한 부여가 가능한 권한을 부여, 부여한 부모의 권한이 회수될 때 자식의 권한도 회수
ADMIN: 테이블에 대한 모든 권한을 부여, 부여한 부모의 권한 회수와 관계 없는 권한
```

REVOKE

用于撤销权限
采用REVOKE {permission} ON {table} FROM {user};

的形式

权限的种类

ALL -- 모든 권한 부여
SELECT INSERT UPDATE DELETE /*  */
REFERENCES ALTER INDEX /*  */

/* ROLE: 다양한 권한을 하나의 그룹으로 묶어서 관리 */
CREATE ROLE {role_name}; -- 권한 그룹 생성
GRANT {permission_type} TO {role_name}; -- 해당 그룹에 권한 등록
GRANT {role_name} TO {user_1}, {user_2}...; -- 다른 유저들에게 권한 그룹 부여

DDL

数据定义语言（Data Definition Language），用于定义数据的命令

以SQL Server为例，支持自动提交（Auto Commit）

CREATE

创建表结构
采用CREATE TABLE {table_name} {table_elements};

的形式

```sql
CREATE TABLE EXAMPLE (
/* 
  컬럼명은 영어, 한글, 숫자 전부 가능 
  첫 글자를 문자로 지정해야 하며, 컬럼의 데이터 타입은 반드시 설정해야 한다.
*/
		NAME  varchar2(max_length)  -- 최대 길이를 가진 가변길이 문자열
  	ID번호 char(length)          -- 고정된 길이 문자열
		나이_2 number(max_length)    -- 숫자형 데이터 타입
  	생일   date                  -- 날짜형 데이터 타입
);
```

##### CONSTRAINT (条件)

* default：指定默认值

* not null：不允许输入NULL

* primary key：指定主键（not null、unique，支持多主键）

* foreign key：指定外键（支持多外键）

ALTER

用于修改表及列的名称、属性，以及进行结构修改（如添加、删除等）
采用ALTER TABLE {table_name} {detail_order} {detail_property(if need)} TO {change_target};

的形式使用

#### 详细命令

* RENAME：更改表、列的名称

* MODIFY：更改列的属性

* ADD：添加列

* DROP：删除列

* ADD CONSTRAINT / DROP CONSTRAINT：添加、删除约束

RENAME

无需通过 ALTER 即可更改表或列的名称
可同时更改多个表名

DROP

无需通过 ALTER 即可删除表或列

#### TABLE {table_name} CASCADE CONSTRAINT

* 仅存在于 Oracle 的选项，SQL Server 中不存在

* 对于外键约束，先删除引用表，再删除该表。

* 同时删除该表数据及所有外键引用约束

TRUNCATE

表初始化（并非删除！）
仅清除内部数据，表的存在及列结构仍保留。

#### DROP vs TRUNCATE vs DELETE

* DROP：彻底删除表并释放内存

* TRUNCATE：保留表和列的存在，仅释放剩余数据的内存

* DELETE：删除记录，数据操作日志保留，可在提交前回滚，且不释放内存

DML

数据操作语言（Data Manipulation Language），用于操作记录的命令

INSERT

将数据插入记录
采用INSERT INTO {table_name} {column_name} VALUES {change_column_name};

的形式

虽可不指定列名进行插入，但若未指定，则必须填入所有字段值

UPDATE

修改现有数据
采用UPDATE {table_name} SET {column_name} = {column_value} WHERE {condition};

的形式

DELETE

删除现有数据
采用DELETE FROM {table_name} WHERE {condition};

的形式

可省略FROM

SELECT

查询特定数据
采用SELECT {select_target} FROM {select_origin} WHERE {condition};

的形式

也可使用GROUP BY {calc_type} HAVING {condition} / ORDER BY {sort_condition}

的形式添加条件

#### DISTINCT

用于查询不包含重复值的条件 (a, b, NULL, a, b, NULL) =&gt; (a, b, NULL)

COUNT

(\*): 统计包含 NULL 值的全部行数

({column\_name}): 统计特定列的行数（不包含 NULL 值）

TCL

事务控制语言（Transaction Control Language），事务控制命令

事务（Transaction）：改变数据库状态的操作

* transaction의 특징
고립성: 실행되는 동안 다른 transaction에 영향을 받아 잘못된 결과를 만들면 안됨
일관성: 실행 전 데이터베이스에 잘못된 점이 없다면 transaction 수행 후에도 내용에 오류가 있으면 안됨
지속성: transaction이 갱신한 데이터베이스 내용은 영구적으로 저장
원자성: transaction에서 정의한 연산은 모두 성공적으로 실행되거나 전혀 실행되지 않음 (All or Nothing)

COMMIT

将数据变更反映到数据库中

SAVEPOINT

指定保存点（savepoint）作为代码分割的分支点
采用SAVEPOINT {savepoint_name};

的形式使用

ROLLBACK

用于恢复到先前状态的命令
可回滚至SAVEPOINT或上一次COMMIT
使用形式为ROLLBACK TO {rollback_point};
若无SAVEPOINT，则恢复至最近一次COMMIT

TCL的效果

保障数据完整性
在永久更改数据前确认数据变更情况
可对具有逻辑关联的操作进行分组处理

函数

字符型函数

常用于指定 SELECT、WHERE 等条件

LOWER

将英文字符串转换为小写

UPPER

将英文字符串转换为大写

CONCAT

合并两个字符串
与 Oracle 的 '||'、SQL Server 的 '+' 功能相同

SUBSTR

从字符串的第 M 位开始，保留 N 个字符并删除其余部分

LENGTH, LEN

包含空格的字符串长度

TRIM, LTRIM, RTRIM

移除两端指定的字符；若未指定字符，则移除空格

数值型函数

ROUND

四舍五入

TRUNC

向下取整

CEIL

取不小于该数的最小整数

FLOOR

取不大于该数的最大整数

MOD

模运算

SIGN

正数返回 1，0 返回 0，负数返回 -1

ABS

绝对值

日期型函数

SYSDATE

输出执行查询时的当前日期和时间

EXTRACT

以EXTRACT ({information} FROM {data})

的形式使用

如何从日期型数据中提取所需值

类型转换

可通过这些函数更改数据类型

TO_NUMBER

字符串 > 数字

TO_CHAR

数字、日期 > 字符串（根据格式不同生成结果）

TO_DATE

字符串 > 日期（根据格式不同生成结果）

基本结构

DECODE

IF语句
当条件可以简单整理时

CASE WHEN

扩展版的 IF 语句
当需要对条件进行较长整理时

ORDER BY

对查询到的表进行排序
可以使用多个排序条件

WHERE

IN, NOT IN：只要列表中的值与其中任意一个匹配或不匹配，即满足条件
IS NULL, IS NOT NULL：判断是否为NULL，返回T/F
BETWEEN a AND b：检查值是否在a和b之间，返回T/F（包含a和b）
比较运算符：=, >, <, >=, <= 等
A LIKE B：根据a查找与b相似的字符串
%：表示存在一个或多个字符
_：表示一个字符

명시적 형변환 vs 암시적 형변환

명시적 형변환: 함수를 활용하여 데이터 타입을 변경
암시적 형변환: 데이터베이스가 알아서 바꿔주는 것
>> 숫자 타입의 PK는 암묵적으로 인덱스가 되는데 데이터의 조회 등으로 암시적 형변환이 발생한 경우, 인덱스로 사용이 불가능

WITH

可使用子查询，像临时表或视图一样使用
可指定别名
被视为内联视图或临时表
以WITH {table_name} AS {table_condition}

的形式使用

GROUP BY

根据条件进行分组的命令
若值的组合不同，则属于不同组

HAVING

基于分组后状态的条件语句
可使用 COUNT（计数）、SUM（求和）、AVG（平均值）、MAX（最大值）、MIN（最小值）、STDDEV（标准差）、VARIAN（方差）等
可使用 DISTINCT（去除重复）、ALL（全部）等条件

NULL 函数

NVL, ISNULL

若为 NULL 则替换为其他值的函数
数据类型不同时无法使用

NVL2

根据是否为NULL返回不同结果的函数
若非NULL则返回第1个参数，若为NULL则返回第2个参数

NULLIF

若两个参数相同则返回NULL，不同则返回第1个参数

COALESCE

返回第一个非NULL的值

GROUP 函数

分组对象列的值和聚合对象列的值将输出为NULL

可通过普通分组函数提取相同的结果

ROLLUP

显示部分和与总和。
函数的参数顺序会影响结果，并以分层结构返回聚合值。

CUBE

针对所有可分组的情况生成参数组合

GROUPING SETS

可按括号括起的集合进行聚合

GROUPING

当计算出小计、总计等时返回1，否则返回0的函数

JOIN

通常指表与表之间的连接，类似于集合

支持表与表之间、连接结果与表之间、以及连接结果之间的JOIN

当两个相关表至少存在一个共同属性时可应用

既有明确指定 JOIN 的 ANSI 标准查询，也存在未明确指定的非标准查询。

若列出了 JOIN，则每次处理两个，无法同时处理所有 JOIN

交集

*

INNER JOIN
- 非标准表示法，用 “ ” 缩写
- 连接两个表的交集
*

LEFT JOIN
- 非标准形式使用时，左侧标注 (+)
- 左侧表全部数据与右侧表的交集进行连接
*

RIGHT JOIN
- 非标准形式使用时，右侧标注 (+)
- 右侧表全部数据与左侧表的交集进行连接
*

OUTER JOIN
- 由于两侧均不可使用 (+) 符号，因此无法使用 OUTER JOIN，必须使用 ANSI 标准查询。
- 与 UNION 不同，即使仅存在一个共同属性也可应用。
并集

*

UNION (ALL)
- 当查询对象的列数相同且各列属性一致时可应用的连接方式
- 数据量为 Data1 + Data2。
- UNION ALL 合并时不会去除重复数据
差集

当仅需确认排除交集后的单一集合时适用

*

MINUS(Oracle)

EXCEPT(SQL Server)

连接对象之间的一致程度
- EQUI JOIN：使用相同的列连接两个关系
- non-EQUI JOIN：使用不完全匹配的列连接两个关系
```
ex) A.key <, >, <=, >= B.key
```

CROSS JOIN

若不使用键进行连接，则会对两个表产生笛卡尔积
```
5개의 행 * 3개의 행 = 15개의 행으로 조회
```

自连接

在同一张表内，对具有关联关系的两个列进行连接
由于表名和列名完全一致，因此必须使用别名

优化器连接

在执行连接的过程中，为性能优化而选择的方法，需通过提示（Hint）指定

层级查询

对树形数据进行查询

层级结构的起点通过 START WITH 设定（ROOT NODE）
没有子节点的节点 = LEAF NODE
层级用 LEVEL 表示

CONNECT BY

确认层级结构的连接方向
- 子节点 > 父节点
- 父节点 > 子节点

##### CONNECT BY PRIOR a = b

* 当 a 列和 b 列在同一条记录中相同时，会形成层级关系

* 按 b -&gt; a 的顺序重新排列

SIBLINGS BY

确定兄弟节点之间的排列顺序

窗口函数

用于轻松定义记录之间关系的函数，采用

SELECT WINDOW_FUNCTION {arguments} OVER {partition by column} {order_style} FROM {table};

的形式

WINDOW_FUNCTION

窗口函数
- 组内聚合函数：COUNT、SUM、MIN、MAX、AVG 等
- 组内排名函数
  
  即使创建了排名函数，也不会自动排序，因此必须使用 ORDER BY 子句。
  
  *
  
  RANK
  - 对相同排名赋予相同的排名
  - 不将相同排名计为同一条记录
  *
  
  DENSE_RANK
  - 对相同排名赋予相同的排名
  - 将相同排名计为同一条记录
  ROW_NUMBER
  - 对相同排名赋予唯一的排名
- 组内比例相关函数
  
  *
  
  PERCENT_RANK
  - 以“顺序”而非数值为对象，查询分区内各顺序对应的百分比
  *
  
  NTILE(n)
  - 返回按分区将总记录数均分为 n 份后的数值
  *
  
  CUME_DIST
  - 查询分区内当前行值及以下记录数的累积百分比
  - 在累积分布中取值范围为 0 至 1
- 组内行序函数
  
  *
  
  FIRST_VALUE
  - 返回分区内出现的第一个值
  *
  
  LAST_VALUE
  - 返回分区内出现的最后一个值
  *
  
  LAG(column_name, record_difference)
  - 获取前一行
  *
  
  LEAD(column_name, record_difference, value_if_null)
  - 获取下一行。
  - 默认值为 1

参数

参数（列名等函数操作的对象）

PARTITION BY

分割表中记录的依据

ORDER BY

指定在分割后的记录范围内或整个表中，按何种标准对记录进行排序

WINDOWING

确定函数运算对象的记录范围

*

RANGE
- 用于指定范围
*

BETWEEN a AND b
- 应用于从 a 到 b 的范围
*

UNBOUNDED PRECEDING
- 起始位置 = 第一行
*

UNBOUNDED FOLLOWING
- 起始位置 = 最后一行
*

CURRENT ROW
- 起始位置 = 当前行

表分区

将大型表拆分为多个数据文件进行存储

存储在物理上分离的数据文件中 => 性能提升且可独立管理

缩小查询范围的效果 => 性能提升

范围分区

基于值的范围进行分区存储的方法

列表分区

基于特定值进行分区

哈希分区

数据库管理系统自行使用哈希函数进行分区和管理的方式

优化器

即使是相同的SQL语句，根据执行方式的不同，性能也会有所差异（性能指标：耗时、资源使用量等）

因此，需要分析SQL语句并根据特定标准制定执行计划，此时便会使用优化器。

优化器可能会影响执行性能，但结果值不会改变。

SQL문 작성 => 파싱 (문법 검사, 구문 분석) => 옵티마이저 (비용 기반 / 규칙 기반) => 실행 계획 (PLAN_TABLE 저장) => SQL 실행

成本驱动

最新版本的Oracle默认使用成本驱动优化器
通过系统统计信息和对象统计信息计算该SQL语句执行的总成本，然后制定成本最低的执行计划

规则驱动

根据15项优先级规则制定执行计划
通常基于ROWID进行扫描的优先级最高

索引

按索引键排序 => 查找速度加快
主键（PK）会自动生成索引
可以在一张表上创建多个索引，一个索引可以由多个列组成
按降序创建和排序
不建议将频繁变化的属性设置为索引
除非是具有UNIQUE属性的索引，否则辅助索引允许输入重复数据。
与索引扫描相比，全表扫描可能更高效且在成本上更具优势
对于分区表，可以针对分区创建分区键索引，称为全局索引
索引增加必然导致数据量增加，因此可能会导致插入、删除和修改速度下降
所有数据类型均可创建索引
索引的种类包括顺序索引、位图索引、组合索引、簇索引和哈希索引。

#### SCAN 方式

*<br />



  ##### 唯一索引扫描 (Index Unique SCAN)

  * 当索引键值不重复时，通过该键进行查找

*<br />



  ##### 唯一索引扫描 (Index Unique SCAN)

  * 使用查询特定范围的 WHERE 子句来扫描该区域

  * 根据范围的不同，可能只返回一个结果，甚至返回 0 个结果

*<br />



  ##### 索引全扫描

  * 从索引的开头到结尾进行全范围扫描

优化器连接的类型

#### 嵌套循环连接

* 先查询外部（驱动）表以查找连接对象数据，再连接内部（从属）表

* 处理量由先行表的处理范围决定，因此需要寻找大小较小的先行表

* 行间处理和表间处理均按顺序进行

* 寻找最佳顺序至关重要

* 由于会发生随机访问（在先行表中引用第二个表时发生），为减少性能延迟，应尽量减少随机访问的发生

* 当先行表的处理范围较广或随机访问范围较广时，存在比排序合并连接（SORT MERGE JOIN）更不利的情况

* “必须使用索引”，使用唯一索引时更有利

* 适用于在线事务处理（OLTP）

* 与嵌套循环相同，根据满足先行表条件的记录数进行循环执行

#### 排序合并连接 (Sort Merge JOIN)

* 分别对两张表进行排序，完成后进行合并

* 由于涉及排序，当数据量较大时会变慢。

* 当待排序的数据量较大时，会使用临时磁盘，从而导致性能下降。

* 支持等值连接 (EQIU JOIN) 和非等值连接 (non-EQIU JOIN)

哈希连接

* 将两张表中较小的一张加载到哈希内存中，使用两张表的连接键生成哈希表

* 同时扫描两张表

* 先行表中必须先出现“较小数据”

* 能最大限度利用系统资源，但可能消耗过多资源，且存在负载过高等风险

* 在处理海量数据时表现出色

* 仅适用于等值连接（EQUI JOIN）

* 不使用索引

* 连接方式

  ```text
  먼저 선행 테이블을 결정, 선행 테이블에서 주어진 조건에 해당하는 레코드를 선택
  해당 행이 선택되면 JOIN Key를 기준으로 해시 함수를 사용
  해시 테이블을 메인 메모리에 생성, 후행 테이블에서 주어진 조건을 만족하는 행을 찾음
  후행 테이블의 JOIN Key를 사용해서 해시함수를 적용, 해당 버킷을 검색
  ```

PL/SQL

一种通过扩展SQL实现多种过程化编程的语言

采用块结构，可按功能进行模块化
以 DECLARE 语句开头，通过声明变量和常量进行使用
- DECLARE、BEGIN ~ END 为必备，EXCEPTION 为可选
使用 DML、IF、LOOP 等多种过程化语言
内置于 Oracle 中，可与使用相同语言的程序兼容
提升应用程序的性能
可编写过程、用户定义函数和触发器对象
- 过程内部编写的程序代码由 PL/SQL 引擎处理，而一般的 SQL 语句则由 SQL 执行器处理

分布式数据库

一种由单个数据库管理系统（DBMS）通过网络控制物理上分离的数据库的 DB 形式

性能提升：由于分布式数据库可进行并行处理，因此速度较快
采用模块化设计，可在不影响其他模块的情况下更新系统
可通过添加分布式数据库来扩展容量
便于保护重要数据
可靠性高
管理与控制困难
安全管理和完整性控制困难
结构复杂

메모

count(*): 전체 행의 수를 카운팅, null 포함
count({column_name}) null 을 제외한 행의 수를 카운팅
null: 모르는 값을 상징, 값의 부재를 말함
(null is null) = TRUE
null과의 모든 비교는 null 반환
0 혹은 ' '과 동일한 값이 아님 

서브쿼리: SELECT문 내의 SELECT문이 반복 사용된 쿼리, 단일행 및 다중행으로 구분
- 정렬을 수행하는 ORDER BY를 사용할 수 없다.
- 여러 행을 반환하는 서브 쿼리는 다중 행 연산자를, 단일 행을 반환하는 서브쿼리는 단일 행 연산자를 사용
- 메인 쿼리에서 서브 쿼리의 컬럼을 자유롭게 사용할 수 없음
- EXIST는 True 혹은 False를 반환한다

스칼라 서브쿼리: 한 행과 한 컬럼만 반환하는 서브쿼리
인라인뷰: 서브쿼리가 FROM 절 내에 쓰여진 것

view 테이블
- 사용상의 편의를 위해 사용
- 수행속도의 향상을 위해 사용
- SQL의 성능을 향상시키기 위해 사용
- 임시적인 작업을 위해 사용
- 보안관리를 위해 사용

실행 순서
SELECT ALIAS => FROM => WHERE => GROUP BY => HAVING => SELECT => ORDER BY

조회 행수 제한
몇 번째 행을 조회하는지 부여하는 조건문
ROWNUM {row_number}: Oracle
TOP {row_number}: SQL Server
LIMIT {row_number}: MySQL

ROWID
해당 데이터가 어떤 데이터 파일 상에서 어느 블록에 저장되었는지 알려준다.
데이터베이스에 저장되어 있는 데이터를 구분할 수 있는 유일한 값이다.
ROWID의 번호는 데이터 블록에 데이터가 저장된 순서이다.
테이블에 데이터를 입력하면 자동으로 생성된다.

[BOJ 17471, Python] 选区划分

Mon, 07 Nov 2022 11:14:53 GMT

题目链接

BOJ 17471

分类

广度优先搜索(bfs)，暴力搜索算法(bruteforcing)，组合数学(combinatorics)，深度优先搜索(dfs)，图论(graphs)，图遍历(graph_traversal)，数学(math)

说明

起初我以为这是一个并集查找问题，尝试过删除边、设置其他约束条件，但实际上这是一个需要采用直截了当的方法来解决的问题。

如果忽略0.5秒的限制条件，可以考虑对所有组合进行深度遍历来检查，但由于使用Python，时间限制过短导致我排除了直截了当的解法，这成为了致命失误。

考虑到区域数量最多仅限10个，完全可以通过暴力搜索解决，若将精力投入其他方向反而可能陷入困境。

因此，本题的解法是将所有区域二分，检查是否能形成选区；若能形成选区，则比较两个选区的人口差，若该值小于原有人口差，则进行更新。

解题代码

# 게리맨더링

import sys
from itertools import combinations

input = sys.stdin.readline

# 상한값 선언
INF = 2000000000

# 구역 갯수 입력
area_number = int(input())

# 구역별 인구 정보 입력
people_number = [0] + list(map(int, input().split()))

# 인접 구역 관계 그래프 입력
graph = [[] for _ in range(area_number + 1)]
for area_idx in range(1, area_number + 1):
    near_area, *graph[area_idx] = map(int, input().split())

# 총 인구수 확인
max_people = sum(people_number)

# 최소 차이값 변수 선언
min_difference = INF

# 한 선거구의 포함될 모든 구역 수에 대해 체크 
for areas in range(1, area_number // 2 + 1):

    # 모든 구역 중에서 한 선거구에 포함될 구역 확정
    for target_areas in combinations(range(1, area_number + 1), areas):

        # 해당 선거구에 포함되는 구역 집합 선언 및 해당 선거구 인원수 변수 선언
        target_set = set(target_areas)
        sum_areas = 0

        # Depth First Search

        # 집합에 포함된 한 구역에서 시작하는 깊이 탐색
        for first_area in target_set:

            # 선거구 내 구역 수 체크 카운터 선언
            counter = 1

            # 방문 리스트 선언
            is_visited = [False for _ in range(area_number + 1)]

            # 깊이 탐색을 진행할 스택 선언 및 초기 조건 입력
            progress_stack = [first_area]
            sum_areas += people_number[first_area]
            is_visited[first_area] = True

            # 탐색 진행
            while progress_stack:

                # 현재 구역 확인
                now_area = progress_stack.pop()

                # 모든 인접 구역에 대해 확인
                for next_area in graph[now_area]:

                    # 같은 선거구에 속해있고 방문하지 않았을 경우만 조사
                    if next_area in target_set:
                        if not is_visited[next_area]:

                            # 방문 처리, 인구수 합산, 선거구 카운팅
                            is_visited[next_area] = True
                            sum_areas += people_number[next_area]
                            counter += 1

                            # 다음 구역 스택에 추가
                            progress_stack.append(next_area)

            # 1회의 조사로 선거구의 모든 정보를 획득하므로 반복하지 않음
            break

        # 남은 구역들에 대해서 다른 하나의 선거구라 가정하고 깊이 탐색 진행

        other_set = set(range(1, area_number + 1)) - set(target_set)
        sum_other_areas = 0

        for first_other_area in other_set:

            other_counter = 1
            sum_other_areas += people_number[first_other_area]

            progress_stack = [first_other_area]
            is_visited[first_other_area] = True

            while progress_stack:
                
                now_area = progress_stack.pop()

                for next_area in graph[now_area]:
                    if next_area in other_set:
                        if not is_visited[next_area]:
                            is_visited[next_area] = True
                            sum_other_areas += people_number[next_area]
                            progress_stack.append(next_area)
                            other_counter += 1

            break

        # 양쪽 선거구를 조사했을 때 남는 구역이 없을 경우만 성립
        if counter + other_counter == area_number:

            # 두 선거구의 인구 차이를 확인하여 기존값보다 작다면 갱신
            now_min = abs(sum_areas - sum_other_areas)
            if min_difference > now_min:
                min_difference = now_min

# 한 번도 갱신하지 못했다면 선거구 분할 실패이므로 -1 출력
if min_difference == INF:
    print(-1)

# 갱신한 경우 결과를 출력
else:
    print(min_difference)

[BOJ 14438, Python] 数列与查询 17

Tue, 01 Nov 2022 13:52:01 GMT

题目链接

[BOJ 14438](https://www.acmicpc.net/problem/14438

)

分类

段树(segtree)，数据结构(data_structures)

说明

我认为这是初次接触段树的人最常遇到的段树类型题目。

其优势在于，相比线性列表，它能在O(NlogN)的时间复杂度内构建出支持区间和、区间积、区间最大值等各种运算的结构，并能以O(logN)的高速访问各区间的信息。

本题主要可分为构建分段树的函数、查询区间信息的函数以及更新值的函数。

构建函数

首先来看构建分段树的函数

def make_segtree(target_list: list, result_list: list, start: int, end:int, now_node: int) -> int:
    '''
    최소 숫자 정보를 담는 세그먼트 트리를 생성하는 함수
    '''

    # 포인터가 한 곳으로 모인 경우
    if start == end:

        # 해당 노드는 포인터가 가리키는 인덱스의 값과 동일
        result_list[now_node] = target_list[start]

    # 포인터가 범위를 나타내는 경우
    else:

        # Devide and Conquer Algorithm

        # 중간 지점 선언
        mid = (start + end) // 2

        # 중간 지점을 기준으로 구간을 분할하여 최소값으로 갱신
        val_1 = make_segtree(target_list, result_list, start, mid, 2 * now_node)
        val_2 = make_segtree(target_list, result_list, mid + 1, end, 2 * now_node + 1)

        # 두 구간의 최소값을 비교하여 둘 중 최소값을 현재 노드에 기록
        result_list[now_node] = min(val_1, val_2)

    # 현재 노드의 값을 반환
    return result_list[now_node]

，该函数基本展示了将整个列表按区间拆分，并将各区间的信息存储到分段树各节点中的过程。

由于采用了递归方式，因此会不断堆积递归栈，直到区间长度为1为止；若递归成功，则将该地址对应的单个列表值信息写入其中。

随后，通过返回的值，非叶子节点会筛选符合条件的值，最终到达根节点。

因此，根节点中存储的值就是整个区间内最符合题目要求的值。

搜索函数

接下来查看查找区间内最小值的函数：

def find_min_number(target_tree: list, start: int, end: int, left: int, right: int, now_node: int) -> int:
    '''
    해당 구간의 최소값을 찾는 함수
    '''

    # 범위 내로 포인터가 좁혀진 경우
    if left <= start and right >= end:

        # 현재 노드값을 반환
        return target_tree[now_node]

    # 범위를 아예 벗어난 경우
    elif left > end or right < start:

        # None 값을 반환
        return None

    # 범위가 걸친 경우
    else:

        # Devide and Conquer Algorithm

        # 중간 지점 선언
        mid = (start + end) // 2

        # 중간 지점을 기준으로 구간을 분할하여 값을 확인
        val_1 = find_min_number(target_tree, start, mid, left, right, 2 * now_node)
        val_2 = find_min_number(target_tree, mid + 1, end, left, right, 2 * now_node + 1)

        # 반환된 값들 중 None이 존재하는 경우
        if val_1 is None and val_2 is None:
            return None

        elif val_1 is None:
            return val_2

        elif val_2 is None:
            return val_1

        # None이 없다면
        else:

            # 두 구간의 최소값 중에서 더 작은 값을 반환
            return min(val_1, val_2)

。该函数的基本逻辑是：只要包含目标区间，就进行详细搜索，直到仅包含目标区间为止，并返回该值以便上级函数进行验证。

如果超出范围，则返回None。通过条件判断进行剪枝（Pruning），即可确保仅选择范围内的区间进行比较。

修改函数

最后来看反映值被修改情况的函数


def change_segtree(target_tree: list, start: int, end: int, target_idx: int, target_val: int, now_node: int) -> None:
    '''
    리스트에 생긴 변경점을 트리에 반영하는 함수
    '''
    
    # 포인터가 한 곳으로 모인 경우
    if start == end:

        # 목표로 하는 인덱스랑 동일하다면 변경값을 반영
        if start == target_idx:
            target_tree[now_node] = target_val

    # 포인터가 범위로 주어진 경우
    else:

        # 목표 인덱스가 범위 내에 존재할 경우에만 갱신 가능성 존재
        if start <= target_idx <= end:

            # Devide and Conquer Algorithm

            # 중간 지점 선언
            mid = (start + end) // 2

            # 중간 지점을 기준으로 변경될 수 있는 인덱스를 재조사
            change_segtree(target_tree, start, mid, target_idx, target_val, 2 * now_node)
            change_segtree(target_tree, mid + 1, end, target_idx, target_val, 2 * now_node + 1)

        # 하위 노드들의 갱신이 진행된 이후 현재 노드의 갱신 진행
        target_tree[now_node] = min(target_tree[2 * now_node], target_tree[2 * now_node + 1])

由于如果包含当前被修改值的索引的区间，则必须全部更改，因此以该索引是否包含在区间内为标准进行区分。

与生成函数类似，会不断堆叠递归栈直至缩小到单个索引，并从仅包含该索引的节点开始更新其值，在返回过程中反映修改后的值，最终检查至根节点以完成操作。

解题代码

通过上述过程，可以将题目要求的全部操作模块化，以下是完整的代码。

# 수열과 쿼리 17

import sys
from math import ceil, log2

input = sys.stdin.readline

def make_segtree(target_list: list, result_list: list, start: int, end:int, now_node: int) -> int:
    '''
    최소 숫자 정보를 담는 세그먼트 트리를 생성하는 함수
    '''

    # 포인터가 한 곳으로 모인 경우
    if start == end:

        # 해당 노드는 포인터가 가리키는 인덱스의 값과 동일
        result_list[now_node] = target_list[start]

    # 포인터가 범위를 나타내는 경우
    else:

        # Devide and Conquer Algorithm

        # 중간 지점 선언
        mid = (start + end) // 2

        # 중간 지점을 기준으로 구간을 분할하여 최소값으로 갱신
        val_1 = make_segtree(target_list, result_list, start, mid, 2 * now_node)
        val_2 = make_segtree(target_list, result_list, mid + 1, end, 2 * now_node + 1)

        # 두 구간의 최소값을 비교하여 둘 중 최소값을 현재 노드에 기록
        result_list[now_node] = min(val_1, val_2)

    # 현재 노드의 값을 반환
    return result_list[now_node]

def find_min_number(target_tree: list, start: int, end: int, left: int, right: int, now_node: int) -> int:
    '''
    해당 구간의 최소값을 찾는 함수
    '''

    # 범위 내로 포인터가 좁혀진 경우
    if left <= start and right >= end:

        # 현재 노드값을 반환
        return target_tree[now_node]

    # 범위를 아예 벗어난 경우
    elif left > end or right < start:

        # None 값을 반환
        return None

    # 범위가 걸친 경우
    else:

        # Devide and Conquer Algorithm

        # 중간 지점 선언
        mid = (start + end) // 2

        # 중간 지점을 기준으로 구간을 분할하여 값을 확인
        val_1 = find_min_number(target_tree, start, mid, left, right, 2 * now_node)
        val_2 = find_min_number(target_tree, mid + 1, end, left, right, 2 * now_node + 1)

        # 반환된 값들 중 None이 존재하는 경우
        if val_1 is None and val_2 is None:
            return None

        elif val_1 is None:
            return val_2

        elif val_2 is None:
            return val_1

        # None이 없다면
        else:

            # 두 구간의 최소값 중에서 더 작은 값을 반환
            return min(val_1, val_2)

def change_segtree(target_tree: list, start: int, end: int, target_idx: int, target_val: int, now_node: int) -> None:
    '''
    리스트에 생긴 변경점을 트리에 반영하는 함수
    '''
    
    # 포인터가 한 곳으로 모인 경우
    if start == end:

        # 목표로 하는 인덱스랑 동일하다면 변경값을 반영
        if start == target_idx:
            target_tree[now_node] = target_val

    # 포인터가 범위로 주어진 경우
    else:

        # 목표 인덱스가 범위 내에 존재할 경우에만 갱신 가능성 존재
        if start <= target_idx <= end:

            # Devide and Conquer Algorithm

            # 중간 지점 선언
            mid = (start + end) // 2

            # 중간 지점을 기준으로 변경될 수 있는 인덱스를 재조사
            change_segtree(target_tree, start, mid, target_idx, target_val, 2 * now_node)
            change_segtree(target_tree, mid + 1, end, target_idx, target_val, 2 * now_node + 1)

        # 하위 노드들의 갱신이 진행된 이후 현재 노드의 갱신 진행
        target_tree[now_node] = min(target_tree[2 * now_node], target_tree[2 * now_node + 1])

# 수열의 크기 및 수열 정보 입력
target_length = int(input())
target_arr = ['*'] + list(map(int, input().split()))

# 수열의 구간 최소 숫자를 담을 세그먼트 트리 리스트 선언
segtree_arr = [None for _ in range(pow(2, ceil(log2(target_length) + 1)))]

# 함수를 호출하여 트리 생성
make_segtree(target_arr, segtree_arr, 1, target_length, 1)

# 퀴리 갯수 입력 및 출력 리스트 선언
query_number = int(input())
output = []

# 쿼리 실행
for _ in range(query_number):

    # 각 쿼리의 정보
    order_type, num_1, num_2 = map(int, input().split())

    # 타입 1의 경우
    if order_type == 1:

        # 리스트 값을 변경 및 함수를 호출하여 트리에 반영
        target_arr[num_1] = num_2
        change_segtree(segtree_arr, 1, target_length, num_1, num_2, 1)

    # 타입 2의 경우
    elif order_type == 2:

        # 함수를 호출하여 해당 구간의 최소 숫자를 출력 리스트에 추가
        output.append(find_min_number(segtree_arr, 1, target_length, num_1, num_2, 1))

# 결과 출력
for result in output:
    print(result)

Git 入门

Fri, 28 Oct 2022 13:19:01 GMT

简介

这是一篇在学习 Git 过程中整理所需内容的博文，如果没有重大变化或不需要进一步学习，我认为这既是一篇简介，也将是最后一篇文章。

什么是 Git？

Git 是一种版本控制工具，它通过版本控制记录文件的变更，从而允许用户重新使用特定时间点的记录。

本地版本控制

复制目录
- 最简单的方法
- 可能会不小心修改错误的文件，或者复制错误。
VCS（版本控制系统）
- 利用数据库管理文件的变更信息
- 修订控制系统（Revision Control System）是典型的代表
- 管理补丁集（文件中发生变更的部分）
- 利用一系列补丁集，可以将所有文件恢复到特定时间点

集中式版本管理

进行项目开发时，经常需要与其他开发人员协作
在这种情况下，单独设置一个管理文件的服务器，由客户端从中央服务器获取并使用文件的方式更为有利
如果中央服务器出现问题，且系统没有备份，可能会丢失所有历史记录，而这在本地也同样存在

分布式版本控制系统

不仅简单地保存快照，还会同时复制存储库和历史记录。
若服务器出现问题，可通过相应的副本恢复工作
也可从任意客户端中选择一个来恢复服务器
远程存储库的存在使得多种协作方式成为可能
GitHub也是此类远程存储库的一种

基本用法

配置及文件访问命令

# 전역 사용자 설정
git config --global user.name {name} # 이름
git config --global user.email {email_address} # 이메일

# 로컬 사용자 설정 (해당 디렉토리에서 실행)
git config user.name {name} # 이름
git config user.email {email_address} # 이메일

# 설정 조회
git config --list

# 생성
git mkdir {path}/{folder_name} # 폴더
git touch {file_name} # 파일
git init # 파일 관리 시스템

# 저장소 및 히스토리 복제
git clone {repository_url}

# 원격 저장소
git remote add {remote_repo_name} {remote_repo_url} # 추가
git remote -v # 정보 확인

# commit history
git log
git log --oneline # 정보 표시 간략화
git log --all # 현재 head 이후의 최신 기록들을 포함한 전체 정보를 표시
git log --graph # 브랜치를 시각화하여 분기를 표현한 그래프 형태로 정보를 표시

仓库管理命令

git status # 변경사항을 확인하는 명령어
git commit -m {message} # 현재 스테이지에 존재하는 변경 사항을 커밋

git add {file_name} # 특정한 파일을 스테이지에 추가하는 경우
git add . # 해당 레포지토리의 변경사항을 전부 스테이지에 추가하는 경우

Git 撤销操作

清空暂存区

git rm --cached # root commit이 존재하지 않을 때
git restore --staged # root commit이 존재할 때

修改提交

git commit --amend 
# 스테이지에 파일이 없는 경우: 직전 커밋의 메시지를 수정
# 스테이지에 파일이 있는 경우: 기존 커밋에 현재 스테이지를 더하여 덮어쓰기 진행

将提交回滚至特定时间点

git reset --soft {commit_id} # 미래 파일들 전부 stage에 돌려놓음
git reset --mixed {commit_id} # default, 미래 파일들을 전부 working directory에 유지 (add 필요)
git reset --hard {commit_id} # 미래 파일 전부 제거

删除历史提交

git revert {commit_id} # 과거 commit을 제거 후, 제거했음을 commit으로 추가

由于 reset 会减少提交数量，因此不适合协作环境；建议协作时使用 revert 代替 reset

Git 分支

分支：用于划分工作空间，帮助实现独立工作的机制

能持续保持原始状态，因此很安全
在一个分支上进行单一任务，从而提高协作效率
在 Git 中，创建分支的速度很快，且文件体积不大

Git Merge

合并分支的过程

合并类型

Fast-Forward：将分支指向的提交移至最前端
三向合并（3-Way Merge）：使用各分支的两个最新提交 + 两个分支的共同祖先进行合并
合并冲突：当修改了相同的文件时会发生冲突 => 解决冲突后进行三向合并

# 해당 브랜치를 현재 위치한 브랜치에 병합
git merge {merged_branch}

Git Fork

复制没有所有权的远程仓库，主要用于开源等协作对象较多的情况

我的提交反映到分叉源代码的过程

#
#    원본 원격 저장소 (upstream) <----------- 복제본 원격 저장소 (origin)
#                \           merge request      /|
#                 \                              |
#                  \                 push branch | pull master
#                   \                            |
#                    \     ( pull upstream )     |/
#                     ------------------> 로컬 저장소 (user)
#

将原始仓库复制到我的远程仓库
将该远程仓库保存到本地
在本地创建分支进行开发，并提交相关更改
向原始远程仓库推送合并请求
在原始远程仓库中合并该更改
从原始仓库拉取更新内容
- pull upstream
- sync origin & pull origin
删除本地已合并的分支

[BOJ 7579，Python] 应用程序

Fri, 28 Oct 2022 10:13:23 GMT

问题链接

boj 7579

分类

动态编程 (DP)、Knapsack 问题

描述

我个人认为，解决这个问题最重要的是问题条件。

使用中的内存字节数条件是 10^7，活动应用程序的数量必须最多为 100，成本必须小于或等于 100。

使用内存字节条件来检查误报率的范围非常大，因此我决定将成本设置为相应的变量，为每个成本分配一个地址，并记录我可以节省的内存量。

我推断这里应该使用 DP，并进一步设计了一个使用 knapsack 算法的解决方案，该算法使用代价和值，当值存在时，根据值更新现有值。

求解代码

# 앱

import sys

input = sys.stdin.readline

# 앱 갯수, 필요 메모리 입력
app_number, need_memory = map(int, input().split())

# 각 앱의 메모리와 비활성화 시의 비용 입력
app_memories = list(map(int, input().split()))
disable_costs = list(map(int, input().split()))

# 앱의 메모리와 비용 합쳐서 짝을 지어줌
memories_and_costs = list(zip(app_memories, disable_costs))

# 최대 필요 비용 연산
sum_cost = sum(disable_costs)

# 각 비용별 최대 절약 가능한 메모리 리스트 선언
cost_list = [0 for _ in range(sum_cost + 1)]

# Knapsack Algorithm

# 모든 앱에 대해 확인
for now_memory, now_cost in memories_and_costs:

    # 최대 필요 비용까지 조사
    for last_cost in range(sum_cost, -1, -1):

        # 최대 비용을 넘지 않는 선에서 확인
        if last_cost + now_cost <= sum_cost:

            # 기존 최대값보다 컸다면 갱신
            cost_list[last_cost + now_cost] = max(
                cost_list[last_cost + now_cost], cost_list[last_cost] + now_memory
            )

# 비용을 0에서부터 조사해서 기준 메모리 이상을 절약한 경우의 비용을 출력
for idx in range(sum_cost + 1):
    if cost_list[idx] >= need_memory:
        print(idx)
        break

[BOJ 15683, Python] 监视

Sun, 23 Oct 2022 10:46:34 GMT

题目链接

BOJ 15683

分类

暴力搜索算法（bruteforcing）、实现（implementation）、模拟（simulation）

说明

虽然该题的分类属于暴力搜索算法，但在实现过程中使用了回溯算法。

基本思路是遍历所有监控摄像头可见的方向，当所有监控摄像头的方向设置完成后，调用函数检查监控盲区的数量，如果该数值小于当前最小值，则更新该数值。

由于我习惯在完成解题后立即添加注释，因此后续的博文中，详细的解题方法也将包含在代码注释中。

解法代码

# 감시

import sys

input = sys.stdin.readline

def check_blind_spot(matrix: list, y_range: int, x_range: int) -> int:
    '''
    현재 사무실 내 사각지대 갯수를 반환하는 함수
    '''

    # 사각지대 변수 선언
    blind_here = 0

    # 모든 좌표에 대해서 조사
    for y_idx in range(y_range):
        for x_idx in range(x_range):

            # 해당 좌표값이 0일 경우만 카운팅
            if not matrix[y_idx][x_idx]:
                blind_here += 1

    # 결과 반환
    return blind_here

# 사무실 가로 및 세로 크기 입력
height, width = map(int, input().split())

# CCTV 정보 및 사무실 정보를 담을 리스트 선언
cctvs = []
work_space = []

# 초기 사각지대 갯수 확인
blind_spot = 0

# 사무실 정보 입력
for y_idx in range(height):

    # 행 정보 확인
    temp = list(input().split())

    # 모든 요소들에 대해 조사
    for x_idx in range(width):

        # 만약 CCTV가 있다면 리스트에 추가
        if temp[x_idx] in '12345':
            cctvs.append(((y_idx, x_idx), int(temp[x_idx])))

        # CCTV도 아니고 벽도 아니라면 초기 사각지대
        else:
            if temp[x_idx] == '0':
                blind_spot += 1

    # 행 정보를 리스트에 추가
    work_space.append(list(map(lambda x: int(x), temp)))

# CCTV 갯수 변수 선언
cctv_amount = len(cctvs)

# CCTV 방향 정보 딕셔너리 선언
cctv_directions = {
    1: {0: [(1, 0)], 1: [(-1, 0)], 2: [(0, 1)], 3: [(0, -1)]},
    2: {0: [(1, 0), (-1, 0)], 1: [(0, 1), (0, -1)]},
    3: {0: [(-1, 0), (0, 1)], 1: [(0, 1), (1, 0)], 2: [(1, 0), (0, -1)], 3: [(0, -1), (-1, 0)]},
    4: {0: [(-1, 0), (0, 1), (0, -1)], 1: [(1, 0), (0, 1), (0, -1)], 2: [(1, 0), (-1, 0), (0, -1)], 3: [(1, 0), (-1, 0), (0, 1)]},
    5: {0: [(1, 0), (-1, 0), (0, 1), (0, -1)]},
}

# 각 CCTV의 방향 정보를 담은 리스트 선언
max_direction = ['dummy', 4, 2, 4, 4, 1]

# CCTV가 존재하지 않는 경우 기존 사각지대의 갯수를 출력
if not cctv_amount:
    print(blind_spot)

# 만약 존재한다면 CCTV 방향에 따른 사각지대의 갯수를 조사
else:

    # 최종 사각지대 갯수 변수 선언
    result = blind_spot

    def min_blind_spot(field: list, cctv_list: list, sight: dict, max_direction: list,
                       now_cctv: int = 0, y_range: int = height, x_range: int = width,
                       limit_cctv: int = cctv_amount) -> None:
        '''
        CCTV를 모두 최적의 상태로 설치할 때 최소 사각지대 갯수를 확인하는 함수
        '''

        # 결과값 전역 변수 등록
        global result

        # Back Tracking

        # 모든 CCTV를 전부 확인한 경우
        if now_cctv == limit_cctv:

            # 현재 사각지대 갯수 확인
            now_result = check_blind_spot(field, y_range, x_range)

            # 기존 최소값보다 작은 경우 갱신
            if result > now_result:
                result = now_result

            return

        # 아직 확인하지 않은 CCTV가 존재하는 경우
        else:

            # 현재 확인할 CCTV 정보 확인
            cctv_idx, cctv_type = cctv_list[now_cctv]

            # 좌표 분리
            y_cctv, x_cctv = cctv_idx

            # CCTV에 종류에 따라 감시 방향의 경우의 수만큼 조사
            for direction_code in range(max_direction[cctv_type]):

                # 현재 주시 방향 확인
                cctv_directions_now = sight[cctv_type][direction_code]

                # 해당 주시 방향에서 볼 수 있는 좌표를 담을 리스트 선언
                now_view = []

                # 깊이 탐색을 진행할 방향 설정
                for direction in cctv_directions_now:

                    # 이동 방향 좌표 분리
                    move_y, move_x = direction

                    # 초기 좌표 설정
                    now_y, now_x = y_cctv, x_cctv

                    # 해당 방향에 대해서 반복 조사
                    while True:

                        next_y, next_x = now_y + move_y, now_x + move_x

                        # 사무실 범위를 벗어나지 않은 경우
                        if 0 <= next_y < y_range and 0 <= next_x < x_range:

                            # 벽을 만났다면 반복 종료
                            if field[next_y][next_x] == 6:
                                break

                            # 벽을 만난 것이 아닐 경우
                            else:

                                # 해당 좌표가 사각지대일 경우
                                if not field[next_y][next_x]:

                                    # 리스트에 기록 후 비사각지대 처리
                                    now_view.append((next_y, next_x))
                                    field[next_y][next_x] = '#'

                                # 현재 좌표 갱신
                                now_y, now_x = next_y, next_x

                        # 사무실 범위를 벗어났다면 반복 종료
                        else:
                            break

                # 수집한 좌표들을 다음 CCTV에 조사
                min_blind_spot(field, cctvs, cctv_directions, max_direction, now_cctv + 1)

                # 초기화
                for y_idx, x_idx in now_view:
                    field[y_idx][x_idx] = 0

    # 함수를 호출하여 결과 도출
    min_blind_spot(work_space, cctvs, cctv_directions, max_direction)

    # 결과값 출력
    print(result)

第一篇

Sat, 22 Oct 2022 18:26:40 GMT

以前，我都是把笔记整理成个人专用的，只供自己查看。

但后来我开始思考：既然如此，那还有必要费心把它整理得那么漂亮吗？于是，在“精心整理后发布到显眼处”与“草草记下后发布到显眼处”之间，我选择了后者。

希望我学习并整理的内容，不仅能对我自己有所帮助，也能对可能读到这篇文章的其他人有所裨益。