Kiramux

美术资源备忘录

Kiramux — Wed, 07 Aug 2024 00:00:00 GMT

这是一个我个人整理的美术资源备忘录，用来记录我曾经觉得很有用但没来得及整理的美术资源。

通常来说这些资源我浏览过之后会觉得很有用或是“之后一定用得到”，于是我把它们放进了b站 / 浏览器收藏夹，或是在 To Do 列表中贴一个地址。今天我偶然打开我的某个 To Do 列表，我竟然无法得知曾经的我是为什么记下它们。放在B站收藏夹里的那些视频，等到我真正需要它们时去翻找它们，费事费力，同时也会发现收藏夹里多了一些 “已失效的视频”，然而翻来找去却找不到自己想要找的那条视频，或许它就藏身于这些“已失效的视频”里……于是我想借此机会把自己曾经接触到的一些美术资源列出来作备忘，以免自己在有某些需求急需实现时忘了他们，而又焦头烂额甚至病急乱投医。这里会有一些大大的心得笔记、一些个人博客或是一些课程推荐的记录，也有一些书籍推荐，同时会附上推荐理由，虽然可能会没有时间去做整理，只是堆在这里，避免我自己忘记它们而已。

我该列个书单了。。

目录系列

MadlineCG专题推送目录

https://mp.weixin.qq.com/s/PWuffjACVugobNiwsdrI4A

里面有很多很有价值的文章和教学，包括创作思路分析等等

技术美术百人计划目录 by May

https://docs.qq.com/doc/DUFlzT3ByV2tHanpT

分为 图形部分 、 美术部分 、以及一些其他的建议。

以求职为导向的入门级Unity攻略

https://zhuanlan.zhihu.com/p/644800944

课程 / 视频合集系列

合集·【美感提升】角色设计 by. 不要小白兔

https://space.bilibili.com/431071234/channel/collectiondetail?sid=2896715

合集·【美感提升】场景设计 by. 不要小白兔

https://space.bilibili.com/431071234/channel/collectiondetail?sid=3098951

【绘画教程】皮克斯搬运！色彩与光影。外网大佬视频，包看包会，记得收藏

https://www.bilibili.com/video/BV1UW411o7PJ/

Blender4.0建模入门教程_超细节100集课程新手必学 by. 阿发你好

https://www.bilibili.com/video/BV1fb4y1e7PD/

Unity2024新手入门教程_超细节100集课程 by. 阿发你好

https://www.bilibili.com/video/BV1TZ4y1o76s/

注意，这部合集是我从知乎上找 unity 特效时找到的。

https://zhuanlan.zhihu.com/p/483450692

tips: 又上知乎别的帖子得知 “永远的孤月”“魔王虾”是割韭菜之神，最好闭坑。

割韭菜详情见：https://www.zhihu.com/question/616249171

实名反对魔王虾/皮皮虾/永远的孤月的回答，开发 b站有很多视频千峰黑马啥的都有免费课，ta建议看霜狼的百人计划，特效目前公开课都是基础教程，熟悉完粒子系统参数后，找何sir（moba）李可浮生（二次元手绘） sin（写实）西西（moba）捷导（二次元手绘）除了皮皮虾/火星时代都可以学，b站有锤大佬皮皮虾的视频，可以看下。我做特效的说一下特效需要的软件，unity/ue引擎（二选一） ps处理贴图 max/blend/maya做模型（大部分还是max。不知道你是不是美术生，做特效需要美术，确实是不会可以学，但是有没有审美天差地别，就像皮皮虾做的东西，你看看他做的，然后去魔法盒这个网站，看一下首页作品，这就是审美差距。

而这部合集就是他推荐的特效视频，因此对于 Unity 特效有没有帮助存疑。不过 up 主阿发你好是我曾经就关注过的，但是他的视频我还没有看过。

但是原文提供的链接时旧版，这位 up 主已经将其下线了并重新上线了新版。

旧版的原链接：https://bilibili.com/video/BV1WK411V7dn

【缺课】黄捷Unity3d二次元手绘与CG特效制作第48期【画质高清有大部分素材】

https://chenwenb.com/hju3d2cyshcgtx.html

二次元手绘风格特效。简单看了一下，淘宝上也是117节课的缺课版本，因此大元资源网上的版本应是和那边一样的。

网盘会有备份。

西西MOBA游戏特效课程基础篇【画质不错有素材】

https://chenwenb.com/xiximobayxtx.html

网盘会有备份。

单集视频系列

二次元，但写实！首次详解个人作画流程+基础科普 by. mikasamu

https://www.bilibili.com/video/BV1wi421Y7vB/

Giant Buffalo-Photoshop Manipulation Speed Art Tutorial

https://youtu.be/TN_vWXLu9YQ

个人博客系列

大空昴单推人的个人图书馆

http://www.360doc.com/userhome.aspx?userid=64191223

网站列表

魔法盒

https://www.magesbox.com/

貌似是一个很厉害的特效社区，可以进去膜拜一波。

书籍推荐

[OCR] ARTISTS' MASTER SERIES - Color&Light

部分汉化： https://www.bilibili.com/opus/841142548650000389

网盘有备份

【转载】 Unity Shader 毛发实现

Kiramux — Wed, 07 Aug 2024 00:00:00 GMT

原标题：真香预警！新版“峡谷第一美”妲己尾巴毛发制作分享

原文链接

原创 腾讯游戏学院腾讯游戏学堂 2019-02-20 19:44

关于作者：梁家斌，腾讯互动娱乐天美工作室群高级游戏美术师。

之前有很多人来询问新版妲己宝宝

毛茸茸的尾巴 做法，

先谢谢大家对这个毛发效果的认可，

我在这里就简单的分享一下，

毛发的实现思路和制作方法。

毛绒材质在生活中出现的频率非常高，

但是在各种游戏中，

我们却很少看到这种材质效果的良好表现，

原因在于它们的制作与渲染成本都太高了。

所以， 实时毛发渲染

是业内最为期待的次世代特效之一。

我们先看看这些材质的特征：

<center>[ 毛茸茸的衣服 ]</center>

<center>[ 可爱的毛绒玩具 ]</center>

<center>[ 毛茸茸的动物 ]</center>

他们有着柔软的丰富的外轮廓、

柔和的光影、温暖，

这种材质表现一直是女孩子所喜爱的。

<center>[ 微观的毛发，其实可以理解为一根根的圆柱体，越细毛发的质感越柔软 ]</center>

<center>[ 无数细小的圆柱体拼合在一起，就形成了我们看到的皮毛效果 ]</center>

因为毛发复杂性与庞大的计算量

（每根毛发产生的阴影遮挡），

所以在毛发渲染方面，

基本一直都是离线渲染的专利。

<center>[ MAYA毛发渲染 ]</center>

<center>[ 迪士尼《疯狂动物城》毛发渲染 ]</center>

直到最近，

GPU处理能力才达到实时计算毛发的标准，

当然那也是针对PC平台而言，

我们手机暂时还望尘莫及。

<center>[ Square Enix 夜光引擎的毛发 ]</center>

我们一般游戏的毛发渲染，

都是将毛发纹理放到模型面片上面，

用AlphaBlend或者AlphaTest剔除镂空区。

但这两者也都无法尽善尽美：

-AlphaBlend没有深度会有模型穿插问题。

-AlphaTest有顶点深度但边缘锯齿感严重，

需要在SSAA下面才不会有明显的锯齿。

-两者结合使用效果比较好，

但会带来更高的性能消耗。

所以至今为止，

游戏上面都很难做到满意的毛发表现，

尤其是手游，

往往我们只能从设计层面去规避这些问题。

毛发的特征

要制作一个东西，

我们必须抓住它的特点。

那么毛发有哪些特征呢？

我稍微归纳了一下：

通透性-次表面散射：

毛发是非常的细小的，

光线很容易就可以穿透它的表面，

尤其是浅色毛发，

颜色越深吸收光线的能力越强，

所以深色发毛的透光性相对较低。

<center>[ 不同颜色的毛发通透性差异 ]</center>

<center>[ 逆光下的深色头发与浅色头发 ]</center>

这也是为啥很多女孩子

比较喜欢染发、烫发的原因之一。

因为浅色比黑色的毛发，

在逆光下的效果要漂亮很多。

烫发可以使头发蓬松，

让更多的光线穿透与反弹，

这样整体的层次感会变得很丰富。

复杂的遮蔽性：

毛发又非常的密集，

毛发相互之间的阴影遮挡造成毛发。

密集的地方光线也很难继续渗透进去，

就形成了发根到发梢的阴影渐变。

<center>[ 毛发的Occlusion ]</center>

特殊的高光-各项异性高光：

头发的表面并不是光滑的，

上面有一层被称之为毛鳞片的结构，

产生的高光散射性很高，

很多人造毛很难做到这一点。

这也是为啥很多廉价的假发的质感

让人一眼就看出来不真实的原因。

<center>[ 显微镜下的头发 ]</center>

上面我们说了头发，

是排列在一起的一个个细小圆柱体。

很多人不理解为什么

我们要把头发的高光叫做各项异性高光，

我用一张图简单说明下。

<center>[ 各项异性高光的产生 ]</center>

我们这里提到的所谓各向异性高光，

其实是我们没办法真的将头发

用一个个圆柱体来渲染，

而使用一种基于观察近似的算法模拟结果。

而动物的短毛皮比人类头发更加复杂，

可以大致分为两类，

一种是表层的长毛（被毛），

另一种是内层的绒毛（更加细小、弯曲）。

丝绸同理但更加复杂，

不同的丝本身质感就不一样，

加上不同针织结构，

如纱、绮、绢、锦、罗、绸、缎等10多类，

造成丝绸效果最终质感有很大的差异性，

有兴趣可以深入了解不同丝绸的微观结构。

制作思路

说了这么多。

在手机游戏里怎么实现这些效果呢？

用顶点细分来制作不现实，

这么大量的毛发，

又是移动端平台，

机器的计算性能达不到要求。

而用大量面片插片的方式，

会占用大量3D美术的人力成本，

尽管效果是很好，

相对效果来说也不太划算。

最后选择了美术制作上最简单的

多pass渲染的方案。

因为这套方案在美术资源制作上，

基本上和普通角色资源没有差别，

唯一的限制就是skin多边形数量上的限制。

而且这套方案在PC端游上已经比较成熟，

比如《剑灵》。

多pass的方法局限性也很大，

不过我们可以拆分开来研究和优化。

layer实现方式

<center>[ 多pass的实现方式 ]</center>

根据模型使用层 (layer) 来渲染毛发长度，

在 Unity Shader 中，

每一个 Pass 即表示一层。

当渲染每一层时，

使用法线将顶点位置挤出模型表面。

Pass及使用的层数越多渲染效果越好，

当然开销也越大。

这种做法如果想要很好的表现，

就需要大量的pass。

如何用少量的pass实现更好的效果，

后面我们再一步步解决。

float3 aNormal = (v.normal.xyz);

aNormal.xyz += FUR_OFFSET;

float3 n = aNormal * FUR_OFFSET * (FUR_OFFSET * saturate( v.color.a )); //顶点色alpha通道控制毛发扩展范围

然后将Noise贴图根据layer做衰减，

来当做alpha值。

<center>[ Noise贴图 ]</center>

_UVoffset ("UV偏移：XY=UV偏移;ZW=UV扰动", Vector) = (0, 0, 0.2, 0.2)

一定加入基于layer层高度的UV偏移。

• 没有UV偏移效果的毛怎么看都会像刺猬。

• 记得对毛发做UV偏移的时候，

Diffuse贴图的UV也要跟着一起计算哦。

float2 uvoffset= _UVoffset.xy  * FUR_OFFSET;

uvoffset *=  0.1 ; //尺寸太大不好调整 缩小精度。

float2 uv1= TRANSFORM_TEX(v.texcoord.xy, _MainTex ) + uvoffset * (float2(1,1)/_SubTexUV.xy);

float2 uv2= TRANSFORM_TEX(v.texcoord.xy, _MainTex )*_SubTexUV.xy   + uvoffset;

o.uv = float4(uv1,uv2);

half3 NoiseTex = tex2D(_SubTex, i.uv.zw).rgb;

half Noise = NoiseTex.r;

color.rgb = lerp(_Color,_BaseColor,FUR_OFFSET) ;

color.a = saturate(Noise-FUR_OFFSET) ;

return color;

也可以加入风力、重力等顶点控制项。

根据不同性能的机器来选择是否开启。

<center>[ Noise混合 ]</center>

也可以将多层Noise

混合到一起来做一些不同的毛发，

将他们分别放到R、G、B不同的通道里，

可以减少贴图量。

缺点：

• 这样大家能看出来，

多pass的制作方式，

无法制作头发这样的长毛，

只能制作较短的毛发。

不过我们这次的目标也是制作短毛，

所以长毛与头发可以先抛开。

• 要有比较好的效果，

就需要非常多的pass来进行计算，

这也是我们不希望的。

因为移动平台对大量Overdraw这样的

像素级处理是非常大的一笔开销。

<center>[ layer30 : layer10 ]</center>

layer的层数是越少效率越高的，

在低layer上得到更好效果是我们的目标。

我将控制半透明毛发的曲线做了一些优化，

勉强可以在低layer上面达到多layer的效果。

<center>[ 对Alpha的衰减曲线做调整 ]</center>

<center>[ layer30 : layer10 : 拟合曲线后的layer10 ]</center>

优化Layer数量

一般的做法：

alpha = Noise -FUR_OFFSET;

优化后：同时加入了可控的变量。

alpha = (Noise*2-(FUR_OFFSET *FUR_OFFSET +(FUR_OFFSET*FurMask*5)))*_tming ;

灯光

到现在为止，

在外形上基本接近了我们想要的毛发效果。

我们还需要将毛发的渲染特征也加上去。

这里用3个部分来实现：

环境光、轮廓光、太阳光

环境光：

环境光可以是一个单色，

也可以是一个微弱的顶底渐变，

或者球协光照（提取Hdir贴图低频数据）。

<center>[ 这里可以根据不同项目的需求来定义 ]</center>

这里以简单的顶底颜色为例：

float3 normal = normalize(mul(UNITY_MATRIX_MV, float4(v.normal,0)).xyz);

half3 SH = saturate(normal.y *0.25+0.35) ;

<center>[ 无环境光遮，与真实效果差异很大 ]</center>

前面讲了毛发的特点之一

就是环境光遮蔽与自阴影，

缺少了环境光遮蔽的效果只能打20分。

环境光遮蔽形成的散射是带有颜色的，

会根据物体的颜色不同产生不同颜色。

我很懒，就没将颜色与环境光遮蔽

之间的关系公式写进去，

直接开放一个颜色手动设置反弹的颜色。

（也能节约一些计算不是~）

half Occlusion =FUR_OFFSET*FUR_OFFSET; //伽马转线性最精简版

Occlusion +=0.04 ;

half3 SHL = lerp (_OcclusionColor*SH,SH,Occlusion) ;

<center>[ 无环境光遮 vs 加上环境光遮蔽 ]</center>

但要记住固有色越浅，

反弹光就越强，

Visibility的影响就越弱；

反之颜色越深，

反弹光就越弱，

Visibility的影响就越强；

简单的说就是：

**物体的颜色越浅，**AO颜色越浅；

**反之颜色越深，**AO颜色越深。

轮廓光：

轮廓光其实也是环境光的一部分。

这里单独给轮廓光计算，

也只是弥补环境反光的不足，

同时加一些可控项，

也可以调出一些特殊的不一样的效果。

<center>[ 毛发轮廓光 ]</center>

同时也和上面的一样，

物体的颜色越浅，

轮廓光穿透率越强；

反之颜色越深，

轮廓光穿透率越弱。

这里也一定要加入环境光遮蔽的遮挡，

因为毛发的透光性，

边缘稀疏的部分光线穿透率更高。

同时模拟了在环境光下次表面散射效果。

<center>[ Fresnel ：Fresnel+Visilibity ]</center>

差异性在低多边形下会更加明显。

half Occlusion =FUR_OFFSET*FUR_OFFSET; //伽马转线性最精简版

Occlusion +=0.04 ;

half Fresnel = 1-max(0,dot(N,V));//pow (1-max(0,dot(N,V)),2.2);

half RimLight =Fresnel * Occlusion; //AO的深度剔除 很重要

RimLight *=RimLight; //fresnel~pow简化版

RimLight *=_FresnelLV *SH; //加上环境光因数

   SHL +=RimLight；//与环境光结合

<center>[ 模型线框：Occlusion平方：Occlusion4四次方 ]</center>

将Occlusion的计算

放到RimLight平方的前面，

是因为模型的多边形数量低，

轮廓会比较明显。

将Occlusion4次方，

能更好的减弱低多边形的影响。

因为我们用于毛发材质的模型面数，

是非常非常低的，

如果模型面数相对高一些的模型，

可以放到后面。

<center>[ 环境光最终渲染结果 ]</center>

太阳光：

我们平常说的太阳光，

其实可以把它看成是平行光。

太阳其实是个点光源，

不过因为它过于庞大，

光线到地球上面的夹角非常非常小，

再到我们的可视物体的时候，

就完全可以忽略掉了。

<center>[ 太阳为什么是平行光 ]</center>

我们就取最简单的公式。

half3 lightDir = -_SGameShadowParams.xyz; //外部传入的灯光方向

half NoL =dot(lightDir,normal);

half DirLight =NoL * _FurDirLightExposure*_DirLightColor;

普通光照模型这样计算没有问题，

但完全没有毛发的特性：

缺少太阳光在边缘的穿透性，

也没有逆光下的毛发次表面散射效果。

缺少每根毛产生的复杂的阴影表现。

<center>[ 阴影与光线边缘的穿透 ]</center>

用一个最简单的拟合就可以得到这个效果。

主要利用了NdotL（-1~1）的特性。

_LightFilter("平行光毛发穿透",  Range(-0.5,0.5)) = 0.0

half3 lightDir = -_SGameShadowParams.xyz;

half NoL =dot(lightDir,normal);

half DirLight= saturate (NoL+_LightFilter+ FUR_OFFSET ) ;

DirLight *=_FurDirLightExposure*_DirLightColor;

最后将所有光照合并到一起：

<center>[ 佩奇陪你过大年 ]</center>

• 为了节省性能，所有灯光与颜色计算全部在顶点空间完成；

• 像素空间只用来计算贴图采样；

• 很多需要贴图一起计算颜色值的地方都优化省略掉了，比较遗憾。

• 所有颜色计算都是在线性空间进行的所以最后要转换到伽马空间。这一步也可以去掉，也可以再加上简单的tommping，让画面颜色变得更好。

高光 - Anisotropic（各项异性）

前面讲毛发特性的时候，

对各项异性高光做了个简单的介绍。

<center>[ Anisotropic（各项异性） ]</center>

学术上Anisotropic（各项异性）的解释：

• 某些材质上有一些微观上有方向的细丝，这些细丝在宏观角度来看是不易察觉的，典型的有光盘的背面或者是头发。

• strand based anisotropy是对上述光照情形的一种建模。

（http://www.bluevoid.com/opengl/sig00/advanced00/notes/node159.html）

一些Anisotropic表现的例子：

<center>[ 《爱丽丝惊魂记：疯狂再临 (Alice: Madness Returns)》 ]</center>

各向异性制作的各种具体实现方式

我就不一一细说了：

<center>[ 沿着法线方向去偏移切线 ]</center>

float3 TShift(float3 tangent,float3 normal,float shift)
           {
               return normalize(tangent + shift * normal);
           }

<center>[ Anisotropic高光 ]</center>

float StrandSpecular(fixed3 T,fixed3 V,fixed3 L,fixed exponent)
   {
       float3 H = normalize(L+V);
       float dotTH = dot(T,H);
       float sinTH = sqrt(1- dotTH * dotTH);
       float dirAtten = smoothstep(-1,0,dotTH);    
       return dirAtten*pow(sinTH,exponent);
   }

用抖动忒图来弥补头发细节。

<center>[ 抖动贴图制作头发高光细节 ]</center>

头发比较特殊 观察头发的高光会发现，

其中一层高光是有颜色的，

另外一层高光是没有颜色的，

且两层高光的相互错开一点点。

<center>[ 观察头发高光 ]</center>

<center>[ 头发双层高光公式 ]</center>

我们根据公式在VS里计算出高光效果。这时候会发现高光效果会很粗糙，

简直有点不堪入目。

一步一步来优化。

• 依然使用上面已经使用老套的方法，

用FUR_OFFSET做高光的遮蔽后，

因为VS渲染精度方面过低的问题缓解了，

但效果方面依然不是太好。

fixed SPec1 =StrandSpecular (T1,V,L,_specExp.x)*FUR_OFFSET;

<center>[ 高光加入FUR_OFFSET对比 ]</center>

• 因为毛束是一个个细小的单个圆柱体，

它的高光也并不是一个平面连续的表现。

我想了很多方法来弥补毛发体积与细节。最终下面的结果相对来说，

得出的结果是目前得出的最好的。

大家猜一下——下面这张图是怎么得到的？

<center>[ color = Alpha平方 ]</center>

其实这就是我们目前的alpha当做色彩输出的结果。

• 越靠近透明的区域越黑，中间区域偏亮。

• 它刚好能达到我们高光缺少的细节部分的要求。

我就用它来当做单根毛发边缘体积的遮挡。

得到的结果很不错。同时这个也替代了抖动贴图。

color.rgb +=i.Specular  * (Noise*Noise);

<center>[ 加入Noise遮罩,代替抖动贴图方案 ]</center>

加入低频与高频2层高光后的效果更加自然。

<center>[ 双层高光效果 ]</center>

fixed3 T1 = normalize(_specExp.z*normalWorld+binormalWorld);
fixed3 T2 = normalize(_specExp.w*normalWorld+binormalWorld);
fixed SPec1 =StrandSpecular (T1,V,L,_specExp.x) *FUR_OFFSET;
fixed SPec2 =StrandSpecular (T2,V,L,_specExp.y) *FUR_OFFSET;
o.Specular  = SPec1*_SPColor1  + SPec2*_SPColor2;

高光部分我测试了很多方案，目前效果只能说还能凑合着用，因为都是在VS进行的计算，

效率上面应该还行。

高光参考资料：

https://developer.amd.com/wordpress/media/2012/10/Scheuermann_HairRendering.pdf

结语

第一次写分享，

罗里吧嗦的写了一大堆。

效果方面肯定还有非常大的优化空间。

欢迎大家一起讨论和指正。

一些个人遇到的问题\：

• 毛发UV控制部分我加入了flowmap，

但是FlowTex的绘制太困难，

而且也不直观。

可以做个工具实时直观看到flowmap

在毛发上面的绘制效果。

甚至可以直接在unity绘制到模型顶点色

XY2个值上面控制毛发方向。

• 多模型重叠的时候还是有深度穿插。

分享一个16年的国外视频，

用了另一种方案来控制毛发长度与方向。

<center>[ https://www.youtube.com/watch?v=bl61E2j_q-U ]</center>

Unity Shader 入门笔记vol1--第一束光

Kiramux — Tue, 08 Oct 2024 00:00:00 GMT

前面的碎碎念

本人从 2024 年 3 月初识技术美术，然后一边烦恼一边在各大平台乱逛，想要了解这个职位究竟如何。期间也断断续续学了一点点，就这么犹犹豫豫半年过去了，直至前阵子总算清除了所有的迷惘，并且学过了那些基础的光照模型。

本人是按照 AP01 的课程来入门的，目前刚好处于学过光照模型，然后做过第一个 DOTA2 大作业的状态，勉勉强强可以说是入了半个门了。接下来用我的节奏讲讲我的一些理解。

本人在学习技术美术的过程始终贯彻一个原则——“装懂”，听的懂的很好，听不懂的先装作懂了先用着，秉持一个能跑就行，先跟着走，之后再尝试理解。因此直到现在那些输入结构、输出结构、像素 Shader 之类的东西我还没弄懂。

首先是渲染流程，我还没弄明白，只是在脑中有一个懵懂的概念，因此先贴上PPT。

第一束光-Lambert

向量 ( Vector )：既有大小也有方向的量；如：力，速度等。

理论上不存在没有大小，只有方向的量；但存在大小无现实意义的量，我们多把它归一化处理，在 Shader 中如果出现大于 1 的量会比较危险。
点乘/点积/Dot ：两向量间的一种运算方式，结果为一标量，具有良好的几何含义。

结果的几何意义为：一个向量在另一向量上的投影长度；

结果的图形学表现为：两向量 方向同 结果= 1 （白色）； 方向反 结果= 1 （黑色）；垂直结果= 0 （黑色）

根据向量点乘的图形学含义我们令：

• 模型表面的垂直方向为向量 nDir 即：法线方向（ NormalDirection ）; • 令光照方向的反方向为向量 lDir 即： LightDir ，光方向（由物体表面指向光源）; • 令 nDir · lDir (两者点乘) 结果为像素输出；

则有下图的光照表现

其中：

最亮处：值为1，纯白；
明暗交界处：值为0，纯黑；
暗部：值为负数，亦为黑；

负数是个无意义的亮度，所以我们通常把结果为负数的值截断，都改为 0 ：

Max(0 , nDir · IDir);

即为 兰伯特光照模型 ( Lambert )

截断负值的做法还可以用 Clamp 0-1 。

Shader Forge 实现

我们在 Shader Forge 中新建一个 Unlit 模型作为基础，我们所有的效果都靠自己写，不涉及 Unity 的黑盒的东西。

此处观察 Shader Forge 中的 Light Dir. 的图片就可以理解光方向其实是 “光方向的反方向”

我们先给场景内添加个球，然后对这个 Shader 右键 >> Create >> Material ，用它创建一个材质。然后拖动这个材质到球上，就把这个材质附给这只球了。

HalfLambert

我们现在有了兰伯特光照模型，感觉这个兰伯特的暗部全是一片死黑。那么有一种改进方法。

如下图，对兰伯特的结果 [-1,1] * 0.5 + 0.5 ，得到一个 [0,1] 的结果，这就是半兰伯特（ HalfLambert ）。它的优缺点如图所示，虽然比 Lambert 更透气，但是显然它不符合我们常见的光照情况，因为半兰伯特是一个经验模型，他并不是由物理公式推理而来的。实际上之前版本的 cs 就使用了半兰伯特模型。

Shader Forge 实现

这里的 Clamp 0-1 等效于之前所做的 Max0

半兰伯特放到这个球上还是挺漂亮的。

HalfLambert 调子映射

考虑对半兰伯特做映射。上面讲点积时提到，点积的结果是一维的，但是要对一张贴图（RampTex）采样需要一套 UV （2维），就是说必须要有2个值才能去采样一张贴图。想像那些模型展 UV 时，把模型拆开然后摊大饼，在U坐标V坐标摊开，然后去做贴图之类的东西。这不可能只摊成一条线，那样采样贴图是不可能的。

我们现在有了 HalfLambert 这个一维的常量，那么如何得到一个二维向量呢？

这里就要用到 Append 节点，我们把 2 个标量/一维向量 Append ，就变成了一个二维向量（即有2个分量的向量），一个二维向量和一个标量/一维向量 Append 就变成了三维向量，最多到四维，理解为 RGBA 4个通道。（另外 Component Mask 节点是拆分量的）

那么我们可以把 HalfLambert 和一个常量 Append 成一个二维向量，把它作为 UV 去采样一张贴图（RampTex），采样的结果连接到 Shader Forge 里的 Emission 就完成了。

这里一般来说贴图的渐变是横坐标变换，所以把半兰伯特作为横坐标，另外给的常量作为纵坐标。

然后我们可以用 HalfLambert 做一个简单的卡通渲染（简称”卡渲“）。

贴图的特点：

3 阶明度，过渡卡硬。

暗部做色相变化，少明度变化。

明暗交界线附近由于有偏红的 SSS 效果，光能守恒的原因可能在明暗交界线附近的亮部，会些许泛蓝。

这张贴图尺寸不用很大，采样贴图是一个比较费的操作，一般128*128即可。

可能遇到的问题

最亮处有暗点：把渐变纹理的 Wrap Mode 从Repeat 改为 Clamp 模式。

需要注意的是，我们需要把渐变纹理的 Wrap Mode 设为 Clamp 模式，以防止对纹理进行采样时由于浮点数精度而造成的问题。图 7.19给出了 Wrap Mode分别为 Repeat和 Clamp模式的效果对比。可以看出，左图(使用 Repeat 模式)中在高光区域有一些黑点。这是由浮点精度造成的，当我们使用 fixed2(halfLamberthalfLambert)对渐变纹理进行采样时，虽然理论上 halfLambert 的值在【0，1】之间，但可能会有 1.000 01 这样的值出现。如果我们使用的是 Repeat 模式，此时就会舍弃整数部分，只保留小数部，得到的值就是 0.000 01，对应了渐变图中最左边的值，即黑色。因此，就会出现图中这样在高光区域反而有黑点的情况。我们只需要把渐变纹理的 Wrap Mode 设为 Clamp 模式就可以解决这种问题。

——《Unity Shader 入门精要》

描边有锯齿：卡渲一般标配抗锯齿后处理，暂时不用考虑。

附带一些卡渲的不同风格

Onedrive 迁移方案记录

Kiramux — Tue, 08 Oct 2024 00:00:00 GMT

本文所提到的 onedrive 包含 onedrive 和 sharepoint 两种，它们本质上都是 sharepoint ，同时文中提到的 od 都是指它们。

迁移 OneDrive 时应当考虑 api 限制问题。
目前未知 clouddrive 是否会重试失败任务。
本文只考虑向较为稳定的网盘迁移，国内网盘如百度、阿里、123盘不考虑。
本次记录从 od E5 到 od E5/家庭版、 pikpak 、 115 的迁移方案。

秒传情况

秒传就是两个云盘之间的文件可以快速相互上传，不用等待。

左侧为来源网盘、顶部为目标网盘

	onedrive/sharepoint	pikpak	115
onedrive/sharepoint	×	√	√

onedrive/sharepoint >> onedrive/sharepoint

rclone 是最优解，其他的一概不推荐。

一般来说直接用 rclone 复制即可。

rclone copy "backup01:/汉化会社合集部分 part8/" "s1:/汉化会社合集部分 part8/"  -P

rclone copy "backup01:/汉化会社合集部分 part8/" "s1:/汉化会社合集部分 part8/"  -P --onedrive-chunk-size 100M

加上 -P 可以持续输出日志。如果有报错，可以再运行下面这行，输出错误日志，看看哪些文件出错了。一般是文件报毒，没加密压缩上传导致的。这种情况在网页版 od 仔细翻翻就可以取回了。

rclone copy "backup01:/汉化会社合集部分 part5/" "s0:/汉化会社合集部分 part5/"  --log-level ERROR --log-file hh5.log

如果想同步（删掉目标文件夹的一些文件实现同步），可以用 sync 命令。

rclone sync -v R2:/img sayafx02:/img-backup  -P

另外再记录一种情况，想要批量复制文件夹到另一个盘中。

例如最近我要把 E5 od 的 2T 文件夹分开迁移到家庭版 2 个 1t 的 od 中。如下所示。

E5/Folder1 300g
E5/Folder2 300g
E5/Folder3 300g
E5/Folder4 300g
E5/Folder5 300g
E5/Folder6 300g

Personal-1/Folder1 300g
Personal-1/Folder2 300g
Personal-1/Folder3 300g

Personal-2/Folder4 300g
Personal-2/Folder5 300g
Personal-2/Folder6 300g

由于我没找到 rclone 有类似的命令，等上一条复制完再添加下一个，有些麻烦而且说实话有点蠢。貌似有把需要复制的文件放在一个文本文件里再读取复制的方法，但由于家庭版的 od 号实在是太多了，这么做也很麻烦。

于是我用了 1panel 的计划任务，如果不设置 --onedrive-chunk-size 大约是 4h 搬运完一个文件夹（100g上下）。设置好命令和时间，剩下的只有等待了。

由于个人版 od 不能申请自己的 api 了，所以会慢一些。另外如果调高 --onedrive-chunk-size 的值，内存消耗会急剧增加，省事省力还是使用默认的吧，正好内存占用小，还可以多运行几条命令多线程搬运。

最后把运行成功的计划任务停用或者删除就OK了。

onedrive >> pikpak

1T 以内

把 onedrive 和 pikpak 都挂载到 Alist ，然后用 Alist 复制。（现在的会员每个账号每月只有1t的上传流量，用工具复制算在上传流量里面）

用 Alist 从 od 到 pikpak 是可以秒传的。

超过 1T

方案一

可以分批用 rclone 向多个会员账号迁移，最后汇总到一个号上。

方案二

把 onedrive 挂载到 onemanager 或 Alist ，然后用直链在 pikpak 云下载。

推荐用 cmd 或其他神秘方法生成 onedrive 的目录列表，然后加上域名和路径，拼接出直链批量云下载。

云下载时要注意 onedrive 的 api 限制，具体没测试，大概 1h 50个文件，不然等到碰到 onedrive 限制了，pikpak 传输列表会一堆报错。

PS: 目前 pikpak 挂载到 Alist 需要获取刷新令牌、验证码和设备id，并且时不时会掉登录，挂载方式不是很稳定，可能下次官方再整次活，挂载方式又变了。

onedrive >> 115

探索

115 的登录 Cookie 可以用 Alist 官方文档提供的方法，我用的是使用Python脚本获取 Cookie 。

登录时使用微信/支付宝小程序的 Cookie，日常很少会用到且较为稳定。如果用 Android 或者 IOS 的 Cookie 挂载，当你用手机登录时，Alist 那边对应的登录会掉。

网上搜到的那个支持 115 的改版 rclone 不能用 copy 命令。
直接用 Alist 迁移会在本地留下和文件同大小的缓存文件，迁移大文件不合适，会直接把 vps 的硬盘撑爆。不过支持秒传这点很好，迁移起来很快。
用 Alist 挂载 onedrive 和 115 ，然后把 Alist 用 WebDAV 挂载到 rclone ，用 rclone 的 copy 命令貌似无法写入 115 。

实际使用方案

clouddrive2 可以使用，还算稳定，没有缓存文件，内存占用小

本来想把 Alist 用 WebDAV 添加进去，就不用去一个个添加 onedrive 了。没想到只能读到文件列表，迁移时发现疑似无法从 WebDAV 下载。

clouddrive 需要购买会员，由于我只是偶尔用一下，开了 5￥的月度会员，价格不算贵。

就在我已经迁移了 5t 的时候，用 115 的 cookie 登录挂载上传的方法又挂逼了，疑似偶尔才可以用。无法秒传的文件的迁移计划基本寄掉了。并且听说 115 高峰期时限速很严重，所以暂时不打算向 115 备份了，目前迁移了 5t 之后就再没动过了。

本文用到的工具

Unity Shader 入门笔记vol2--符文·筑基·照

Kiramux — Tue, 08 Oct 2024 00:00:00 GMT

解惑

我现在学习的这门课程是在 2020 年开始录制的，使用的是 Unity 2019，有些年代久远了。课程作者是一位资深 TA ，他也在 B 站个人简介标出：此课程已过赏味期。

在4年后的今天，Shader Forge 的版本也定格在了 2019 ，有更多方便好用的工具可做为连连看替代。我在听过一点课之后，某次和朋友交流时，不经意间看到他在用另一款既美观又看起来很吊的插件（忘记名字了），当时有深深地怀疑过，自己在 2024 年去听这样一门课疑似”过时“的课是否值得。

技术美术最终是要落实到 Shader 代码的。当我接触到这门课程的代码部分时，之前的疑问全都烟消云散了。

以 Shader Forge 作为 Unity Shader 的开始仍是有意义的。Shader Forge 程序化生成的代码很简洁，可以很容易地删减出 Unity Shader 版的 HelloWorld ，辅助思路实现的同时也很好拿来做写代码的参考。Shader 代码的部分是相通的，会写 Shader 之后，我们可以把 SD 、 SP 里的 Shader 拿出来参考，把它们移植到 Unity 里或者别的地方，也可以比葫芦画瓢把写好的 Unity Shader 移植到其他地方。

连连看终究是一个辅助，不是最终答案，最终还是要丢掉的。目前 Unity 和 UE 有连连看，然而到一些陌生的平台，有没有这样的连连看工具还难说，也不会有人为了你想向这个平台移植 Shader ，专门为你开发一款工具。学会 Shader 是一个学会 “渔” 的过程。

综上， Shader Forge 只是一个工具，很适合拿来入门，等到熟练之后要脱离它。很多情况下写代码比连连看更容易实现效果，现在因为纠结工具问题而犹犹豫豫就输了。

PS：不同的 Unity 版本使用起来还是有区别的，比如某个变量在 2019 版里还叫这个名字，有可能之后某个版本就改了。同时有一些旧版本官方文档推荐的做法，在之后的新版本就不推荐了。还是要多查官方文档，这也是一名技美必备的基本素养。

HelloWorld （ FlatCol ）

我们在 Shader Forge 中新建一个 Unlit Shader ，自带一个颜色连到了 Emission 上，这就是一个最简单的 Shader 。

这个颜色我们可以任意更改，比如我们可以把它改成绿色。效果：

我们用 VSCode 打开这个 Shader ，删除掉 Shader Forge 自带的内容，最大程度上地精简它，得到一个 Unity Shader 版的 Hello World —— FlatCol （ Flat Color ，最简的 Shader ）

Shader "VS/FlatCol" {
    Properties {
    }
    SubShader {
        Tags {
            "RenderType"="Opaque"
        }
        Pass {
            Name "FORWARD"
            Tags {
                "LightMode"="ForwardBase"
            }


            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"
            #pragma multi_compile_fwdbase_fullshadows
            #pragma target 3.0
            // 输入结构
            struct VertexInput {
                float4 vertex : POSITION;   // 将模型的顶点信息输入进来
            };
            // 输出结构
            struct VertexOutput {
                float4 pos : SV_POSITION;   // 由模型顶点信息换算而来的顶点屏幕位置
            };
            // 输入结构>>>顶点Shader>>>输出结构
            VertexOutput vert (VertexInput v) {
                VertexOutput o = (VertexOutput)0;           // 新建一个输出结构
                o.pos = UnityObjectToClipPos( v.vertex );   // 变换顶点信息 并将其塞给输出结构
                return o;                                   // 将输出结构 输出
            }
            // 输出结构>>>像素
            float4 frag(VertexOutput i) : COLOR {
                return float4(0.0, 1.0, 0.0, 1.0);
            }
            ENDCG
        }
    }
    FallBack "Diffuse"
}

我们目前需要关注的只有以下这些部分，其他部分可以当做“无用”的形式段。知道含义自然更好，不知道也无所谓，就把它当做一种仪式感。可以把它们当做发动魔术之前吟唱的咒文。

// 材质面板上暴露出的参数
   Properties {
    }

// CGPROGRAM 前面的部分，目前是空白，这个位置用来为材质面板上的参数声明变量	
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
// #include 用来引用库文件
            #include "UnityCG.cginc"

// 输入结构
            struct VertexInput {
                float4 vertex : POSITION;   // 将模型的顶点信息输入进来
            };
// 输出结构
            struct VertexOutput {
                float4 pos : SV_POSITION;   // 由模型顶点信息换算而来的顶点屏幕位置
            };
// 输入结构>>>顶点Shader>>>输出结构
            VertexOutput vert (VertexInput v) {
                VertexOutput o = (VertexOutput)0;           // 新建一个输出结构
                o.pos = UnityObjectToClipPos( v.vertex );   // 变换顶点信息 并将其塞给输出结构
                return o;                                   // 将输出结构 输出
            }

以及最重要的也是我们主要写的部分——像素 Shader

// 输出结构>>>像素
            float4 frag(VertexOutput i) : COLOR {
                return float4(0.0, 1.0, 0.0, 1.0);
            }

需要注意的地方

每个 Shader 都应该有一个独一无二的路径名，位置在开头的 Shader "VS/FlatCol" ，引号内的就是路径名。Shader Forge 中的路径在左栏的 Shader Settings >> Path 。
只有从 CGPROGRAM 到 ENDCG 之间的内容，每行末尾需要加 ; ，其余的地方是不用加分号的，相当于是在 Shader 代码中插入了一段 cg 代码。
注意半角符号！
最后 return 的值必须是一个四维的（有时会自动转换）
在写 Shader 时数字最好保留一位小数，如 0.0 ， 1.0 这种，虽说引擎可能自动转换，但是在某些情况下转换又会很邪门地出问题，尤其在一些老设备上，所以最好养成这个习惯。
打开 Unity 的 Console 放在窗口下部，这样每次 Shader 报错出现 bug 红的时候，可以看到报错信息。

当我们精简好之后，我们用 FlatCol 创建一个材质附给一个模型，不出意外的话，会和 Shadow Forge 中连出来的效果一样。如果有些地方不慎写错，会出现以下的 bug 红 和 Console 报错：

代码 Lambert

有了 Hello World （ FlatCol ），我们已经可以输出一个纯色了

我们离写出人生中写的第一个 Shader 只有一步之遥了。

我们先观察在 Shader Forge 连出来的 Lambert 节点。

FlatCol 中已经有了顶点信息。

我们在 Lambert 又用到了 法线信息 ，因此在 输入结构 、 输出结构 、以及 输入结构 >>顶点 Shader >> 输出结构 这三个部分内追加法线信息。

看不懂是正常现象，直接从 Shader Forge 那边先复制过来，之后用的多了慢慢就会懂了。

            // 输入结构
            struct VertexInput {
                float4 vertex : POSITION;   // 输入模型的顶点信息
                float3 normal : NORMAL;     // 输入模型的法线信息
            };

            // 输出结构
            struct VertexOutput {
                float4 pos : SV_POSITION;       // 由模型顶点信息换算而来的顶点屏幕位置
                float3 nDirWS : TEXCOORD0;      // 由模型法线信息换算而来的世界空间法线信息
            };
            // 输入结构>>>顶点Shader>>>输出结构
            VertexOutput vert (VertexInput v) {
                VertexOutput o = (VertexOutput)0;                   //新建一个输出结构
                o.pos = UnityObjectToClipPos( v.vertex );           //变换顶点信息，并将它塞给数据结构
                o.nDirWS = UnityObjectToWorldNormal( v.normal );    //变换法线信息，并将它塞给数据结构
                return o;                                           //输出数据结构
            }

然后我们准备向量 nDIr 和 lDir ，可以先不用理解，依旧直接从 Shader Forge 连好的代码里粘贴过来。

由于 nDIr 和 lDir 都是三维的，我们用 float3 。

点积的结果是一个一维的量，用 float ，然后截断负值。

我们把计算结果补充成 float4 （ RGBA ），最后输出。

            // 输出结构>>>像素Shader
            float4 frag(VertexOutput i) : COLOR {
            
                float3 nDir = i.nDirWS;                             //获取nDir
                float3 lDir = _WorldSpaceLightPos0.xyz;             //获取lDir
                
                float nDotl = dot(nDir,lDir);                       //nDir点积lDir
                
                float Lambert = max(0.0,nDotl);                     //截断负值
                
                return float4(Lambert,Lambert,Lambert,1.0);         //最终输出颜色，只能是float4，float等也可以只不过会自行转换
            }

<details> <summary>展开查看完整代码</summary> <pre><code> Shader "VS/Lambert" { Properties { } SubShader { Tags { "RenderType"="Opaque" } Pass { Name "FORWARD" Tags { "LightMode"="ForwardBase" }

        CGPROGRAM
        #pragma vertex vert
        #pragma fragment frag
        #include "UnityCG.cginc"
        #pragma multi_compile_fwdbase_fullshadows
        #pragma target 3.0

        // 输入结构
        struct VertexInput {
            float4 vertex : POSITION;   // 输入模型的顶点信息
            float3 normal : NORMAL;     // 输入模型的法线信息
        };

        // 输出结构
        struct VertexOutput {
            float4 pos : SV_POSITION;       // 由模型顶点信息换算而来的顶点屏幕位置
            float3 nDirWS : TEXCOORD0;      // 由模型法线信息换算而来的世界空间法线信息
        };
        // 输入结构>>>顶点Shader>>>输出结构
        VertexOutput vert (VertexInput v) {
            VertexOutput o = (VertexOutput)0;                   //新建一个输出结构
            o.pos = UnityObjectToClipPos( v.vertex );           //变换顶点信息，并将它塞给数据结构
            o.nDirWS = UnityObjectToWorldNormal( v.normal );    //变换法线信息，并将它塞给数据结构
            return o;                                           //输出数据结构
        }
        // 输出结构>>>像素Shader
        float4 frag(VertexOutput i) : COLOR {                   //只能是float4或half4
            float3 nDir = i.nDirWS;                             //获取nDir
            float3 lDir = _WorldSpaceLightPos0.xyz;             //获取lDir
            float nDotl = dot(nDir,lDir);                       //nDir点积lDir
            float Lambert = max(0.0,nDotl);                     //截断负值
            return float4(Lambert,Lambert,Lambert,1.0);         //最终输出颜色，只能是float4，float等也可以只不过会自行转换
        }
        ENDCG
    }
}
FallBack "Diffuse"

} </code></pre> </details>

代码 HalfLambert

我们只需要在像素Shader 部分，对 Lambert 的结果做一下处理即可。

            // 输出结构>>>像素Shader
            float4 frag(VertexOutput i) : COLOR {                                    //只能是float4或half4
                float3 nDir = i.nDirWS;                                              //获取nDir
                float3 lDir = _WorldSpaceLightPos0.xyz;                              //获取lDir
                float nDotl = dot( nDir, lDir );                                     //nDir点积lDir
                float HalfLambert = max( 0.0, nDotl * 0.5 + 0.5 );                   //转换为半兰伯特并截断负值
                return float4( HalfLambert, HalfLambert, HalfLambert, 1.0 );         //最终输出颜色，只能是float4，float等也可以只不过会自行转换
            }

委托任务

如 Gif 图创建一个材质，面板上提供一个 Slider 可以平滑调整猴子的明暗调子；

浑浑噩噩的每一天

Kiramux — Fri, 25 Oct 2024 00:00:00 GMT

这些文章属于较为私人的个人日记，拿来随手记录的。俺的生活终于要回归正轨了。（一个月限定）

这篇文章是昨天创建的，本来昨天下午创建好，想趁着有难得的空闲写一篇 blog 记录的，走在路上连名字都想好了，英文明明就叫做 “ wonderful everyday ” 。然而到了专业教室，旁边坐着的两位仁兄看上去要准备连麦打劫，我顿感身心俱疲，收拾电脑光速滚回宿舍了。

这篇文章我是随心写的，想到什么就记下什么。标题叫做浑浑噩噩每一天。实际上我已经被课设折磨了连续 10 天了，实际上应该更久，但由于课设题目简单 + 老师很亚撒西 + 我自己刻意逃避，我自己作死把 9 周的课设压缩到 10 天来做。其实这次的课设真的很简单，城市园林景观设计，说白了随便去知末上搜一下案例，直接贴过来就好了。然而俺心里总有个倔强的想法，既然是个课设俺就要做做试试，做出自己的东西（当然也有老师引导的成分，那位老师确实是位不错的老师）。于是就开始做课设，但又不会给它分配太多时间，因为知道自己志不在此，想在随便做做的同时顺便做出点自己的东西来，就是这样任性、倔强的想法。再加上有休假，所以趁机整理一下网站，迁移一下文件，然后画点画顺便做做课设，这期间还萌生了好多别的想法，例如学一下 py 做 tg 频道文件补档之类的，于是国庆七天就过去了。刚好国庆过去交了二草，然后家里表哥结婚，于是回家 4 天，顺便把要交草模的那节课给请假了（实际上是俺故意逃的，只不过有假条，事实证明那个东西只是纯粹浪费时间）。等休假回来，发现由于学校要被评估，设计周被砍了，交图也提前了，然而俺的设计甚至连草图还没画好。然而俺还怀着之前的那种想法彻底藐视这个设计，景观设计又没啥规范限制，随便做都可以，只要自己说的通，圆的过来就没人会说咱的设计有问题。事实上确实很简单，当俺每次上课都不给老师看图的时候，看到其他的同学已经渲染都渲完了开始排版了，俺的草图还没落实，此时我的战略腚力依旧很强，在上次二草俺的方案已经基本确定了，就差那些水滴的形状的具体处理了，自己来看进度还是可以的，于是依旧不慌，而且已经有了初步的想法了。就在俺这么慢悠悠地做的时候，时间来到了上周六（20241019），俺正在和 Galgamer 的群友玩世界第一好玩的你画我猜。正在画着的时候，后面那个哥们王者打完了（没错就是昨天打劫的那个，每次吵得要死），然后看到俺在用数位板画画，然后就开始当爹了。“这是手绘板吗？”等下又直接问“现在在画画，想必你的设计进度肯定做的很快吧。”

我当时还毫不在意，另一个哥们在说“有个爱好挺好的”所以也没放在心上，然而这句话已经印在心里了。当时咱的计划是周二把方案和模型出完，然而周六白天几乎什么都没干，出去和室友吃了大锅台然后睡了一下午，晚上回去随便干点啥，晚上又和群友玩画猜了。其实还有周日也还好，毕竟还有一天。然而不知道怎么回事，具体情况也给忘了，结果就是周日俺睡了一天，然后越是迫近周日的晚上，我就越寝食难安。当我每次想到“这会儿在干这个，想必你进度一定很快吧”这句话的时候，我就会被干碎一次。这种心态已经完全做不成设计了，玩游戏睡觉都要没心思了，时间又那么紧迫（在当时的心理下看来是这样，毕竟自己定的 ddl 是周二）。周一也有一天课，我在周六周日什么课都没的情况下进度几乎为 0，难道指望在满课的周一将设计进度推进突飞猛进吗。

没错，这时候俺破防了。想了想好想也没什么人能安慰自己，但还是试着给她发了发信息，毕竟之前她也老对着我发电来着，俺对她稍微撒撒娇怎么了。。于是给她发完消息之后，先给我妈通了一通视频电话，完全没提自己心里的堵，就是日常聊天，聊到表哥要去新婚旅行了，然后家里想买台电车日常开之类的。。当妈妈在揉眼睛的时候，俺看到她的眼袋和眼角有深深地皱纹，俺的眼泪立马就要涌出来了。但妈妈就是很普通地跟我在聊天，我也不想就这么哭出来，还好忍住了，然后那位打过来了微信电话，只不过我这边仍在占线中。

过了 10 分钟，和她接通了。一开始谁都没说话，持续了好几分钟，也忘了是谁先开的口，于是就聊了起来。她帮我分析问题，然后安慰我。虽然她说的道理我都知道，而且大家的问题和焦虑其实都很相似，大家都心里很难受，自己有啥理由让别人安慰我呢，她大概也在面临同样的压力同样的问题，或许比我还严重，然后还要她克制住自己的痛苦然后再来安慰咱。实际上更现实的问题是，她或许也没有能解决这个问题的思路，或者说比我更焦虑，然后说着一些咱都懂的话，如果不是完全站在某个人的立场下，只是说“你这样那样不就好了吗”，这些都是不负责任的话。

其实周日那天，我重读了《挪威的森林》第一章，里面渡边君对直子说：“直子你就是神经崩的太紧，日常应当放松一些。”原话有些记不清了，但大致意思是这样。直子回答的大意是，你无法站在我的立场上，也就无法理解我的痛苦，现在我的自己只要稍微放松一丝，我的精神就会分崩离析，然后你却让我日常放松一些，不就好了。说出这种话是十分不负责任的。

不过我还是和她有一搭没一搭地聊了很久，然后她问了我地址，说要给我买东西吃。和她聊了聊自己感觉好多了，焦虑也少了好多。过了几天我明白了，其实和她聊天的各种内容都无所谓，只要自己能感觉到，有人还在关心着自己，然后愿意来安慰自己，这件事本身，就是对我最大的抚慰了，是俺在焦虑万分时的灵丹妙药。

以上都是这周周一之前的故事了。周日那晚和她通完电话已经很晚了，于是就休息了。周一上课。在周二周三周四，我拼命赶设计进度，然后感觉自己果然是 deadline 领域大神，周二周三的进度推动依旧是龟速，然后在周四肝一整天，顺带肝到凌晨 4 点，居然把图出完了。然后是上午做 PPT ，等待答辩，下午上课--补觉--然后上绘画的构成课。可能是因为自己这次真的太藐视这次课设了，或者说自己已经不怎么把重心放在建筑学上了，这次完成课设之后也没有那种一释重负的感觉，只是想到俺的生活终于要回归正轨了。毕竟之后还有一大堆事留着没做，开了太多坑了，需要自己慢慢填，而且前几天在高压状态下，我又萌生出了想自制周边（甚至去学 zb 雕手办）的危险想法。总之我仍是范围巨广的三分钟杂食动物。

接下来打算先把技术美术稍微放一放，专心学 2d 绘画，然后辅以学 python ，看看能不能写一个 tgbot 出来，然后刚好技术美术学到一个节点（虽然都快 20 多天没碰了），打算写 blog 总结以下之前学到的东西，算复习让自己回想一遍不至于忘掉。大致上就是这些安排，之间穿插着各种学校的课程和作业什么的，偶尔看看能不能偷点时间玩玩游戏打打 gal 什么的。今天大概就写到这里了。

其实那晚还有一位女生来安慰我，只不过被我略过没写了。附上那天去吃的大锅台

然后她给俺买的糖果和鸡爪。

初见德加的舞女

Kiramux — Sun, 10 Nov 2024 00:00:00 GMT

前言

我在昨天读过《西方绘画大师经典佳作德加（高清细节版）》后，萌生了起草这篇 blog 的想法。然而读过之后我已经很累了，于是零零碎碎记录下了当时看每一幅画时的第一想法，打算之后再记录。然而昨晚和今天想要写点什么的时候，发觉当时那些画给我留下的感受，和我之前想写的细节内容，在我脑中已经荡然无存了。这篇文章就是我事后凭借印象写出大致感想，再拼贴当时的记录而成的，所以可能会有文章上下文思路跳跃过大，或出现破碎言语片段的情况。此篇文章仍待日后再整理。

读过这篇文章，你就相当于读过《西方绘画大师经典佳作德加（高清细节版）》的 50%之多了。因为本文贴了大量这本书中的画作。

本文左右的图名都是针对图名上方的画作的标注。

另外需要注意的是，尽管本文贴出的德加的画作几乎都是人物油画，但德加的画作远不止人物油画这一个种类，他还很喜欢风景油画和人物素描等。本文算是对看过德加笔下的舞女的感想总结。

本人只是一个非科班出身热爱美术的普通人，请理性看待本文内容。

zlib 地址: 《西方绘画大师经典佳作德加（高清细节版）》

初见

昨天在 zlib 翻找书的时候，偶然发现了一本带着芭蕾舞者画的封面的书，瞬间被封面上的舞裙吸引了。我很喜欢芭蕾舞者（实际上更喜欢舞裙），于是打开阅读。

《西方绘画大师经典佳作德加（高清细节版）》

这本书一开始从德加的生平讲起，接着是沿着德加的人生历程展示画作。

在 Chapter 1 德加生平概述和 Chapter 2 特立独行的青年时期（1857年-1861年）两个章节中，展示的画作绝大多数是自画像、肖像画或者说风景画，只有偶然的一两张画舞女。于是我在想，这本书大概也是因为这位叫做德加的画家，他画的几张舞女十分出名，然而数量很少，还是在画什么人物和风景画居多，只是因为画的舞女很出名，于是作为这本书的封面了。

我就带着这样的想法接着看下去。不得不赞赏这些风景画的构图真的很优美很和谐，最近我也在学画面构成相关的内容，所以深有体会，看这些画的时候就在一直想，或许把这些人物换成二次元美少女，也会是很不错的画面。或者说我可以直接从这些经典作品中提取那些动态线，然后 copy 到我的作品中来用。

《自画像》 Self-Portrait 1856 年—1858 年布面油画

《意大利老女人》 The Old Italian Woman 1857年布面油画宽749mm 高610mm

《海边长廊》 Promenade by the Sea 1860 年布面油画

《亚历山大和布塞弗勒斯》 Alexander and Bucephalus 1861年—1862年布面油画

Chapter 1 2 和 3 的前半部分我还在走马观花地浏览，很随意地看着想着，这张图不错，那张图没准可以在 xx 用到。不过当我注意到，即使在我看过上面的全幅作品后，再看到一些画作的细节放大图时仍是很陌生，甚至根本没有印象，就好像是一副全新的画作。我这时才意识到我犯的错误。我欣赏这些画作的方式不对。

我从来不懂怎么去看这些名家的画作，可能我是个俗人。无论是看照片，或是去美术馆看原作 / 复制品，自己看到的始终是“整幅画的一部分”。直到这时我才发现，这些细节部分，如果用画框框住画面，就已经是一副新的作品了。这本书的细节展示部分的图片边缘，正是一个个图框，把这部分细节和整个画面隔离开，才能使人更容易欣赏到它的细节之美。

通常我自己在看这些画的时候，或许脑中或者眼中应当有一个无形的画框，或者干脆手持一个实体的画框，通过它来观察。否则，我的注意力大概只会被画作上的笔触、藏色吸引，而忽略构图等要素。

《花瓶旁的女人》 A Woman Seated beside a Vase of Flowers 1865年布面油画

例如这张画，我看待它时只会看到它的构图和大致的色彩，构图上中间有好大一簇花之类的，甚至都没注意到画面左下角有个透明瓶，也没注意到花球的边缘和女人衣服的背景是如何处理的。这些方面只有我看到编者特意在下方提供的画面细节时才注意到。原来我已经错过了这么多重要的信息。

《花瓶旁的女人》局部细节展示

单独地看，每一处的细节裁切都是一副精妙绝伦的景物画，我甚至开始怀疑它们真的是从上面那张我认为“平平无奇”的画上裁切出来的吗？这真的不是另一幅画？然而当我返回再看时，事实每次都狠狠地打了自己的脸。

《版画收藏者》 The Collector of Prints 1866年布面油画

局部细节展示

《菲奥克尔小姐在芭蕾剧〈泉〉中》 Mlle Fiocre in the Ballet - La Source 1867年—1868年布面油画

作品说明：

受菲奥克尔之约创作的《菲奥克尔小姐在芭蕾剧〈泉〉中》，他在前景中添画了一匹正在饮水的马。此画是德加创作的一个转折点，标志着他在创作中反映当代社会的日常生活。

局部细节展示

我意识到这些画的内容不可小觑，即使从我这个俗人眼中看来是“平平无奇”的画，也值得细细揣摩。于是接着读 Chapter 3，已经渐渐出现许多有关芭蕾剧内容的画作了。

写到这里我忽然在想，既然要出画作系列的话，那么是否可以用德加的画当作参考，然后把人物替换为日系二次元或者其他形式，创作出一系列插画。这样就保证了灵感足够多、构图流畅和谐、不缺乏故事性，同时还有戏谑的意味，也是对经典作品的一种”致敬“。会有些像那些国画山水画风的 “猫和老鼠图”的感觉。

这张画让我想到了 island 里的那只小船。

舞女

《舞蹈课》 The Dancing Class 1870 年布面油画

局部细节展示

[PS: 被这张镜中舞女的表现再次惊艳到了]

从这幅画开始，描绘舞女的作品数量极度增多，使我对这部画集的认知再次改观。

以这幅画为分界线，之前的部分虽然让我认识到了德加的厉害之处，同时端正了自己欣赏画作的态度，但是我一直在寻觅那些自己想看到的东西。我想看到那些身姿婀娜、翩翩起舞的舞女，我想看到蓬松绽放的芭蕾裙。

于是在这幅画之后的篇幅，大量的舞女画作呈现出来，目不暇接。

我从书中摘录了一些放在这里，请欣赏这些动人的画作。

局部细节展示

<details> <summary>折叠了一些男性音乐家的细节展示</summary>

</details>

《舞蹈课》 Dance Classes 1871年—1874年奥赛美术馆法国巴黎布面油画宽850mm 高750mm

《在舞台上排练》 The Rehearsal on the Stage 1874年布面油画

局部细节展示

《芭蕾舞台上的排练》 The Rehearsal of the Ballet Onstage 1874年布面油画

局部细节展示

《芭蕾舞台上的排练》 The Ballet Rehearsal on Stage 1874年布面油画

“人们称我是画舞女的画家，他们不知道，舞女之于我只是描绘美丽的纺织品和表现运动的媒介罢了。”

局部细节展示

三张同名的画作

三张同名的画作，相同的构图，几乎相同的人物和场景，却用了三种的表现方式。

第一幅更偏写实一些，体现的是写实美。第二幅则是通过用色和场景形态传达出了一种疯狂、一种痴迷。第三幅更偏黑白的表现，此时指导的老师消失了，只剩后方一个男人，我猜想可能是想表达更客观的视点画面，或者是所谓的 " Other view " ，又或者是这些舞者内心中的芭蕾舞台的表现。

其实我第一次看到这三幅画时有些吃惊，认为这些画可能是在同一空间上的不同时间的表达，现在看来又或者是同一场景的同一段时间内不同“视点”的表达。

1 >> 所希望的画面，2 >> 不知是谁心中的疯狂、痴迷的体现，3 >> 舞者内心的体现 / 舞台的客观体现。

《芭蕾舞课》 Ballet lessons 1874年布面油画

这张的人物位置安排，也是我最想模仿的。

《练舞者》 Practice the Dancers 1876年—1878年布面油画

我被舞者身上的那一抹红深深吸引了。

我很在意这幅画中的冷暖对比，衣服上的红色过于鲜艳，背景很灰暗很危险的绿灰色，然而画面却很和谐？应当如何把控？

局部细节展示

[PS: 有一种锈蚀感]

这幅画中的笔触已经体现出些许疯狂了。让我联想到沙耶之歌的男主的家，房间内刷满了油漆……

《两个舞女，半幅》 Two Dancers, Half-length 1876 年布面油画

《杜乐丽花园里撑阳伞的女人》 In the tuileries garden umbrella woman 1877年布面油画

《舞者在练习芭蕾》 Dancers Practicing at the Barre 1877年布面油画

局部细节展示

[PS:把签名融入画面中是一个不错的选择，既能补充画面，有些情况下人为去掉签名还会导致画面动态缺失，算是“硬编码”署名了]

《芭蕾舞团在巴黎歌剧院》

《芭蕾舞团在巴黎歌剧院》 Ballet at the Paris Opéra 1877年布面油画

局部细节展示

我很喜欢偏冷色的皮肤质感表达，无论是摄影还是绘画。我在高中二年级时在教室后黑板画黑板报时，无意间画出了类似的感觉。当时是在画水下的初音，阴差阳错画出了水下冷色皮肤的感觉，之后我便喜欢上了这种感觉，偏灰偏冷。应该说很喜欢冷灰白。

我很喜欢这幅画中的裙子四肢等白色阴影部分的表达。

头发、裙子的表达，肢体的安排和颜色，冷色皮肤，舞台上的舞者和台下秃顶的仰头拼命看舞者的观众对比……

舞女的画家

去拍摄的编者，他们肯定是满心激动去拍摄的。同一幅画，通过不同的画布尺寸裁剪，就可以“发掘”出一件新的作品，一边为大师的作品之精美所惊叹，一边为同一幅画以不同的构图拍摄不断涌现新的惊喜而欣喜若狂。这同时也是我的真实感受。

“人们称我是画舞女的画家，他们不知道，舞女之于我只是描绘美丽的纺织品和表现运动的媒介罢了。”德加这样说道。他确实不愧被称为 “舞女的画家” 。

无论是从结构和构图，光线和色彩的运用，还有画面所表达的故事这些方面来看，都无懈可击。细节明暗色彩的表达，同时和笔触的结合……十分完美，同时能精确而强烈地传达出人物的情绪。

《等待》 Waiting 1882 年布面油画

作品说明：

德加的画里根本没有故事。他之所以对芭蕾舞女演员感兴趣，并非因为她们是漂亮少女。他似乎不关心她们的心情，他以印象主义者观察周围风景那种冷漠客观的态度去观察她们。

局部细节展示

这本书前面的部分是画家早期的作品，大多是些风景和肖像。一开始只是觉得构图有意思，色彩和传达的故事感也很棒，可以尝试临摹一下。就是这样简单的想法。

然而一旦舞者的画作一幅幅出现下页时，看过一张画的总览，再一张张看细节图，我就越来越难以抑制住心中的激动之情。

从心底里觉得这才是舞者，这才是绘画和艺术。光影和用色，构图的故事性，以及舞者的神态情绪的表达，给我带来了极大冲击，我立刻有一种想要临摹试试的冲动。

如果不是这本书的编者安排细节图在书中，引导我去细看这些作品，我可能永远都不会注意到这些作品的精绝之处。可能是因为我是个俗人，领悟不到要如何去阅读这些作品，并且无法无师自通，也没有过人来引导我来怎么欣赏这些画作吧。

上文说到，我很在意德加的皮肤的用色，他画出了我很喜欢的冷色调的皮肤色，或者即使是暖色也会有一种我说不上来的可以打动人的地方。光影的形状，阴影的边缘控制，颜色的倾向……

《绿裙歌手》 The Green Singer 1884 年布面油画宽603mm 高464mm

局部细节展示

《舞蹈者》 Dancers 1884 年—1885 年布面油画

局部细节展示

对舞女的芭蕾裙的表达也是德加的一绝，也是最打动我的地方。我一开始点进这本书，就是被芭蕾裙的表达所惊艳到了。我个人对芭蕾舞者和芭蕾裙/服装是很喜爱的，看到书中有这么多芭蕾裙不同的表达，感动的快要热泪盈眶。

这次阅读这本画集，很久违地被画深深地触动了。真的好久好久没有这种感觉了，上次应该还是在看到 void_0 的画和一些构成参考时有被触动到，已经有整整 1 年了。

一直觉得我现在的生活太功利了，总是想着我去做这个事能给我带来什么，情绪价值或者能提升画技，或者说为准备工作能有什么直接的帮助吗。昨天上午我被这些画吸引，阅读然后感触颇深，我真的应该慢下来去欣赏这些诉说着故事的画作，也能引发一些自己的思考和感动。

太功利做事或许会时间收获双双失去。

透过舞女的情感传达

读到 Chapter 4 时，体会已经由好厉害的心情变得很累很疲劳了，画面太过冲击，并且有很多诡异、匪夷所思、用意很深的表达，感觉似乎在隐喻着舞女在德加眼中究竟是什么，和舞女当时的社会地位和问题。

《女帽店》 Millinery 1882 年—1895 年布面油画

局部细节展示

德加在晚年一转之前的写实画风转到写意，并且用色越来越诡异。颜色传达了情绪，在作者眼中观测到的这些人物是什么样子的，是怎样的情绪或者在传达一种怎样的情绪/氛围。

请先看下面这幅作品。

《芭蕾舞团》 The Ballet 1885 年布面油画

德加越到后期的画作越透露出了一种癫狂，有些像被致幻的感觉。构图依旧是哪些构图，依旧是那些舞者，只是用色更加癫狂起来，在那些场景中几乎不可能出现的大片的绿色蓝色，同时画面中充满了线条在扭动着。皮肤的颜色也怪异了起来。

我觉得他是在表达自己眼中的舞女，在描绘他观测到的舞女的存在。举一个不恰当的例子，可能有点像是色盲的世界，或者说是那些写意的画面是类似 “沙耶之歌” 男主这样的视点的描绘，或者是某种环境气氛的感觉，又像或者素晴日里“三位一体”带着极度主观色彩的客观世界的视点画面。

书中说到，德加只是冷眼观测舞女，他的创作就是他眼中舞女的样子的表达，是他眼中的世界，是他观测到的世界。

“她们是我所知最接近天堂的形象，尽管她们早已远离了伊甸园。”

尽管说是德加在冷眼旁观这些舞者，但是这些舞者在德加眼中究竟算什么呢，是怎样的存在呢？他对舞者如此痴迷，为何最终演变成了这种癫狂的画风？或许是因为他在晚年察觉到了自己有失明的风险。我看到这些画的时候，觉得这些舞女给人一种仙子或者精灵的感觉，但是是处在底层的精灵或仙子。她们美好而轻盈，却也容易被压迫被惊吓。特别是德加在许多舞女的创作中，都很喜欢用树林 / 丛林作背景，这就更为舞女和画面的故事带上神秘的色彩。

局部细节展示

这里舞女的表达感觉更像是 Ghosts 。

《芭蕾舞舞者》 Ballet Dancers 1890 年—1900 年布面油画

局部细节展示

或者说他们是在被什么追赶着，驱逐着。注意到脚和手臂的颜色已经不一样。

是否和当时舞者的生存环境和社会地位有关？

这些舞者她们生活的环境条件是怎样的，她们的下场最终会如何？

她们一生是辛苦幸福吗，还是遭到冷眼或抵触或歧视？？

1880年，德加开始创作其晚期代表作品“浴女”系列。对于这些纯属隐私、不宜见人的妇女形象，画家只是冷眼画出妇女们丑陋的抬腿，在浴盆前半近半出的样子。还有就是浴后擦身体的不雅动作，或蹲着、或弓着背、或伸直着腿。

可能是德加在尝试表达光鲜亮丽的舞女私下生活那些纯粹隐私的地方。她们不只有舞台上光鲜亮丽的那一刻，她们的还有舞台下的另一面。更真实的舞女，还包括她们私下的生活。

“丑陋的抬腿，在浴盆前半近半出的样子。还有就是浴后擦身体的不雅动作，或蹲着、或弓着背、或伸直着腿。”无论是台上的优雅或是台下生活洗浴时各种不宜见人 / “丑陋”的动作，这都是舞女的全部，都会让人们对“舞女”这个存在的认识更加立体。

《浴者踏入浴桶》 Step Into the Bath Bucket Bath 1890 年布面油画

局部细节展示

德加在“冷眼”观察舞女的同时，也在舞女的创作中投入了自己更多的感情。那些画作更加疯狂，富有进攻型和侵略性。

整幅画作都变成了德加输送情感的途径，黄绿和蓝灰的色调使人想到某种邪恶的秘境，或是使人联想到噩梦的场景。

《浴后擦拭身子的女人》 zoom:25%

《浴后擦拭身子的女人》 After Shower Wipe the Body of A Woman 1890 年—1895 年布面油画

如果眯着眼或者缩小来看《浴后擦拭身子的女人》时，会觉得这不过是一张背景略显”嘈杂“的写实裸女画罢了，甚至有点像那种被压缩失真很严重的 GIF 图的感觉。然而一旦放大这张图看，你就会发现画面中充斥着交错的”刺眼“的线。画面十分”吵闹“，并且用色基本和科学和事实无关，纯粹是情感的表达，传递着偏执。

《用毛巾的女人》 Woman with a Towel 1894 年—1895 年布面油画

局部细节展示

《舞者》 Dancers 1894 年—1904 年布面油画

局部细节展示

被锈蚀或者被蚕食的感觉，让人细看之后很不舒服。然而这种大胆的用色却没有让画面显得很脏。

《浴后》 After the Bath 1895 年布面油画

局部细节展示

《梳发》 Combing the Hair 1895年-1898年布面油画

《梳发》把传统绘画中女子梳头或被梳头的经典主题引入了现代社会。

《演出前》 Before the Performance 1896年布面油画

局部细节展示

~~看到这些画，都有一种吃了云南菌子的感觉~~。真的像是在凝视幻觉。

隐约感觉到德加似乎在为她们控诉着什么……

《演出前》 Before the Performance 1896 年布面油画

《穿红色服装的三个舞者》 Three Dancers in Red Costume 1896 年布面油画

局部细节展示

《两个舞者》 Two Dancers 1898 年布面油画

到此时，德加笔下的舞女风格已经和之前的大相径庭。回头看看上面的这些写意画，你还记得《芭蕾舞团在巴黎歌剧院》那些梦幻朦胧的舞女吗？

德加对舞女在舞台灯光下的描绘也十分精彩。

阿·沃拉尔援引过德加一句颇有意思的话：“人们从一幅画中呼吸到的空气与人们在画外呼吸到的空气不是一回事”。他不想去发现大自然即兴安排的大胆的美，而更钟爱由人类创造出来的美。德加对人工舞台灯光的热爱要甚于阳光。他喜欢表现人，但从不以其他印象派画家那种随便、勿忙去勾勒人物的身影。因此，他的艺术不是对安格尔激发起来的古典主义的拒绝，而是以新的贡献扩大和丰富了这种绘画形式。

《舞者》 The Dancers 1899 年布面油画

局部细节展示

结尾

实际上我在看到这些部分时，已经感到十分疲惫了。这些画作对我的冲击也很大，同时给我的情绪和思绪带来了很大的压力。

我在看《芭蕾舞团在巴黎歌剧院》那部分的画作时，每幅都会停下来细细观看，分析那些打动我的地方。然而下面的画作却渐渐染上了疯狂的色彩。我隐隐感觉这些画所传达的信息和主题越来越沉重，我不得不转变之前欣赏画的策略，快速浏览看过就作罢。

我想你读到这里也肯定有相同的感受吧。

其实我欠这篇文章一个结尾。然而此时的我已经无力写出什么结尾了。

读过这本《西方绘画大师经典佳作德加（高清细节版）》，我对这些名家大师的作品，以及其他美术类书籍感兴趣了起来。或许我之后可以读一下《如何看一幅画 = How to Look at a Painting》。

使用虚拟信用卡注册 Mapbox 过程记录

Kiramux — Sat, 23 Nov 2024 00:00:00 GMT

前言

https://www.mapbox.com/

Mapbox 现在注册要信用卡验证了

前阵子是只要用美国 IP 和 proton 邮箱就不要信用卡信息的，疑似被国人薅烂了，现在也需要信用卡验证了。我想上车已经晚了，因此一直没能注册到账号。

前几天发现了一篇帖子，看起来刚好可以用来注册 Mapbox。~~要不是课设要用谁会注册这个网站啊。~~

【教程】免信用卡为cloudflare添加付款方式

我复制一些过来存档。<这个括号里是我之后编辑的信息>

Cloudflare是一家全球云平台服务提供商，面向全球不同规模的企业和个人用户提供广泛的网络服务。该公司提供多项免费网络服务，包括CDN、Workers and Pages、R2、Zero Trust等，深获用户好评。然而，部分免费服务如R2、Zero Trust需要绑定支付方式方可使用。鉴于一些用户没有外币信用卡、担心意外超额扣费、或因隐私考虑不愿绑定真实信用卡，Paypal信息等原因，无法使用R2、Tunnel、SaaS等服务。本教程将介绍一种通过生成信用卡信息为Cloudflare添加付款方式的方法。

需要准备：

一个信用卡号生成网站，这里以Namso-gen为例
一个信用卡校验测活网站，~~这里以MrChecker为例~~，<失效，更换为 https://checkertop.com/>
一个卡BIN查询网站，这里以BINCheck为例
一个虚拟地址生成网站，这里以美国地址生成器为例。<推荐使用真实地址，随便搜点就可以，生成的地址有些网站可能不认>
一个可以通过cf支付网关验证的卡段，这里我为大家提供几个： 601121255660xxxx 546775142533xxxx 622759531087xxxx 479229938031xxxx （用其他卡段测试成功的mjj也可在楼下补充）

原理：一部分网站的支付网关在初步验证信用卡信息时仅检查卡号的格式是否符合标准（如Luhn算法）以及卡种、发卡行等基本信息，而不进行实际的资金预授权或小额扣款验证。也就是说，在绑定信用卡时，这些网站可能只进行基本的格式检查，而不与银行或信用卡网络进行实时验证来确认卡号的真实性和有效性。这意味着，只要卡号格式正确，就可能可以通过验证。然而，这并不意味着可以使用这些随机生成的信用卡信息进行实际消费或支付，因为在进行交易时，支付系统会进行更深入的验证，包括资金的实际可用性和账户的有效性。因此，当一些网站采用更严格的验证措施，如要求验证卡的有效性或进行小额扣款验证时，这时随机生成的信用卡信息就无法通过验证。
操作步骤： a.在Cloudflare Dashboard点击右上角的头像-->账单-->付款信息，添加付款方式。 b.使用信用卡号生成网站Namso-gen，在对应的卡段下生成一定数量的信用卡信息 c.将随机生成得到的信用卡信息复制到MrChecker进行校验 d.挑选一个通过校验的信用卡信息，将卡号，有效期，cvv填写到cf中，其中的地址信息最好要和信用卡段所在国家一致，比如我提供的信用卡卡段是美国的，就填写美国的地址信息。卡bin查询和虚拟地址生成可以使用我上面提供的网站。 e.最后点击确定即可通过验证，如果不能通过，可以选取另外的信用卡信息再次进行尝试。
后话生成的虚假信用卡信息远不止绑定cf这一用处。比如可以通过绑定特定卡段的虚假信用卡信息，实现免费试用github copilot服务，白嫖perplexity ai pro等，一般把这种行为称为C号（C即CVV，Crack之意），这里因为篇幅和防止滥用等一些原因不再深入。

❌在某种意义上，尝试使用随机生成的信用卡信息进行绑定或交易属于非法行为，可能会导致法律后果，包括被网站禁止、面临欺诈指控等。因此如非必要，即便在技术上可能存在这样的漏洞，也强烈建议遵守法律和道德规范，不要尝试使用非法手段进行操作。本教程仅供学习参考 ❌在某种意义上，尝试使用随机生成的信用卡信息进行绑定或交易属于非法行为，可能会导致法律后果，包括被网站禁止、面临欺诈指控等。因此如非必要，即便在技术上可能存在这样的漏洞，也强烈建议遵守法律和道德规范，不要尝试使用非法手段进行操作。本教程仅供学习参考 ❌在某种意义上，尝试使用随机生成的信用卡信息进行绑定或交易属于非法行为，可能会导致法律后果，包括被网站禁止、面临欺诈指控等。因此如非必要，即便在技术上可能存在这样的漏洞，也强烈建议遵守法律和道德规范，不要尝试使用非法手段进行操作。本教程仅供学习参考

</details>

具体注册方法

使用美国 IP ，账单地址使用美国真实地址（疑似非必要）。
使用 namso-gen 随机生成信用卡，选用网友分享的可用的卡头， format 选 PIPE ，方便校验卡信息。我使用的是第二个卡头。

5154620012 、 515462001608 、 5154 6200 1822 7221
使用 https://checkertop.com/ 校验卡信息，把 namso-gen 生成的那一堆信用卡信息粘贴进去检测。使用 Live 状态的信用卡。最好去 https://bincheck.io/ BIN Check 一下。
在 Mapbox 关闭 ADBlock 等广告插件。
用 Gmail 和美国节点注册。注册信息填完之后会提示输入信用卡信息，把刚才验证过的信用卡信息填入。日期的格式例如 10/32 ，CVV 是3位（或4位数字）。
如果失败就换其他验证过的信用卡信息重试，没有过信用卡的账号是没注册的，因此需要重新填注册信息，再填一次信用卡。如果一直失败，就考虑换卡头。

信用卡过了之后，要验证邮箱。邮箱验证之后去搜一个真实美国地址，填账单信息，这步之后就注册好了。

![]../images/006/result.png)

Arcgis 三维模型导入 SketchUp

Kiramux — Mon, 25 Nov 2024 00:00:00 GMT

此方法来自：07ArcGIS三维模型导入Sketchup

在导出模型之后，我们发现了模型底面与 Arcmap 中显示不一样，Arcmap 中的显示显然更扁。当时一直不知道怎么解决，现在了解到是坐标系的问题，把它改为投影坐标系就可以了，详情见 008 的开头部分。

由于我导出模型时用了 FME 等工具进行数据转换，可能这些操作在什么地方自动解决了投影坐标系不一致的情况，所以模型是准确的，而未调整坐标系的 Arcmap 中显示的底图图形是错误的。

[TOC]

获取数据

一般来说可以调用某些地图平台 api 等迂回曲折的方式获取到 POI 数据，再根据 POI 数据搞到 AOI 数据。另外貌似可以水经注下载。最方便的还是去某鱼找代下，十几块钱一个市，价格也不贵。

在 Arcmap 中处理数据

把数据导入 Arcmap 中筛选数据，导出为shp。

可以对图层右键 >> 数据 >> 导出数据。选择 视图范围中的所有要素 可以免去选择数据的步骤。输出要素类是输出路径，输出类型要改为 shp 。

在 Arcscene 处理模型

把 Arcmap 导出的 shp 数据导入 Arcscene 处理。对图层右键 >> 属性 >> 拉伸设定为 height (或者 floor * 层高3.6)。

会出现高度问题。对左栏 Scene 图层右键 >> 场景属性 >> 垂直夸大 >> 地理。

现在还不是 3d 模型（多面体），需要转成 3d 模型

现在每个建筑都是一个体块，直接导出会变成一堆文件，需要合并成一个“组”

右键编辑要素开始编辑

打开属性表 >> 全选，选择之后直接关闭窗口。3D编辑器 >> 合并 >> 停止编辑 >> 保存

默认即可。此时打开建筑体块_cut 的属性表，就会只有一个多面体了。效果。

使用 FMEx64 转换为 SketchUp 格式

如果按网传的方法（见下文）直接把输出的 ID_0.dae 导入 SketchUp 会出错，疑似是因为是 32 位软件。

因此需要使用 FME（64位版） 把 shp 数据直接转为 skp

FME 新建一个 Blank Workspace。

在菜单栏处找到 Reader 。添加一个 Reader 。

Format 里如果没有 Esri Shapefile ，需要下拉在更多中找。

添加一个 Writer

把两个节点连起来， Run 一下就可以了。

下方 log 栏出现 Translation was SUCCESSFUL 就可以去看输出文件了。

其他可用的方法

直接使用 arcgis pro ，只有 64 位版的，所以可以直接用自带的 FME 转换插件。

疑似失效的方法记录

网上传的方法，一般按照他们说的流程，导入 su 会卡在 10% 然后失败。方法记录。

首先要把合并好的多面体转 Collada 导出 dae 文件。

如果直接把输出的 ID_0.dae 导入 SketchUp 会出错，疑似是因为是 32 位软件。

评论区说把数据存储在 GDB 中再转为 dae 可以用 su 导入，但是实测导入 dae 慢的要死，一直卡在 10%，可能这次选的区域太大了。

后续。。依旧导入失败，此方法无效。

想要把数据存为 GDB 需要先新建一个文件地理数据库，然后导出的时候选择这个新建的 gdb 文件即可。

当然也有可能是我把数据存进 GDB 的方式不对，导致这个方法没复现成功。

</details>

Arcmap 计算街区开发强度

Kiramux — Wed, 04 Dec 2024 00:00:00 GMT

本文整理自【街区开发强度】：GIS统计街区建筑密度、容积率

由于本文中使用的都是 shp ，故给字段命名时有长度要求，因此都用了英文的简写来辨识。

另外需要注意，默认导入数据用的是地理坐标系，需要转换为投影坐标系才可以显示正常，否则图形会比较扁。可以看文中和文末的图片区别。

菜单栏 >> 视图 >> 数据框属性 >> 坐标系，选择投影坐标系下的 World >> WGS_1984_World_Mercator ，确定即可显示正常。

本文的目的是通过已有的数据，对该街区开发强度进行计算（容积率和建筑密度），因此需要根据公式计算并获取需要的数据。

计算公式：

建筑密度 = 总基底面积/总用地面积*100

容积率 = 总建筑面积/总用地面积

因此需要：

总用地面积（街区的面积）
总基底面积和总建筑面积（基底面积 * 层数）
代入公式计算
通过图的形式表现结果（调整符号系统）。

[TOC]

创建街区范围

仍旧是自行获取路网和建筑的数据。我获取的建筑数据里没有 Shape_area ，要自己用字段计算器的 Python 函数 !Shape.Area!计算一下，下文有记录.

先对路网要素转面通过道路围合生成街区面。系统工具箱 >> Data Management Tools.tbx >> 要素 >> 要素转面。

给每个街区添加街区编号。对街区.shp 右键打开属性表，添加新字段 街区id，通过字段计算器将其赋值为编号 FID 的值（有可能是 OBJECTID 等）。

计算建筑的 shape area 。添加新字段 shape_area ，字段编辑器使用 Python 的 !Shape.Area! 函数计算面积。

连接街区与建筑数据

计算街区建筑基底面积及建筑总面积

建筑基底面积 = shape_area

层数 height / 3，因为数据的 height 都是 3 的倍数，图方便就直接除以3得到大概的数据了。

建筑总面积 = 基底面积 * 层数

对刚刚输出的建筑交街区.shp 右键 >> 打开属性表，分别添加基底area （建筑基底面积）和 Total_area （建筑总面积）字段，分别计算建筑基底面积和建筑总面积。

汇总街区建筑基底面积

基底area 右键汇总，导出dbf表（dBASE 表），命名为街区建筑面积计算.dbf 。

这里已经导出过了，截图演示注意一下保存类型为 dBASE 表。

汇总街区建筑总面积

汇总建筑总面积条目

连接统计结果表与街区图层数据

就是一个操作：分别连接，添加新字段，赋值，移除连接

总结就是分别连接两个表，在街区这个表中新建字段，把刚才连接的表里用到的数据赋值给这个新建的，然后断开连接（为了不干扰下一个表的连接和赋值），重复下一个。

右键打开刚才保存的这两个表，再打开街区的属性表

通过连接与关联，通过 街区id 进行连接。

降序排列 Sum_基底area

添加新字段 Sum_base （建筑基底面积汇总），得到街区.Sum_base

移除连接。

再连接街区建筑总面积计算，依旧对 Sum_Total_area 降序排列，添加字段，建筑总面积汇总，之后赋值。

移除连接

计算容积率和建筑密度

添加字段建筑密度 Density 和容积率 Ratio （双精度）

计算公式：

建筑密度 = 总基底面积/总用地面积*100

容积率 = 总建筑面积/总用地面积

这里要用到总用地面积，即每个街区的面积，为了不和上面的建筑 Shape_area 混淆，就放到这里计算。

先计算出街区的 Shape_area，依旧是用 Python 的 !Shape.Area!。

然后用字段计算器分别计算建筑密度和容积率并赋值。

建筑密度

容积率

筛选并剔除空值：按住 Shift 去选表左侧的表头，选中之后关闭表，对街区右键导出数据，命名为街区开发强度.shp 。（视频中导出的是文件和个人地理数据库要素类，我这里导出了 Shapefile）

最后在属性 >> 符号系统里调整

成品图

这两张成品图按照出图要求做了处理：

转换为地理坐标系出图，图形形状准确与实际相符。
更换与整张图纸相符的配色，并对色块图层创建剪辑蒙版，下面是该地块的建筑底图。
加了图例和图名，成功转换为有信息量的水图。

2024年内总结

Kiramux — Mon, 30 Dec 2024 00:00:00 GMT

随便开个头写年内总结。

2024 年可以分阶段用不同的词语来概括。

1 月-2 月休假期间，是接洽了自己，好好休息，也是这时候加入了 galgamer 的群聊，认识了很多群友。

3 月-6 月，是在迷茫和浑浑噩噩，在 3 月尝试过学习一点技美入门，但是学校课总会有一种无形的压力，即使任务没多少，但是总会感觉被 PUA 了。3 月一直在白天磨洋工，晚上和室友干农活。于是 4 月为了转换心情，出去旅游玩，去南京散心。一直待在小城市，那次到了南京才第一次会坐地铁。然后和朋友玩了 2 天，他先回了，然后第 3 天我车欠了，稍微玩了下就回去了。之后就忙忙碌碌到期末了。

7 月留校 1 个月，原计划打算好好入门技美，但是每天只能面对一个电脑屏幕，没人可以说话，整个人精神状态堪忧，期间还由于这个和家里人起了点摩擦。家里人想让我回家，不想让我留到学校，不知道是什么神秘理由，我认为他们无法理解我，甚至要给我断掉生活费。于是撑了 1 个月回家了，仍旧和自己和解了，暑假休息了一个月。

8 月，休息。在暑假即将结束的那个夜晚，我和几位友人在小酒馆彻夜长谈，解决了我目标不明确和焦虑问题，让我确定了方向，并不动摇地走下去。那个夜晚真的对我来说很重要。如今有人问我今后的打算，我会毫不犹豫地说我在准备别的工作，不再瞻前顾后了。

9 月初，测绘实习，体验了无人机测绘，学会了如何用无人机拍的照片跑正投影图，跑三维重建。与此同时，我重启了技美的学习，和设计课同步进行。同时也在用 blog 记录的方式复习之前的内容，虽然只有一点点。设计课老师是一位很好的老师，他很直白地问我们，如果谁想转行在准备其他工作可以和他讲，他不会要求那么严苛。然而我在这门课设中也有想学到的东西，也有自己的倔强，有点不想认输，于是最终也没有跟他讲过。虽然最后出的成果图也是差强人意，但是有好好地把我想表达的表达出来了。

10 月，节奏中断了。国庆假期，2 天给 TA ，2 天画 Q 版，中间穿插休息，剩下的时间给了设计课和测绘画图。中旬家里人结婚，请假回家休息，于是不知不觉到了 10 月 17 日，krenz 的构成课开始了。原计划打算在 17 号之前把庄懂的课程学完，但是因为课程内容涉及到大作业有些难/上半月大量休假，导致进度停滞，不过刚好课程到达一个节点，于是技美的学习暂停，开始 krenz 的构成绘画课学习。

11 月，投入 krenz 的课程学习。中间涉及到课程作业的成果提交，于是延缓了 2 - 3 周的作业没做，课程还是跟着听。给 12 月埋了很多的雷。

12 月，忙碌 + 疲劳。新课设改为了小组作业，本来以为会比之前任务量小很多，没想到其实也不少。我不擅长做设计，于是承接了前期的技术相关工作和周围场地的建模工作。12 月写的那些 Arcgis 的文章就是学习过程中的记录，只不过有些地方需要勘误，之前一些疑惑的地方现在已经可以解决了。本以为只用画图工作量还可以，但是由于是小组作业，作图的标准大大提高了，这次画的图是我画过最密的一次。之前一张的图幅现在需要放四张图，可以理解为工作量几乎多了 3 倍，唯一轻松的点是我可以完全把设计抛给她们做。整个 12 月最要命的时期还是在课设预答辩前夕， krenz 的 L8 作业截止日期和预答辩日期完全重叠，我不得不在画图压力很大的情况下，抽出时间来做 L8 的创作作业。好在 krenz 的课程设计很精妙，他已经将前期我最不擅长的路给铺好了，于是我顺风顺水地完成了 L8 ，每个节点给助教发过去检查 >> 通过 >> 下一节点 >> 检查 >> 最终通过。就这么顺利地完成并通过了，有些超乎我的想象，本以为会卡更多时间。不过拜熬夜画图所赐，再加上周日喝了点酒，周日那晚我发烧病倒了，周末浪费过去了，甚至那天出去玩还 A 了钱，然后玩一半回去看病（草好心疼。12 月末我还在还上次生病欠下的债。

总结看来，其实直到 9 月，我今年才算真的步入正轨，其他时间其实都不知不觉流过去了，而且自己其实也并不开心，一直在被焦虑裹挟。说到底其实还是就业形式不好，还有国内建筑学本身教育安排就在 PUA 学生，不给学生留空隙。休息的空隙就只刚好够休息，一旦再加另一件要完成的事，都要透支自己的睡眠去完成，很畸形。不过今年其实已经还算轻松了，去年还一直在补修大一的课，现在看来当时的自己简直是超人了，用 1 年的时间几乎修完了 2 年的课。

其实我之前是没有写年内总结的习惯的，去年甚至写了一般然后烂尾了。今年是因为原计划的元旦贺图难以推进，于是把那个鸽了来写这个。

经过去年年末以及今年的尝试，我发现我确实不适合做创意工作，我没有创作的才能，但是比较擅长 copy 。而且现在还对前端感兴趣（虽然一直没有开始正经学），但是还是保持着想学的心态，这很好。然后在今年也萌生了很多想做的事，有短期难以实现需要长期坚持的，也有平时随手可以做得到的小事。例如我想有生之年自己搓出来一个自己设计的手办，这个要自己先画原画，慢慢学 zbrush 然后做成 GK 白模再上色，是个长期的目标。也有日常可以拿来陶冶情操的活动可以做。例如我之前想过自己画画的意义以及如何能让他人记住自己，于是我买过空白书签，再上面画上自己喜欢的人物，然后在上课时送给陌生人（当然是美少女），然后还画了一些送给社团的朋友，招新时也单独送了一些，现在再考虑画一些明信片给友人寄过去。做这些是想有机会能让自己的存在以另一种形式存在与他人的生活中，即使是只见过一面的陌生人，没准她偶然间翻到那张书签，然后会尝试回忆这张书签是从哪里来的呢？即使她想不到，这页由我画的书签仍然是留在了她的生活中。假如不幸被丢掉了，它可以说是也曾经留在过她的记忆中过。我觉得这种实体存在的画，比深藏在某个文件夹下的 psd 文件更有意义一点。

其实这一年整体看来过的蛮糟糕的，不过还好在最后努力了，还认识了很多很重要的群友，这一年也很有意义。

接下来就要准备考试，然后把作业和那些报告都做完，寒假回家好好休息，假期多玩点 jrpg ，争取过年入一台 macmini ，有空的话可以画点明信片给群友或者朋友邮寄，假期或者等开学再二度重启 TA 学习。这就是我接下来的安排和愿景。

虽然今年乱糟糟的，但生活中还是有很多美好，比如我还可以随手画一点小东西做记录，毕竟还有很多不错的朋友和群友能听俺讲话，偶尔和家里人通一通视频也挺好的。希望我的下一年没那么累，然后顺利找到实习。

今天先写到这里，明天有空的话再看一眼可能再写点。

低成本网盘存储方案记录

Kiramux — Thu, 06 Feb 2025 00:00:00 GMT

❗❗前排提示❗❗ 本文于深夜撰写，内容输出完毕但顺序有待日后优化。

概述

最近闲暇在家折腾网盘。作为穷学生一名，又想用廉价的云存储，那就只有网盘这一个选择了。

首先说明我的需求：

文件存储。游戏、图片、书籍、课程等。
影视。转存动漫、电影资源，通过程序挂载 + 302 / 反代获取网盘视频文件和字幕，在第三方播放器播放。
大空间不限速，安全稳定，价格相对便宜，短期内不会跑路，不用费心频繁迁移。

但是话又说回来，稳定、速度、便宜永远在一个「不可能三角」上，所以肯定会有不少坑和限制。

我们可以参考 Alist 官方文档所列出支持的网盘存储。

首先排除一些网盘：

阿里云盘：永久空间不大，曾经的承诺说改就改，没会员限速，PASS。
百度网盘：SVIP 用户官方客户端体验勉强还行，限设备严重，挂载复杂且使用不便，离开官方客户端使用限制很大。
夸克网盘：要开会员，88VIP被砍废了限制很多，大空间疑似需要做任务。
中国移动/联通网盘：了解不多，据说限制比较多，资源较少玩的人也少，运营商网盘，暂时不考虑。
谷歌云盘：没稳定的账号，国内无法直连，空间不便宜，暂时跳过。
还有一些其他的网盘也不在考虑范围内，不再赘述原因。Dropbox、MEGA 、蓝奏云、迅雷云盘。

排除之后，有以下表格对比：

	挂载可用性	挂载API风控限制	上传速度	挂载下载	价格	用户数/讨论度
OneDrive	✅	小/中	✅	✅	Free/5一月	✅
天翼网盘	✅	小	家庭盘or会员✅	✅	买账号便宜	✅
115	本地代理✅/302❓	中/高	会员+官方✅/挂载❓	✅	年费158	✅
123	✅	❓	❓	✅	99一年/228三年	✅
6盘	❌	❌	❌	✅	❓	❌
pikpak	✅/❌	易掉线	1T/云下载✅	✅/WebDAV⍻	贵且不等/邀请白嫖	✅
Terabox	❓	❓	❓	❓	Free？	✅
FebBox	❓	❓	❓	❓	Free？	❓

一些可能可用的网盘，没有过多尝试：

115：原石会员高峰期限速，挂载使用不当疑似会风控。好在原石会员便宜，当时买号时送了3天体验会员，迁移了部分文件，体验不错，后来 115 改了上传接口，当时无法挂载上传文件了。现在 API 上传已恢复，但是账号是没会员状态，我只需要它的大空间，月费会员过于昂贵，为了传几t文件花一百多充年费疑似不值得。由于有人用它来开影视站，官方目前限制卡的很死，用 cookies 挂载掉线是玄学问题。据说之后会出 API ，先观望。
123：会员和空间挺便宜，了解不多，听说挂载使用体验还不错。分享链接会封文件。
6盘：国内的一家基于 IPFS 的云盘，现在仍在整改调整中，计费计划还没出。前几天可以注册体验，注册有 12T 空间，上传流量少的可怜只有 10g ，只能用过磁力上传。现在使用的空间，等计费计划确定之后要发账单的。
FebBox：空间大，之前看的时候官方客户端做的烂，且 WebDAV 不支持上传，不知道现在如何。
pikpak：会员贵，主打磁力下载，登录挂载容易掉，WebDAV 挂载有时速度很烂，会员上传和下载流量有限制，不适合高强度挂载使用。
Terabox(海外百度)：听说送很多空间，还可以刷很多空间，不知道是否限速，再加上是百度加的产品，没有上手尝试。

大致上符合需求的网盘，实际大量使用过：

OneDrive：E5 和家庭版。免费 or 便宜，挂载使用体验极好，限制不多。
天翼网盘：便宜，大空间，基本不限速，资源多。

还是因为「不可能三角」原则，目前（打算）主力使用的网盘只有 OneDrive 和天翼网盘。这两个网盘限制最少，价格最便宜，使用体验最好。可能其他网盘也很不错，考虑到文件迁移，目前精力有限只主力用过这两款。接下来我就对这二者的使用体验和注意事项方面逐一说明我的个人经验。

OneDrive

Onedrive 分很多版本。A1 相关的 Onedrive 基本已经死绝了，E3 只有少部分人有订阅，使用最广门槛最低的只有 E5 试用和家庭版订阅了，下面详细说明这两个。

购买价格

E5 试用：5T *25 。现已无法免费注册，注册条件见：谁有资格获得 Microsoft 365 E5 开发人员订阅？
家庭版：1T*6 。5 CNY/月。注册土耳其区 AppleID 并充值礼品卡，通过 App Store 订阅月付的 Microsoft 365 家庭版。

下载和上传相关

下载体验从左至右依次降低⬇️：挂载/反代下载、rclone 配合前者 > 网页+多线程 > 客户端

上传只推荐：客户端 / rclone 。（极少时候用到本地部署 Alist，分别挂载本机存储和 od 再 copy ，下面会讲）

E5 灵车🚗

现在除了无法免费注册，时不时还会有被~~无差别~~封禁的风险。因此虽然有免费的大空间，但随时可能丢失数据，已经成为名副其实的灵车了。

E5 的 OneDrive 挂载到 Alist 、 Onemanager 等网盘程序获取下载直链，搭配 IDM 等多线程下载工具体验很不错。短时间内下载文件过多会报 activityLimitReached ，等待 1-2h 会恢复。

E5 只推荐挂载下载。E5 的客户端直连下载很烂，用浏览器直连下载获取的直链体验也很烂。

E5 OneDrive 一般不审查文件，只审查病毒/炼铜屁内容。审查 ban 掉的「疑似」含毒文件可以通过网页版取回本地，入口有些隐蔽。

一些特殊拓展名文件有时也不被允许上传（极少情况一般遇不到）

家庭版🏠

购买订阅后获得一个账号的订阅以及5个订阅席位，每个账号有 1t OneDrive 。你可以注册5个小号分配席位，然后通过 Alist 别名实现 6T 一样的效果。

听说 API 限制比 E5 严重很多，动不动会限制。虽然不支持创建应用程序，但也可登录挂载到 Alist / rclone 等程序。偶尔会小封一下账号，手机验证码验证一下即可。

家庭版疑似审查色情敏感内容，因此不要对这些文件创建分享链接，否则可能会面临很严重的封禁，不是收收验证码就可以解决的。

虽然限制不少，但是比起国内网盘的文件审查可以说是几乎没有了。每月 5 元的价格提供 6T 的空间，即使是作为冷备份空间也是很不错的选择。

Cloudflare 反代下载

详细教程请参见：AList如何使用代理下载链接

按照教程走就OK，这里记录一些你可能踩到的坑。

Cloudflare 只代理 80/443 端口。cf 反代隐写端口号域名无法访问。

可能你会因为 80/443 的特殊性，单独为了部署 Alist cf 反代购买一台 vps 。这时假如你把 Alist 的端口设置到 443 ，然后又恰巧通过 cf 绑定域名并用页面规则反代隐写端口号，这时你会发现域名无法访问了，用 ip 却可以正常访问。

解决方法 ：Alist 端口改为 80 。
alist-proxy.js 相关问题。

var ADDRESS = "YOUR_ADDRESS";

这里的 Alist 地址如果填写 ip 可能无法反代。

前阵子新增了WORKER_ADDRESS，填写 Worker 的地址即可。
优选域名和 IP 会影响反代下载速度。
Crypt 驱动不能反代，Pikpak 的 WebDAV 挂载疑似也不能反代。

确实可以单独准备一台 vps 用来跑 cf 反代，然后通过 Alist V3 协议挂载到主力站点就OK。

OneDrive 补充

如果你试过用 Rclone 在两个 OneDrive 之间迁移文件，会发现最近 API 限速严重，无论是上传还是下载，甚至到无法使用。在我没用反代之前，只能被迫把 rclone copy 的参数改为 --onedrive-chunk-size 150M --transfers=1 才能勉强使用。

rclone copy -v "storage01:/folderA/" "storage02:/folderA/"  -P --onedrive-chunk-size 150M --transfers=1

之后发现海外 VPS + cf 反代刚好解决了 OneDrive 的 API 限速问题。但是由于上传还有限制，所以速度也只是在 100Mb/s 左右，勉强能看。

Rclone + OneDrive + Cloudflare 反向代理，Copy 文件到本机存储截图：

上图为国内联通 300M 家宽， rclone 下载 cf 反代的 OneDrive 文件速度。

天翼云盘

账号的选择和购买

	空间容量	传输速度	单日上传总量（文件大小）	单文件上传大小	单次转存文件数
普通账号	30g + 30g	高峰期限速❓	≤2G（可家庭中转）	≤2G（可家庭中转❓）	≤1000
黄金会员	2t + 2t	不限速✅/❓	≤200G（可家庭中转）	≤200G（可家庭中转❓）	≤10000
铂金会员	4t + 4t	不限速✅/❓	不限制	不限制	≤50000
备注	可买大空间账号	使用不多没遇到，听说限速	买号不推荐共享家庭	未测试	-

我目前的账号（闲鱼购买）：

铂金会员 4+4 ：4T 个人 + 4T 家庭，主力盘，用来上传存文件。配合 Crypt 加密上传了很多「重要文件」。

普通账号 20t ：20T 个人 + 30g 家庭。用来转存影视资源挂载播放，或者转存会员号的分享文件。

选择天翼云盘的原因

电信运营商网盘不怕跑路，也不像联通和移动抠抠搜搜的，网盘权益很多。
有大空间和会员账号可以低价购买，不用担心实名问题。
绝大多数情况下不限速，可以挂载 Alist。
配合 Crypt 加密可以实现文件的安全存储，给自己的游戏和小姐姐一个安全的家🏠。
可以把文件分享给其他账号，避免某个账号突然暴毙。
影视资源较为丰富，挂载看视频体验很好。
正常使用不乱折腾，账号很稳定。

与此同时也有些许遗憾：

分享文件时需要先审核才能分享，不过不影响 Crypt 加密文件分享。
非电信（多是移动）可能会使用速度不佳。我这边联通家宽无影响。
低价购买的账号不能修改密码。❗❗触发验证码是高危操作❗❗ 后果是账号可能会突然无法登录。
家庭空间文件可以不经过审核转移到个人空间。而天翼网盘有家庭共享功能。原本可以把会员号的大家庭空间和普通账号绑定，实现会员上传再转移到普通号的大空间内。这个操作会涉及到验证码高危操作，所以尽量避开❗❗ 已经有人去试这个然后账号无法使用的例子了。当然也有人试过这个无事发生。
Rclone 没有支持天翼网盘存储，几乎无法使用 Rclone 写入大文件。
太多设备登录也许会掉登录。

Crypt 相关

使用 Crypt 加密可以安全地在网盘放文件，但是一定要牢记密码和盐值 ❗❗ 否则数据丢失可不是闹着玩的。

Alist 的 Crypt 有性能问题，以下是我遇到的情况和问题，至今仍未找到解决方式：

Alist 复制文件到 Crypt 存储（网盘上传）速度有时过慢，任务有时会失败而浪费 vps 流量。
本地 PC 部署 Alist 本机存储，用 rclone WebDAV 挂载 alist 复制文件到 crypt （上传）也会有性能问题。PC 的性能肯定够，但是多数上传 80 KB/s。
VPS 上部署的 Crypt 存储下载有时会遇到性能问题，即使看不到一点点 CPU 和内存占用，有时下载速度也是几百KB/s 的龟速。
本地 PC 部署 Alist 挂载该Crypt 存储，下载速度飞起，疑似只适合挂载到本地 PC 用。

~~这也相当于一种另类的网盘客户端了。~~

Crypt 上传

Rclone 不支持天翼网盘，而通过 Alist 复制文件到 Crypt 存储实在很难用，还是用的国内运营商网盘，本身使用移动等家宽就有可能会有网络问题，海外 vps 就更不必说了。因此我十分想通过 Rclone + Alist WebDAV 实现上传文件到 Crypt >> 天翼网盘。

然而只实现了1%。

以下操作除非提及使用 PC ，其余都在海外 VPS 操作。

我的思路：

Rclone 直接挂载 Alist WebDAV，直接从其中的网盘A 复制到其中的 Crypt，相当于从 Alist WebDAV 网盘 >> Alist WebDAV 网盘，通过 Alist 的 Crypt加密。

WebDAV 挂载时不能挂载托管在 Cloudflare 的域名，否则会只空跑流量不传输文件，返回 Cloudflare 相关的错误，因此之后的 WebDAV 都用 ip+端口挂载。

结果：失败❌
WebDAV 用 ip+端口挂载到 rclone ，仍使用上面的方案，文件有时传输到 100% 后长时间没反应，有时干脆根本不传输。

结果：失败❌

此时我意识到不能直接通过 Alist 的 Crypt 加密，这个 Buff 叠的太多了，加密还要走一层 WebDAV 协议。直接在 rclone 这边加密相当于在 VPS 本机操作，更近一点应该更合理。

Rclone 直接挂载 Alist WebDAV， Alist WebDAV 里的网盘作为文件源A，在 rclone 添加一个天翼网盘的 Crypt 加密存储B，然后rclone copy A >> B，相当于从 Alist WebDAV 网盘 >> Alist WebDAV 网盘，通过 rclone 的 Crypt 加密。

结果：失败❌

这时我搜到相关帖子，想到可能是文件源的问题，可能是 Alist WebDAV 的问题，于是发现就算不走 Crypt 加密， Alist 存储间通过 WebDAV 复制都有极大概率出错。

那么不走 Alist WebDAV ，而直接挂载 OneDrive 或者直接用本机存储作为文件源试试如何呢？

Rclone 挂载 OneDrive 作为文件源A，同时挂载 Alist WebDAV ，在 rclone 添加 WebDAV 里的一个天翼网盘 Crypt 加密存储B，然后 rclone copy A >> B，相当于从 OneDrive 网盘 >> Alist WebDAV **网盘 **，通过 rclone 的 Crypt 加密。

结果：失败❌，只有一个几百兆的小文件成功了一次，之后速度就几乎为0。此时我意识到 Alist WebDAV 用 rclone 复制，只能走本机存储 >> 网盘。
PC / VPS Rclone 挂载本机存储A，同时挂载 Alist WebDAV ，rclone 添加天翼网盘的 Crypt 加密存储B，然后 rclone copy A >> B。相当于从本机 >> Alist WebDAV **网盘 **，通过 rclone 的 Crypt 加密。

结果：大文件成功✅

此时我意识到本机存储上传是可行的。

于是我在自己的 PC 上搭了个 Alist 又来测试，从本机存储复制到 Crypt 加密的天翼网盘，发现不会报错全部成功，但是也会出现文件传输 100% 后需要等半天才上传成功的情况，真的要等好久。我上传总大小 2g 数量为 1,294 的图片，居然花了 2.5h 。

经过以上历程，我已经彻底放弃用 rclone Crypt 加密上传天翼网盘了，还是老老实实用 Alist 的复制功能吧。

意外收获

WebDAV 可能没有我之前想象中的那么好，经过深入使用，它的阴暗面已经渐渐地暴露出来了，各种权限问题真的层出不穷。例如有的云盘给 WebDAV 权限只有读取不给上传，还有各种限速问题……网盘支持挂载或者 WebDAV 速度不限制的话，肯定会被用来建影视站，网盘被薅怕了就会改政策。目前看来多家网盘都是这个结果，天翼网盘是电信家的应该不怕，现在带宽这么贵，不知道 123 网盘能撑多久。
如果想通过 Alist 把本地文件上传到挂载的网盘，那么挂载本机存储，用 Alist 复制到那个网盘是更好的选择。这是除用官方客户端上传外最好的方法了，同时可以用到 Crypt 加密。使用网页端上传的同学应该深有体会，本地通过上传接口上传到 Crypt 存储，稍微大点的 4-5g 的文件几乎没有不出错的时候，而使用复制功能可以极大提高文件传输成功率。
搭建好 Cloudflare 反向代理之后，发现真的很好用，几乎万物都可反代，通常在海外有非常客观的速度，可以拿来突破 OneDrive API 的下载限速问题。同时也体会了本机代理的好，像 115 这样风控严重的网盘，使用本机代理可以大大提高挂载稳定性，不会因为 302 给全球各地的 IP 而掉登录。
另一种文件分享的思路。通过 Crypt 加密上传到天翼等网盘，然后分享加密后的文件，附上加密和盐值。拿到文件的用户，自行解密使用。

前端笔记 - Form Input Wave

Kiramux — Sat, 15 Mar 2025 00:00:00 GMT

效果

代码地址

Live Demo

实现思路以及用到的东西

本身是 flex 布局的一个小表单项目，记录一下某些细节的实现方式。

Input 的样式

/* 点击 input 或焦点在 input 上时，去掉描边并更改颜色，用两个伪类实现 */

.form-container input:focus,
.form-container input:valid {
    outline: 0;
    border-bottom: 2px lightblue solid;
}

.form-container input {
    display: block;
    background-color: transparent;
    width: 100%;
    border: 0;
    border-bottom: 2px #fff solid;
    padding: 15px 0;
    font-size: 18px;
    color: #fff;
}

:focus

表示获得焦点的元素（如表单输入）。当用户点击或轻触一个元素或使用键盘的 Tab 键选择它时，它会被触发。

https://developer.mozilla.org/zh-CN/docs/Web/CSS/:focus

:valid

表示内容验证正确的<input> 或其他 <form> 元素。这能简单地将校验字段展示为一种能让用户辨别出其输入数据的正确性的样式。

Label 文字波动上移

部分 HTML 代码：

<form>
    <div class="form-container">
        <input type="text" required>
        <label>Email</label>
    </div>
    <div class="form-container">
        <input type="password" required>
        <label>Password</label>
    </div>

    <button class="btn">Login</button>
    <p class="text">
        Don't have an account? 
        <a href="#">Register</a>
    </p>
</form>

部分 CSS 代码：

.form-container label {
    position: absolute;
    top: 15px;
    pointer-events: none;
    /* 加了上面这行，鼠标才能穿透label点击input */
}

.form-container label span {
    display: inline-block;
    font-size: 18px;
    min-width: 5px;
    transition: 0.3s cubic-bezier(0.68, -0.55, 0.265, 1.55);
}
/* 对 span 设置了 inline-block 后，下面的 transform 才生效 */

.form-container input:focus ~ label span,
.form-container input:valid ~ label span {
    transform: translateY(-30px);
    color: lightblue;
}

JavaScript 代码：

const labels = document.querySelectorAll('.form-container label')

labels.forEach(label => {
    label.innerHTML = label.innerText
        .split('')
        .map( (letter,idx) => `<span style="transition-delay:${idx * 30}ms">${letter}</span>`)
        .join('')
})

这段代码为表单 label 标签中的每个字母创建独立动画效果：

将标签文本拆分为单个字符，每个字符包裹在带有递增过渡延迟的中，最终配合 CSS 形成波浪式动画效果。

JavaScript 笔记：

DOM选择

document.querySelectorAll('.form-container label')

特性：querySelectorAll
作用：CSS选择器获取节点列表
文档：querySelectorAll - MDN

遍历元素

labels.forEach(...)

特性：NodeList.prototype.forEach
作用：遍历类数组对象
文档：NodeList.forEach - MDN

文本处理

label.innerText.split('')

特性：String.prototype.split
作用：字符串转字符数组
文档：String.split - MDN
引号内是用于分割的 separator ，省略 separator （即：‘’）或者传递 undefined 会返回只包含所调用字符串的数组，比如这个项目的效果是 ["E", "m", "a", "i", "l"]。

数组转换

.map((letter,idx) => `...`)

特性：Array.prototype.map + 箭头函数
作用：数组元素批量转换
文档：Array.map - MDN | 箭头函数 - MDN

// 正确写法（保留前两个参数占位）
.map((element, index, originalArray) => {
    console.log(originalArray) // 原始数组的引用
    return element * originalArray.length
})

// 或
// 只使用元素
[1,2,3].map(n => n*2) 

// 使用元素和索引
[1,2,3].map((n, i) => n + i)

// 使用全部三个参数
[1,2,3].map((n, i, arr) => n + arr.length)

// 如果不需要某些参数
.map((_, _, arr) => arr.join('')) // 用下划线占位

Array.prototype.map 里的三个参数不能换位置，后面两个参数可选，但是如果用数组参数，就必须要留 index 的位置，用 _ 占位。

箭头函数用 {} 就必须有 return 只有一个变量时可以省略 () 只有一条表达式时可以省略 {} ，且不要 return

模板字符串

`<span>${letter}</span>`

特性：模板字面量
作用：动态字符串构建

文档：模板字符串 - MDN

Q：${} 中可以写哪些内容？ A：任何合法 JavaScript 表达式：

`计算：${2 + 3 * 4}` // "计算：14"
`时间：${new Date().toLocaleTimeString()}`
`嵌套：${`子模板：${value}`}`

Q：如何输出反引号？ A：使用转义符：

`这是一个\`反引号\`` // "这是一个`反引号`"

Q：模板字符串会执行HTML转义吗？ A：不会！需注意XSS防护：

// 危险示例
const userInput = '<script>alert(1)</script>';
document.body.innerHTML = `${userInput}`; // 会执行脚本

// 正确做法：使用textContent替代innerHTML

// 危险！用户输入可能包含恶意脚本
element.innerHTML = `<div>${userInput}</div>`;

// 正确做法：转义特殊字符
const safeHTML = `<div>${escapeHTML(userInput)}</div>`;

function escapeHTML(str) {
    return str.replace(/&/g, '&amp;')
             .replace(/</g, '&lt;')
             .replace(/>/g, '&gt;');
}

数组合并

.join('')

特性：Array.prototype.join
作用：数组转字符串
文档：Array.join - MDN

[1,2,3].join('-') // "1-2-3"
[1,2,3].join('💡') // "1💡2💡3"

DOM更新

label.innerHTML = ...

特性：Element.innerHTML
作用：解析HTML字符串
文档：Element.innerHTML - MDN | Element.innerText - MDN

innerHTML 包含 HTML 标签，而 innerText 剔除 HTML 标签，只保留文本，表示一个节点及其后代所渲染文本的内容。

随笔一则-250416

Kiramux — Wed, 16 Apr 2025 00:00:00 GMT

最近过的十分混乱十分魔幻，这一周通了不少宵，短短一周一共七天，居然通宵四次 😱，直到现在也没缓过来。一直想找个时间写点东西，没想到过了两天，又有更多想写的东西了。

自从月初从清明假期结束后，在家恣意休息，落下很多进度，于是回到学校之后开始恶补，特别是设计课的项目。

由于想写的太多了，先把想写的话题分开写。

//关于生活和学习/工作的界限

高中毕业后，我最先想到的就是购买一部属于自己的电脑，然后得到之后，开始了我的电脑人之旅。本身对于 PC 比较感兴趣，于是找来各种各样感兴趣的地方研究。同时也比较喜欢画画，于是经常在休息的时候看一些绘画视频/教程观摩学习。因为这些玩的过程很有意思，于是经常不感到疲倦，同时感到很快乐，时间全花在上面，然后游戏也没啥时间玩了，或者说不怎么想到去玩。

自己杂七杂八的研究这个研究那个，可能确实是懂一些，然后日常各种工作都更轻松更舒服一些，但是直到最近，我突然意识到，自己好像没什么能拿得出手的项目。或者换句话说，无法证明自己的能力。最简单的体现，除了自己的主修课程，其余方向上没有任何一个方向“有所成就”，连半份简历都凑不出来。最近越来越接近毕业，也是要提早考虑就业问题，于是想找方向主要学习，然后做些项目出来。

然而这么想着开始学习时，忽然发现这种学习侵占自己的生活太多，几乎没有生活的存留空间了。我现在还是没办法很好地划分学习和生活的界限。之前是觉得“这个不错啊，来做吧！”，于是废寝忘食地去做。然后有些累了或者疲倦了，又遇到其他方面的不错的东西，于是抛下之前的事去做别的。有点朝三暮四的感觉。

学了建筑学之后，我在一学期内就领悟到了一个道理：在 deadline 之前，工作是永远做不完的，除非到了临近日期不得不提交成果，否则工作甚至可能会越做越多。于是我决定一定要将学习和生活分得开。前阵子 C 来到我们专业教室，评价我们上学像上班……每个人坐一个工位，然后来了就开始对着一块屏幕做自己的工作。

//关于认真生活

我曾经做了许多计划，几月中旬、几月初什么工作做到什么程度，什么内容学到什么进度，然而总是计划赶不上变化，于是我寻找到了原因：这些计划与我的休息和生活冲突，特别是在假期的时候。

于是我假期用来休息。

我的家乡在某高考大省，从小被灌输的观念都是学习第一重要，休息什么的都靠边站。以至于我在转专业之后，面对课业压力，被迫也在以这种方式推着自己走。最近越来越注意到，认真体会生活，甚至学习生活中各种技能，也是生活中非常重要的一部分。

前面提到，我在假期休息。放在曾经被灌输的观念里，“假期才应该多学习、弯道超车”等等，但我觉得假期休息是必要的，学会生活在人生中也是非常重要的。或许我也还是在自己推着自己走，才会有“假期不学习是不是浪费”这种想法，我在潜意识里可能还是在这么想。但是又从另一个角度来看，我在这个假期陪伴家人，探访亲戚，练习开车，这些也很重要。现在就业形势那么严峻，面向就职多学一些未必会和其他应届生做更多区别，未必会有更好的工作选择，但是给自己疲惫的身心休息时间，以及给家人朋友多点陪伴或许更有价值。毕竟家人会陪自己一辈子，朋友也会陪自己走尽可能久，再看看那沟槽的工作呢，它值得你为了它而疏于生活，疏于陪伴家人朋友吗？

//关于恋爱剧情

上文说到 C 来我这边找我了。在她来我这边找我的前一天，其实我刚跟朋友出去通宵唱 K 去了，睡到中午准备开始下午的画图。进入状态没多久，忽然一条信息弹出，“来不来喝酒”。她怎么来我这边了我去。于是光速收拾好去见她。关于她来的理由我其实挺不能接受的，她其实是“失恋”了顺便来找我的，只是因为我在同一个城市。

我当然是心情很复杂，但还是决定一起去附近的景区逛逛。一开始空气真的有点安静，不知道彼此之间要说些什么，刚好碰到了那个景区举办小游戏活动，我们一人一本小册子，去游景区做小游戏集印章。我们两人在一起手捧着本小册子，一边看前面的人表演一遍排队，真的很有约会的感觉。

多亏了这个集印章小游戏，让我们有了游园的理由和目标，不再有那种尴尬的气氛，玩了小游戏也比较放的开了。我们写了毛笔字，抢粮票，还给她录了她跳舞的视频。然后在一遍找集印章地点时，我们还同时在找可以出片的场景，陪她拍照。当时我有些恍惚，在其他人眼里，我们是不是很像情侣。不过拜她所赐，经过她的指导，之前没什么拍照经验的我也能拍出很不错的照片，她看起来很高兴。

景区闭园之后，我们找了一家小酒馆，顺便叫了另一个人，于是我们三人开始喝酒，玩骰子。喝着喝着，他们可能喝醉了，于是开始大聊情感话题，我就在一边装睡一边听，同时还要注意不让他们上头接着点酒喝，中途她居然还把她房间号告诉了我。

这些都结束之后，我们出门走走，在河边看到了很圆的月亮，我想起了《I/O》和《月姬》的剧情，同时也在回忆今天的经历。我真的很喜欢月亮，不仅仅是那处风景，也很喜欢月亮虚无缥缈的意象。于是我拍下了一张照片留念。之后 C 又点了点东西吃，我们在河边又聊了很久，这种感觉真的很久违，我突然想到高中的时候，我唯一一次生病请假，我妹妹邀请我去外面散步走走，真的很突然，她从来没有做过类似的事，当然我也没经历过。那天也是圆圆的月亮，路上几乎没有行人，我们在路灯下走着不断聊天……我忽然又恍惚自己是在当年。这些经历给我的感受真的很相像，应该会让我永生难忘。

那天我为她拍了很多照片，凌晨我翻着相册，看着手机荧幕中的她，觉得挺可爱，第一次萌生了想要主动备份相册的念头。

//GalGame 的价值

从所谓“第三人称视点”来看前几天发生的事，是不是可以这样总结：

某天我在疲于工作要死要活时，突然收到了失恋女孩的一则消息，她突然来到了我在的城市，问我要不要出来喝酒。

接着我们莫名其妙地像情侣一样在景区给对方拍照、合影、做游戏集印章……接着又去喝酒，互相倾诉情感事迹，甚至她还告诉了我那个神秘数字……

这情节修改一下甚至完全可以当作某废萌 GalGame 作品的共通线剧情了，甚至很俗套。

事实上陪 C 出门那天，我其实特别忙，因为我已经花掉一天去陪朋友出去场 K，然后第二天其实要课设预答辩，而我的进度几乎没有推进……然后我犹豫了一小会儿，还是决定陪她出去玩。不涉及男女之情，我还是觉得朋友比较重要，狗屁课设作业算什么。

之前看到一篇文章标题是“GalGame 的价值”，虽然那个作者写了什么内容我已经记不得了，但我经常会问自己，玩了很多 GalGame，对于我来说，什么是 GalGame 的价值。在那天我和 C 出门约会归来之后，我又开始思考这个问题。我觉得 GalGame 的价值最大在于，它让我认识到应该以真诚的态度对待自己身边的人。我玩过一些比较“黑深残”的作品，你会发现在这些表面看上去很猎奇很残忍的故事背后，绝大多数的作者都还是在宣扬倡导最朴素的正能量价值观。例如《素晴日》、《寒蝉》、《海猫》、《月姬》等。特别是在被以“血池轮回”称号冠之的十二神器之作《3days》，在最后抵达真实之扉时，仍然是为了友情和爱情，在与邪恶斗争。也是玩过这个游戏之后，我不知不觉中把 C 看作自己人生中的“藤见环”。她是亲密的朋友，是青梅竹马，是朋友之上无所不言的关系，却并非一定要是男女朋友，只不过我不能忍受她受委屈。

//有能力有水平的老师，真心向我们传授经验

这学期我有一个很严重的失误：有一门很重要很精彩的课，我用没选课的借口少上了三节课。

哪门课是一门实务课，我本以为也是水课，直到去了才知道这门课真的很有用，是请了一位相对于设计院老板的女士来给我们讲课。我前阵子在 B 站上听了雷军班班会的讲话，深有体会并且受益匪浅。像这种级别的老师肯平下心来平等并无保留地对我们讲授经验，真的是很难得的机会。她的这门课会给我们讲几乎所有建筑学在工作单位会遇到的实务问题，还有相关考研考证的推荐。同时每位同学还要去讲自己对于建筑学的见解，以及自己将来的打算。我很重视这次机会，于是好好准备了一下，这也是我第一次如此重视如此认真地去准备一次 presentation ，同时也是一个了解同学们想法的很好的机会。

这位老师在昨天最后一节课上，对我们讲了很多她想对当年的自己讲的一些话和经验，如果当年有人能对她讲这一番话，她肯定会比现在更好一些。我最近其实也有点丢失方向，也真的很期望有人能对我讲一些这样的话。刚好这位老师有水平、有经验、不摆架子。

其中提到几点：

要不断学习并舍得对自我投资
学习从书和知识中寻找解决方案，历史/经济/心理学
合理安排时间
投资的一些建议
多一些准备，多一些退路，没有一个事业可以干 30 年之久
……

我想等我消化一下之后，再专门找个时间整理一下。

在课堂中，这位老师是真的为我们好，希望我们能听进去，未来发展的更好，看待事物也不带偏见，指出她同期的同事不思进取的桎梏所在。我又想到之前测量学的老师，他也是一位很能抓得住机会和风口的老师，很有水平，只不过他现在在我们学校执教“养老”，看他也活的很豁达。他也是很真诚地为我们做建议、指路。说实话能遇到这样的老师真的很好，而且也可以算是我的引路人，不至于让自己彻底迷失方向。其实在高中毕业之后，我就很少有明确的目标和憧憬的人了，即使有憧憬的人（或者说是当作目标的人），在和他们熟识之后，也会发现他们是普通人，也有擅长和不擅长的事，甚至还会想，自己努力到他们那种程度，又如何呢……

不过有引路人已经是一件很好的事了，总好过周围一堆烂人。

有时候看着这个沟槽的世界，本来都觉得一篇黑暗了，什么傻逼，但是想想自己周围的朋友，他们都是很纯粹的人，又觉得世界上还是有很多不错的好人的，也不至于那么遭。这也是我经常给自己充电的方式。

//时间安排

这点之后在写吧，时间有些不够了。

//画画

最近突然又重拾画笔，又有了画画的想法、很想设计自己的人物了。今天画了《I/O》中的角色朔夜，把赛博世界中的角色留在了现实世界中。打算再找个时间用冷裱膜和胶带把它做成色纸 🥰。

画画之魂又重燃了 🥰

![sakuya]../images/012/sakuya.jpg)

![sakuya]../images/012/sakuyaPaint@0.5x.jpg)

左侧重颜色不小心加了太多 TT

绘画总结（上）

Kiramux — Wed, 13 Aug 2025 00:00:00 GMT

前阵子报名了毛厂速写绘画的速写团练60天。经过30天的训练，已经卓有成效。

训练之前：

训练之后：

现在看看30天之前画的画真的很愚蠢……

“课程”介绍

特色和优点

以下评价仅针对于 3 期，个人观点仅供参考。

不同于另一家「xx班长」的速写团练只有录播课，毛厂的速写团练可以算成是一门课程。

课程十分便宜只要299，性价比很高，我认为薄纱了很多几千块报名费的课程。团练每天都有直播带画，会讲很多知识（人体、如何画角色、黑白灰关系、画面构成设计）。每周六是图包拍摄，可以看到真实动作是如何来的，与摆拍有什么区别。周日是很牛的嘉宾分享课~~（我一般当成鉴赏课来听）~~。

课程结束后会有奖金瓜分和纪念品。人太多了奖金应该只有一点点，所以可以忽略。打卡满60天会送一个很有意思的吧唧。

老师讲的内容和绘画理念很好，不会误人子弟。

一些不足

团队管理运营人手不足，但是不影响上课。我在报3期进课程群时审核很慢，可能是报名人数是在太多了。上课使用的是「小鹅通」这个平台，发展还不太成熟，界面逻辑有待优化，不过网络还可以（如果平台没有更新的话）。

有一点点学生饭圈化的感觉。

学习心得

准备工作

软件等配置和老师尽可能完全一致。绘画软件、数位板、软件布局，为的是能100%复刻老师的各种操作，降低软件操作的学习成本。同时也顺便学习到老师使用软件的习惯、工作区安排和软件操作，可以参考老师平时的绘画流程。

一台PC | 数位板、数位屏 | sai2 | pureRef（参考图软件）

调整 sai2 ，分别为以下工具设置合适的快捷键。

由于我已经习惯了 [A]减小画笔尺寸、[D]增大画笔尺寸，所以我的快捷键可能有些奇怪。

使用最基本的 3 种笔刷：

[B]铅笔、[Z]喷枪、[C]水彩笔（涂抹用）。

[S]选区笔、[F]选区擦、[W]魔棒

[R]扩大选区1px、[T]缩小选区1px

为什么要设置快捷键？

当熟悉快捷键之后，操作效率是非常高的，可以在1s内迅速选区然后用喷枪图几笔。如果不为经常使用的工具设置快捷键，画几笔就需要去选其他工具或笔刷，会经常性地打断绘画，浪费了时间，甚至绘画思路也会丢掉，所以要保证自己的笔一直在画画！！

下图我做了以下操作： [S]选区笔封闭线稿 -> [W]魔棒选择区域 -> **[R]**扩大选区 -> [Z]喷枪填充

如果非常熟练的话，这个过程可以很快完成，效率很高！

把喷枪调大，填充非常方便，可以很好的控制深浅，也可以在选区边缘轻轻蹭，实现渐变效果。

基础训练

起稿不用太在意型准，但需要特别注意面积和比例正确。需要特别注意整体！所有的「正确」和细节都需要为整体让步。

随意画的草稿比仔细勾线的线稿更好看，很大程度上是因为勾线时追求精致，放大到局部去画，忽略了整体。因此忘掉勾线这个步骤，换为“细化造型”。

选 sai2 最普通的铅笔笔刷，把笔刷调整到和躯干、四肢差不多的粗细。观察整体，用色块起稿画出相似的趋势。
补上轮廓线，这一步需要注意各个体块的前后关系（谁在谁的前面？），依旧不用注意型准。可以先重叠起来画，再把被遮挡的部分擦掉。

[每一步都需要检查一下比例和趋势（斜度），选区后用 Ctrl + T 调整]

新建一层，重新画一遍

注意：

如果参考图的人物不是失衡状态，则人物的重心一般在两脚之间。从头顶向下拉一条竖直的线可以找到重心。
一定要观察并检查画面的整体比例、面积、以及各部位的前后遮挡、穿插关系。

以下截图来自老师直播带画。

纠结型准？

什么是型准？为什么要追求型准？型准的目的是什么？

我们所有的练习最终都是为画面和创作服务。我们可以拥有画得像能力，但不需要苛求每次画画都做到和原图 90% 甚至 99% 相似，这只是平面思维。再换个角度想想，我们创作找参考时绝对找不到一模一样的参考图，我们拿到参考之后一定会对它做处理，旋转角度或是增减零件，所以追求从平面上画得一模一样对创作来说意义不大。追求平面型准只是一种能力，但不是那么地必要，除非你想要把自己变成一台照相机。然而现在相机已经足够多了，甚至现在 AI 文生图、图生图的能力越来越强，我们或许真的应该想想自己追求的是什么。

我们需要引入平面思维和三维思维。

感性：我们可以把眼睛看到的画面看作是2d图形，它是感性的。我们看到上图中某个图形（剪影）会想到什么？上图的每一个作品都没有画出任何 3d 结构，但我们的大脑仍然大致可以看出（我们认为的）物体，可能是人物、楼梯、城市，或者某个场景。

理性：我们学习透视，或者 3d 美术，或者游玩 3d 游戏，会了解到三维的模型经过渲染器渲染，最终会输出为屏幕上的 2d 画面，所以理论上来说一切画面都可以通过 3d 的思维来实现。

用纯图形（感性）的思想，上手简单直观，但易遇到瓶颈。有人经常会发现自己可能已经画得很不错了，但仍缺些什么。信息量不足？如何添加细节才更合理？什么是按照结构来画，结构要怎么确定？同时我们也会发现有些人物或物体角度、有些场景很难画出来，或者画出来不太真实。

3d 透视有标准答案，它是理性的，它绝对「正确」，但不灵活，它不像我们手持一支铅笔就可以在纸上很快地涂鸦出画面，3d 需要我们摆模型、设置摄影机和光源……只用三维的思想很难快速地表达我们的创作想法，它在限制我们的表达，用三维的思想直接构图对人的要求特别高。而且一般来说，直接用 3d 方式出图，效果总没有平面出图来的自然且有灵性。通过「绝对」正确的计算出来的内容「绝对」正确，十分经得起检验，奈何它一般都不好看。

所以我们自然而然地想到：可以先通过感性（平面）画出草稿框架，再给其中填充透视。这条路径是过度十分顺滑且低耗的，也同时继承了这两种思维的优点。

基础进阶

一些补充说明：

观察上图，小臂可以理解为一段圆柱和一段长方体的平滑过渡，不要去研究小臂的肌肉和骨骼，纯纯浪费时间，只要记住这个形状即可。
一定要记得画“护腕”，给手腕留位置。手掌通常会和小臂末端稍微错开~~（往哪边错开我忘记了）~~。
不要在意胯部和大腿根部如何连接，先画重合在一起，再补成圆柱，最后根据遮挡关系擦掉多余的线，再把没接上的地方接上，就已经很逼真了。
在画腿部形状的时候，连接处最好留出一些位置，并且大小腿也会向某个方向错开~~（不好意思我又忘掉了）~~，具体观察照片。
人体四肢的边线通常是一段曲一段直

如果你难以判断手臂或者腿的截面的俯仰关系，或者很难画出来它的透视线，那么这说明你可能不会画各个角度的圆柱体。这是绘画的基本功，应当多加练习。

观察方法

不推荐使用九宫格计算检查画面！画得一模一样没有意义。

观察方式，多点位对比。不要绝对的准确，只要相对关系准确。

比如下图，我们只要注意观察的点位与其他点位的相对位置关系正确即可。

戴手表的手腕在另一只手腕的偏左侧一点、绿色的肘部比蓝色的肩膀偏左一点、抬起的脚底面在粉色手腕的左边……人体的趋势和比例正确，重心在两腿之间，再通过许多点位快速检查位置关系，你就画出照片中的动作了。不需要一模一样。

层次关系大于体积关系

物体之间的层次关系一定要画对，哪怕不画透视只画几个矩形，也要比“层次画错的、完成度高的画”要好。

其他起稿方式

油烟管道“螺旋升天”：通过不断画圆来暗示透视线，更方便画一些比较刁钻的透视。

T字：适合常规一些的透视。找到肩线和胯线，再找到中线（或者脊柱线）。不太适合画大透视。

”势“：我理解的是一种 gesture drawing，先忽略具体的透视和形状，去感受整个人体的走势，用线画出来，一般比较奔放粗犷，动感很强，是我喜欢的风格。根据“势”可以更方便地做出夸张。

众多起稿方式都很不错，不能评判孰优孰劣，也可以混合使用或者互相检查。只有在合适的场景使用它们才能发挥最大作用。

重要绘画小技巧

参考图不需要很清晰，甚至很模糊更好。画速写看的是整体关系，不需要看细节，关注细节只会影响整体的观察和绘画进度。
不用在意胸腔和盆腔的连接，大致的比例和位置对了，直接用线连上即可。因为腹部都是软的肉，本身就可以变形，只要不是太离谱都说的过去。
膝盖方向通常和脚尖方向一致
在画手腕时，最好留一个”护腕（手表）“的位置，这是一个好习惯
画手其实和画人物整体的方式一样，先画手掌「方形」平面，然后手指使用宽度相当的色块起稿，最后勾线时手指当作2节来画。大拇指需要先在手掌一侧加一个三角形，再加一节大拇指。
画脚时先画脚的两个底面（圆形），然后再和脚踝连接
宁脏勿净，多画结构素描，虽然画完不能当作作品，但是可以练到超级多的东西。要敢于去画，不要担心画错，只有参考一条错的线，才可能画出一条更正确的线，所以一开始肯定画的线没有一条是正确的。少按撤回键，多用橡皮。把透明度调低调出一个软一些的橡皮轻轻擦，在它的基础上修正虽然画面可能脏脏的，但是结构全都画清晰了，干净的线可能很难有这种练习的效果。

其他思考

筛选好老师，会教课的老师，不要听垃圾课浪费时间。每个老师教的都有特色，但也有局限性，会有一点“偏见”和糟粕。不能只跟一个老师学，他说的答案不一定是最优解，也有可能是一条歧路，可能会对自己产生误导。要多听其他老师的课，多听其他绘画观点。

例如大毛和 krenz 的某些观点会有冲突，因此听绘画课需要多思考。

同时我感觉到这些教的很好的老师，学生太多，于是有了很多饭圈化粉丝学生。我觉得这对学画来说不是一件好事情吧。

最后，感谢你看到这里，祝你越画越好🥰。

Go数组及相关算法（上）

Kiramux — Tue, 16 Sep 2025 00:00:00 GMT

对 Go 数组和相关算法进行了学习，并做了笔记。相关链接：代码随想录

Go 数组

定义相关

数组是存放在连续内存空间上的相同类型数据的集合。

数组是具有相同类型的一组已编号且长度固定的数据项序列。这种类型可以是任意的原始类型（int、string或者自定义类型）。

数组元素可以通过索引来读取或修改。

数组定义： var a [len]int，例如 var a [5]int

数组的大小len必须是常量，且是类型的组成部分（数组的类型不仅由 元素类型 决定，还由长度决定，例如[5]int 和 [10]int 是 两种完全不同的类型）。

数组大小一旦定义后不可变。

内置函数 len 和 cap 都会返回数组大小

需要注意：

数组的下标都是从0开始的
数组内存空间的地址是连续的

正是因为数组在内存空间的地址是连续的，所以在“删除”元素时需要移动其他元素的地址。数组的元素不能删，只能覆盖。

遍历数组：

    for i := 0; i < len(a); i++ {
        //...
    }
    for index, v := range a {
        //...
    }

访问越界，如果下标在数组合法范围之外，则触发访问越界，会panic

数组是值类型，赋值和传参会复制整个数组，而不是指针。因此改变副本的值，不会改变本身的值。

值拷贝会出现性能问题，通常会使用 slice 或数组指针。

Go 数组支持 "=="、"!=" 操作符，因为数组是值类型，内存总是被初始化为对应类型的0值。

指针数组 [n]*T，数组指针 *[n]T 。

数组的初始化

// 全局:
var numbers [5]int //初始值为0
var arr0[5]int = [5]int{1, 2, 3}
var arr1 = [5]int{1, 2, 3, 4, 5}	// 使用初始化列表来初始化数组的元素
var arr2 = [...]int{1, 2, 3, 4, 5, 6}	// 数组长度不确定，使用...代替数组长度，编译器会根据元素个数自行推断数组长度
var str = [5]string{3: "hello world", 4: "kira"}	// 如果设置了数组长度，可以通过指定下标来初始化元素

// 局部:
a := [3]int{1, 2}	// 未初始化的元素值为0
b := [...]int{1, 2, 3, 4}	// 通过初始化值来确定数组长度
c := [5]int{2:100, 4:200}	// 使用下标来初始化元素
d := [...]struct {
    name string
    age string
    // 这里是数组元素类型struct
}{
    {"user1", 10},
    {"user2", 20},	// 2个元素
}

Go 向函数中传递数组

Go 语言中的数组是值类型，因此将数组传递给函数时，实际上传递的是数组的副本。

向函数传递数组参数，需要在函数定义时声明形参为数组。

func aFunc(arr [10]int) {
    ...
}
// 或者
func bFunc(arr []int) {
    ...
}

如果想要在函数内修改原始数组，需要传递数组的指针

package main

import "fmt"

// 函数接受一个数组作为参数
func modifyArray(arr [5]int) {
    for i := 0; i < len(arr); i++ {
        arr[i] = arr[i] * 2
    }
}

// 函数接受一个数组的指针作为参数
func modifyArrayWithPointer(arr *[5]int) {
    for i := 0; i < len(*arr); i++ {
        (*arr)[i] = (*arr)[i] * 2
    }
}

func main() {
    // 创建一个包含5个元素的整数数组
    myArray := [5]int{1, 2, 3, 4, 5}

    fmt.Println("Original Array:", myArray)

    // 传递数组给函数，但不会修改原始数组的值
    modifyArray(myArray)
    fmt.Println("Array after modifyArray:", myArray)

    // 传递数组的指针给函数，可以修改原始数组的值
    modifyArrayWithPointer(&myArray)
    fmt.Println("Array after modifyArrayWithPointer:", myArray)
}

输出结果

Original Array: [1 2 3 4 5]
Array after modifyArray: [1 2 3 4 5]
Array after modifyArrayWithPointer: [2 4 6 8 10]

多维数组

一个二维数组 a 为三行四列，二维数组中的元素可通过 a[ i ][ j ] 来访问。

    // 全局
    var arr0 [5][3]int
    var arr1 [2][3]int = [...][3]int{{1, 2, 3}, {7, 8, 9}}
    // 局部
    a := [3][4]int{  
        {0, 1, 2, 3} ,   /*  第一行索引为 0 */
        {4, 5, 6, 7} ,   /*  第二行索引为 1 */
        {8, 9, 10, 11},   /* 第三行索引为 2 */
    }
    b := [...][2]int{{1, 1}, {2, 2}, {3, 3}} // 第 2 纬度不能用 "..."。

多维数组遍历

package main

import (
    "fmt"
)

func main() {

    var f [2][3]int = [...][3]int{{1, 2, 3}, {7, 8, 9}}

    for k1, v1 := range f {
        for k2, v2 := range v1 {
            fmt.Printf("(%d,%d)=%d ", k1, k2, v2)
        }
        fmt.Println()
    }
}

输出结果

    (0,0)=1 (0,1)=2 (0,2)=3 
    (1,0)=7 (1,1)=8 (1,2)=9

704.二分查找

704. 二分查找

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果 target 存在返回下标，否则返回 -1。

你必须编写一个具有 O(log n) 时间复杂度的算法。

示例 1:
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
示例 2:
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1
提示：

你可以假设 nums 中的所有元素是不重复的。

n 将在 [1, 10000]之间。

nums 的每个元素都将在 [-9999, 9999]之间。

使用二分查找的前提：有序数组；无重复元素。

边界处理是重要问题。

主流写法有2类，左闭右闭[left, right]和左闭右开[left, right)。

左闭右闭区间`[left, right]`

x >> n相当于除以 2^n 并向下取整。

mid := left + (right-left)>>1是常见的二分中点写法，直接相加除以二可能会导致数值溢出。

left := 0

right := len(num) - 1

*判断 left < right 时有没有=，需要看区间[left, right]。

左闭右闭，left == right 在这个区间内有意义，所以需要 <=

*更新区间边界，以下是伪代码

if num[mid] == target

return mid

else if num[mid] > target

更新右边界，如下图所示。因为区间[left, right]右闭包含 right，并且上面的判断条件 mid ！= target，所以

right = mid - 1 。

else // num[mid] < target

更新左边界，左闭包含 left，left != target，所以

left = mid + 1

func search(nums []int, target int) int {
    // 左闭右闭 [left, right]
    // 初始化左右边界
    left := 0
    right := len(nums) - 1

    for left <= right {
        mid := left + (right - left) >> 1
        if nums[mid] == target {
            return mid
        } else if nums[mid] < target {
            // 更新左边界，mid 不是 target，所以left应该为 mid+1
            left = mid + 1
        } else {
            // 更新右边界， mid > targer,所以right 应该为 mid-1 
            right = mid - 1
        }
    }
    return -1
}

左闭右开区间`[left, right)`

left := 0

right := len(num)

由于右开， right 应当是数组元素综述+1才不会漏元素

*条件判断时，left < right ，因为 left == right 在区间[left, right)中没有意义。

*更新区间边界

if num[mid] == target

return mid

else if num[mid] > target

更新右边界。num[mid] != target，又因为右开，所以

right = mid

else // num[mid] < target

更新左边界，因为左闭，应当包含边界，而 num[mid] != target 所以

left = mid + 1

func search(nums []int, target int) int {
    // 左闭右开 [left, right)
    // 初始化左右边界
    left := 0
    right := len(nums)

    for left < right {
        mid := left + (right - left) >> 1
        if nums[mid] == target {
            return mid
        } else if nums[mid] < target {
            // 更新左边界，mid 不是 target，所以left应该为 mid+1
            left = mid + 1
        } else {
            // 更新右边界， mid > targer,所以right 应该为 mid-1 
            right = mid
        }
    }
    return -1
}

遗留：什么是循环不变量？

27. 移除元素

27. 移除元素

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。

假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：

更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。

返回 k。

用户评测：

评测机将使用以下代码测试您的解决方案：
int[] nums = [...]; // 输入数组
int val = ...; // 要移除的值
int[] expectedNums = [...]; // 长度正确的预期答案。
 // 它以不等于 val 的值排序。

int k = removeElement(nums, val); // 调用你的实现

assert k == expectedNums.length;
sort(nums, 0, k); // 排序 nums 的前 k 个元素
for (int i = 0; i < actualLength; i++) {
 assert nums[i] == expectedNums[i];
}
如果所有的断言都通过，你的解决方案将会通过。

示例 1：
输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2,_,_]
解释：你的函数函数应该返回 k = 2, 并且 nums 中的前两个元素均为 2。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。
示例 2：
输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3,_,_,_]
解释：你的函数应该返回 k = 5，并且 nums 中的前五个元素为 0,0,1,3,4。
注意这五个元素可以任意顺序返回。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。
提示：

0 <= nums.length <= 100

0 <= nums[i] <= 50

0 <= val <= 100

暴力解法

时间复杂度是O(n^2)

两层 for 循环，一个for循环遍历数组元素，第二个for循环更新数组。

一旦第一层 for 循环找到 val ，就用其后面的元素把它往前一位覆盖掉，并且数组大小 len-1

func removeElement(nums []int, val int) int {
    len := len(nums)
    for i := 0; i < len; i++ {
        if nums[i] == val {
            for j := i + 1; j < len; j++ {
                nums[j-1] = nums[j]
            }
            i--
            len--
        }
    }
    return len
}

快慢指针法

时间复杂度：O(n)；空间复杂度：O(1)

没有改变元素的相对位置

快指针：寻找新数组元素（非val的元素）
慢指针：指向要更新的元素，新数组的下标。

快指针一旦找到新数组元素，就更新慢指针的元素，直到找完就得到了全部是非 val 元素的新数组。

slowIndex 刚好就是新数组大小。

func removeElement(nums []int, val int) int {
    var slowIndex int = 0
    len := len(nums)
    for fastIndex := 0; fastIndex < len ; fastIndex++ {
        if nums[fastIndex] != val {
            nums[slowIndex] = nums[fastIndex]
            slowIndex++
        }
    }
    return slowIndex
}

双向指针法

有点像二分查找，这里按照左闭右闭来写。

双向指针法，left找 val，right找非 val，一旦都找到，就 nums[left] = nums[right] 随后 left++ ; right-- (都向中间靠拢) 当 left > right 时，说明left左侧没有 val，left 指针左侧即是最终的数组，left 就是数组大小。

过程：

func removeElement(nums []int, val int) int {
    left := 0
    right := len(nums) - 1
    // 左闭右闭区间，所以是 <=
    for left <= right {
        // 寻找左侧val，找到退出循环
        for left <= right && nums[left] != val {
            left++
        }
        // 寻找右侧非val，找到退出循环
        for left <= right && nums[right] == val {
            right--
        }
        // 各自都找到后开始覆盖
        if left < right {
            nums[left] = nums[right]
            left++
            right--
        }
    }
    return left
}

977.有序数组的平方

977. 有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：
输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]
示例 2：
输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]
提示：

1 <= nums.length <= 104

-104 <= nums[i] <= 104

nums 已按 非递减顺序 排序

进阶：

请你设计时间复杂度为 O(n) 的算法解决本问题

暴力解法直接平方排序

O(n + nlogn) 或是 O(nlogn)

func sortedSquares(nums []int) []int {
    for i, val := range(nums) {
        nums[i] *= val 
    }
    sort.Ints(nums)
    return nums
}

双指针法

O(n)

数组是有序的，平方之后的数组，最大的数分别在两端，越往中间越小。

创建新数组 ans，以及k（数组的最大下标）。

两端的下标 left, right（左闭右闭）。nums[left]^2 和 nums[right]^2 做比较。

大的填入 ans[k]，然后大的指针--，k--，另一个不动留着下一次比较。即：

如果A[i] * A[i] < A[j] * A[j] 那么ans[k--] = A[j] * A[j]; j--。

如果A[i] * A[i] >= A[j] * A[j] 那么ans[k--] = A[i] * A[i]; i++。

下图在最后应该是 i 和 j 相等，都到元素0再判断平方大小，动画可能少了一张图。

func sortedSquares(nums []int) []int {
    len := len(nums)
    var left, right, k int = 0, len-1, len-1
    ans := make([]int, len)
    for left <= right {
        lsq, rsq := nums[left]*nums[left], nums[right]*nums[right]
        if lsq > rsq {
            left++
            ans[k] = lsq
            k--
        } else {
            right--
            ans[k] = rsq
            k--
        }
    }
    return ans
}

Go数组及相关算法（下）+ Go 基础笔记

Kiramux — Wed, 17 Sep 2025 00:00:00 GMT

对 Go 数组和相关算法继续学习，并做了笔记。做了一部分 Go 基础的笔记。相关链接：代码随想录

Go 基础笔记

Go 思想：Less can be more.

Go 优点

自带 gc
静态编译，编译好后，扔服务器直接运行
简单的思想，没有继承、多态、类等
丰富的库和详细的开发文档
语法层支持并发，和拥有同步并发的 channel 类型，使并发开发变得非常方便
简洁的语法、提高开发效率，同时提高代码的阅读性和可维护性
超级简单的交叉编译，仅需更改环境变量

Go 语言的主要特性：

自动立即回收
更丰富的内置类型
函数多返回值
错误处理
匿名函数和闭包
类型和接口
并发编程
反射
语言交互性

Go 基本类型

置顶变量类型，如果没有初始化，则变量默认为零值。

各种类型各自的零值

类型	长度（字节）	默认值	说明
bool	1	false	无法参与数值运算，无法转换为其他类型，也不允许将整型强制转为 bool
byte	1	0	byt e是 uint8 的别名
rune	4	0	Unicode Code Point, 底层是 int32
int, uint	4或8	0	32位或64位
int8, uint8	1	0	-128~127; 0~255; uint8->byte
int16, uint16	2	0	-32768~32767; 0~65535
int32, uint32	4	0	-21亿~21亿; 0~42亿; rune 是 int32 的别名
int64, uint64	8	0
float32	4	0.0
float64	8	0.0
complex64	8		实部和虚部为32位
complex128	16		实部和虚部为64位
uintptr	4或8		用以存储指针的 uint32 或 uint64 整数
array			值类型
struct			值类型
string		“”（空字符串）	UTF-8字符串
slice		nil	引用类型
map		nil	引用类型
channel		nil	引用类型
interface		nil	接口
function		nil	函数

值类型

值类型是指变量直接存储了实际的数据，并且每个变量都拥有独立的存储空间。当一个值类型的变量被复制给另一个变量时，会进行值拷贝。对其中一个变量的修改不会影响到原始变量。

Go 中值类型包含：整型、浮点型、复数、布尔型、字符串型、数组、结构体

值类型有以下特点：

直接存储值，不存储地址
变量间赋值时、作为参数传递时进行值复制
值类型的变量副本是独立的，修改一个变量的副本不会影响另一个
值类型通常在栈上分配，除非是通过 new 函数分配的，或者是作为闭包中的变量被分配到堆上。

引用类型

引用类型并不直接存储数据本身，而是存储指向数据的指针。

当复制一个引用类型的变量时，复制的是指针，新旧变量指向的是相同的底层数据。

Go 中的引用类型包含：

切片 slice ：切片是对数组的封装。当修改切片中的元素时，实际上是在修改底层数组的相应元素
映射 map ：将 map 传递给一个函数、赋值给一个变量时，任何对映射的修改都会反映在所有引用了这个 map 的地方
通道 channel
接口 interface ：接口类型是一种抽象类型，定义了一组方法，但不会实现这些方法。接口内部存储的是指向实现了接口方法的值的指针和指向该类型信息的指针
函数 function ：当把一个函数赋给另一个变量时，实际上是在复制一个指向该函数的引用。

引用类型有以下特点：

存储的是指向该数据的地址，而不是数据本身
当引用类型的变量被赋值或作为函数参数传递时，实际上是将该地址复制一份，因此多个变量可能共享同一份数据
引用类型的数据通常在堆上分配，即使变量本身在栈上
引用类型的零值是 nil ，一个未初始化的引用类型的变量值是 nil ，不指向任何内存地址。

整型

uint8 对应 byte

int16 对应 C 中的 short

int64 对应 C 中的 long

int 和 uint 的长度自动根据平台大小调整（uintptr: 用于存储指针值的无符号整型）

字符串

定义多行字符串，使用反引号

    s1 := `第一行
    第二行
    第三行
    `
    fmt.Println(s1)

反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。

字符串常见操作

方法	说明
len(str)	求长度
+ 或 fmt.Sprintf	拼接字符串
strings.Split	分割
strings.Contains	判断是否包含
strings.HasPrefix, strings.HasSuffix	前缀/后缀判断
strings.Index(), strings.LastIndex()	子串出现的位置
strings.Join(a[]string, sep string)	join 操作

byte和rune类型

组成每个字符串的元素叫做“字符”，可以通过遍历或者获取单个字符串元素获得字符。字符用单引号'包裹起来，如：

var a := '中
var b := 'x

Go 语言的字符有两种

uint8 类型，或者叫 byte 型，代表了 ASCII 码的一个字符
rune 类型，代表一个 UTF-8 字符

当需要处理中文、日文或者其他复合字符时，则需要用到 rune 类型。rune 类型实际上是一个int32。

Go 使用了特殊的 rune 类型来处理 Unicode，让基于 Unicode 的文本处理更为方便，也可以使用 byte 型进行默认字符串处理。

    // 遍历字符串
    func traversalString() {
        s := "pprof.cn博客"
        for i := 0; i < len(s); i++ { //byte
            fmt.Printf("%v(%c) ", s[i], s[i])
        }
        fmt.Println()
        for _, r := range s { //rune
            fmt.Printf("%v(%c) ", r, r)
        }
        fmt.Println()
    }

输出：

112(p) 112(p) 114(r) 111(o) 102(f) 46(.) 99(c) 110(n) 229(å) 141() 154() 229(å) 174(®) 162(¢)
112(p) 112(p) 114(r) 111(o) 102(f) 46(.) 99(c) 110(n) 21338(博) 23458(客)

for i := 0; i < len(s); i++ { //byte } 是以字节为单位遍历的。

for range 是以 Unicode 码点（rune）遍历字符串的。

字符串底层是一个 byte 数组，所以可以和 []byte 类型相互转换。字符串是不能直接修改的。

字符串有 byte 字节组成，所以 len(s) 是 byte 字节的长度。

rune 类型用来表示 UTF-8 字符。因为 UTF-8 编码下，一个中文由 3~4 个字节组成，所以不能按照字节去遍历一个包含中文的字符串，否则就会出现上面输出中第一行的结果。

修改字符串

要修改字符串，需要将其先转成 []rune 或 []byte ，完成后再转换为 string 。无论哪种转换，都会重新分配内存，并复制字节数组。

    func changeString() {
        s1 := "hello"
        // 强制类型转换
        byteS1 := []byte(s1)
        byteS1[0] = 'H'
        fmt.Println(string(byteS1))

        s2 := "博客"
        runeS2 := []rune(s2)
        runeS2[0] = '狗'
        fmt.Println(string(runeS2))
    }

Go 变量声明

Go 声明可见性

声明在函数内部，是函数的本地值，类似 private
声明在函数外部，是对当前包可见（包内所有 .go 文件都可见）的全局值，类似 protect
声明在函数外部且首字母大写是所有包可见的全局值，类似 public

Go 语言在声明变量的时候，会自动对变量对应的内存区域进行初始化操作。每个变量会被初始化成其类型的默认值。（参考上文的类型表格）

不同声明方法

var name string

// 声明时初始化
var name2 string = "kiramux"
var num int = 1

// 批量声明
var (
    a string
    b int
    c bool
    d float32
)

// 批量声明+初始化
var (
    color string = "blue"
    x int = 10
    is_X bool = true
)

// 类型推导
var domain = "kiramux.com"

// 一次初始化多个变量
var name3, y = "kiramux", 1

// ---
// 全局变量m
var m = 100

// 函数内部的短变量声明
func main() {
    n := 10
    m := 100 // 此处声明局部变量m
    
}

在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量，用下划线_表示。

for _, val := range nums {
    // ...
}

匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。

注意：

函数外的每个语句都必须以关键字开始（var、const、func 等）
:= 不能在函数外使用
_ 多用于占位，表示忽略值

Go 下划线

下划线在 import 中

在导入一个包时，该包下的文件里所有的 init() 函数都会被执行。

当我们仅希望它执行 init() 函数，不需要把整个包都倒进来，就可以用 import 引入该包。即 import _ 包路径 只是引用该包，仅仅为了调用 init() 函数，所以无法通过包名来调用包中的其他函数。例如：

代码结构
    src 
    |
    +--- main.go            
    |
    +--- hello
           |
            +--- hello.go

package main

import _ "./hello"

func main() {
    // hello.Print() 
    // 启用上一行代码会编译报错：./main.go:6:5: undefined: hello
}

hello.go

package hello

import "fmt"

func init() {
    fmt.Println("imp-init() come here.")
}

func Print() {
    fmt.Println("Hello!")
}

输出结果

    imp-init() come here.

init 函数和 main 函数

init 函数

init 函数是用于程序执行前做包的初始化的函数，比如初始化包里的变量等
每个包可以有多个 init 函数
包的每个源文件也可以拥有多个 init 函数
同一个包中多个 init 函数的执行顺序 go 语言没有明确的定义（说明）
不同包的 init 函数按照包导入的依赖关系决定该初始化函数的执行顺序
init 函数不能被其他函数调用，而会在 main 函数执行之前自动被调用

init 函数和 main 函数的异同

相同点：

两个函数在定义时不能有任何的参数和返回值，且 Go 程序自动调用。

不同点：

init 可以应用于任意包中，且可以重复定义多个。

main 函数只能用于 main 包中，且只能定义一个。

init 函数和 main 函数的执行顺序

对同一个 go 文件的 init 函数调用顺序是从上到下的。

对同一个 package 中不同文件是按照文件名字符串比较“从小到大”顺序调用各文件中的 init 函数

对于不同的 package ，如果不相互依赖的话，按照 main 包中“先 import 后调用其包中的 init 函数”。如果 package 存在依赖，则先调用最早被依赖的 package 中的 init 函数。

最后调用 main 函数。

如果 init 函数中使用了 println() 或者 print() ，会发现在执行过程中二者不会按照想象中的顺序执行。

这两个函数官方只推荐在测试环境中使用，在正式环境不要使用。

Go 类型别名和自定义类型

自定义类型

Go 中有整型、string 等基本的数据类型，可以使用 type 关键字来自定义类型。

自定义类型是一个全新的类型。可以基于内置的基本类型定义，也可以通过 struct 定义

    //将MyInt定义为int类型
    type MyInt int

MyInt 就是一种新类型，它具有 int 的特性。

类型别名

TypeAlias 只是 Type 的别名，本质上两者是同一个类型。

就像一个人小时候有小名、乳名、中文名、英文名，但这些名字都是指它一个人。

    type TypeAlias = Type

    // rune和byte就是类型别名
    type byte = uint8
    type rune = int32

类型定义和类型别名的区别

//类型定义
type NewInt int

//类型别名
type MyInt = int

func main() {
    var a NewInt
    var b MyInt

    fmt.Printf("type of a:%T\n", a) //type of a:main.NewInt
    fmt.Printf("type of b:%T\n", b) //type of b:int
}

结果显示

a 的类型是 main.NewInt ，表示 main 包下定义的 NewInt 类型；

b 的类型是 Int 。MyInt 类型只会在代码中存在，编译完成时并不会有 MyInt 类型。

如果怕记错的话，想一想 struct 的定义， struct 就是一种新类型

type cats struct {
    name string
    age int
}

209.长度最小的子数组

209. 长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其总和大于等于 target 的长度最小的 子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度**。**如果不存在符合条件的子数组，返回 0 。

示例 1：
输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
示例 2：
输入：target = 4, nums = [1,4,4]
输出：1
示例 3：
输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0
提示：

1 <= target <= 109

1 <= nums.length <= 105

1 <= nums[i] <= 104

进阶：

如果你已经实现 O(n) 时间复杂度的解法, 请尝试设计一个 O(n log(n)) 时间复杂度的解法。

暴力解法（力扣超时）

时间复杂度：O(n^2)

直接遍历所有子数组，寻找符合条件的情况。

相当于 i 是头， j 是尾。

func minSubArrayLen(target int, nums []int) int {
    len := len(nums)
    var sum int = 0
    var result int = len + 1
    for i := 0; i < len; i++ {
        sum = 0
        for j := i; j < len; j++ {
            sum += nums[j]
            if sum >= target {
                subLen := j - i + 1
                if subLen < result {
                    result = subLen
                break
                } 
            }
        }
    }
    if result == len + 1 {
        return 0
    } else {
        return result
    }
}

滑动窗口法

时间复杂度：O(n)
空间复杂度：O(1)

所谓滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们想要的结果。

也可以理解成一种双指针法。

在暴力解法中，是一个for循环滑动窗口的起始位置，一个for循环为滑动窗口的终止位置，用两个for循环完成了一个不断搜索区间的过程。

尝试使用一个 for 循环：

以题目中的示例来举例，target=7，数组是 2，3，1，2，4，3，查找过程：

最后找到 4，3 是最短距离。

j代表滑动窗口的“尾”，先找到总和大于 target 的子数组，再移动头部缩小子数组。

如果 j 代表起始位置的话，就和暴力解法没区别了。

func minSubArrayLen(target int, nums []int) int {
    len := len(nums)
    var sum int = 0
    var result int = len + 1
    i := 0

    // j 是滑动窗口的终止位置，如果代表起始位置的话，和暴力解法没区别
    for j := 0; j < len; j++ {
        sum += nums[j]
        for sum >= target {
            subLen := j - i + 1 // 求长度所以+1 
            if subLen < result {
                result = subLen
            }
            // 起始位置移动
            sum -= nums[i]
            i++
        }
    }

    if result == len + 1 {
        return 0
    } else {
        return result
    }
}

本题实现滑动窗口，主要确定以下三点：

窗口内的是什么？
如何移动窗口的初始位置？
如何移动窗口的结束位置？

本题的窗口：满足其和≥target 的最小的连续子数组；

本题的起始位置如何移动：如果当前窗口的值≥target ，窗口就要向右移动了（窗口该缩小了）；

本题的终止位置如何移动：窗口的结束位置就是数组的遍历指针，也就是 for 循环中的索引。

解题的关键在于，窗口的起始位置如何移动：

滑动窗口的精妙之处在于：根据当前子序列和大小的情况，不断调整子序列的起始位置，从而将O(n^2)暴力解法降为O(n)。

**时间复杂度是O(n)**的原因：

不是两个 for 循环嵌套就是O(n^2)，主要看每个元素被操作的次数。

每个元素在滑动窗口进来操作一次，出去操作一次，每个元素都是被操作两次。所以时间复杂度是 2*n 也就是 O(n)。

59.螺旋矩阵II

循环不变量1

模拟顺时针画矩阵的过程:

填充上行从左到右
填充右列从上到下
填充下行从右到左
填充左列从下到上

可以发现这里的边界条件非常之多，在一个循环中，如此多的边界条件，如果不按照固定的规则来遍历，上来就i:=固定值。那么就是 一进循环深似海，从此offer是路人。

方法1: 每一边都坚持左闭右开原则*（或者左开右闭原则）*

每一个拐角处都不处理，交给下一条边来处理。

圈数 loop == n / 2，如果n是奇数，那么就把中间的值赋值 n*n 即可。

定好每一行开始的位置和结束的位置，每完成一圈，offset++

func generateMatrix(n int) [][]int {
    var (
        loop = n / 2
        startx = 0
        starty = 0
        offset = 1
        counter = 1
    )

    var nums = make([][]int, n)
    for i := 0; i < n; i++ {
        nums[i] = make([]int, n)
    }
    for loop > 0 {
        i,j  := startx, starty
        for j = starty; j < n - offset; j++ {
            nums[startx][j] = counter
            counter++
        }
        for i = startx; i< n - offset; i++ {
            nums[i][j] = counter
            counter++
        }
        for ;j > starty; j-- {
            nums[i][j] = counter
            counter++
        }
        for ;i > startx; i-- {
            nums[i][starty] = counter
            counter++
        }
        loop--
        startx++
        starty++
        offset++
    }
    if n % 2 == 1 {
    nums[n/2][n/2] = n*n 
    }
    return nums
}

循环不变量2

这个思路是：规定未处理的范围 left, right, top, bottom, 坚持左闭右闭原则。

每处理完一条边，就把未处理的范围减去一条边，明确下一条边要处理的范围。例如处理完红色的第一行，那么就top++。

这个思路优点是代码简单，思路容易想到。缺点是每一条边的具体操作不一致，可能会容易出错。

func generateMatrix(n int) [][]int {
    left, right := 0, n-1
    top, bottom := 0, n-1
    counter := 1
    tar := n * n

    var matrix = make([][]int, n)
    for i := 0; i < n; i++ {
        matrix[i] = make([]int, n)
    }

    for counter <= tar {
        for i := left; i <= right; i++ {
            matrix[top][i] = counter
            counter++
        }
        top++
        for i := top; i <= bottom; i++ {
            matrix[i][right] = counter
            counter++
        }
        right--
        for i := right; i >= left; i-- {
            matrix[bottom][i] = counter
            counter++
        }
        bottom--
        for i := bottom; i >= top; i-- {
            matrix[i][left] = counter
            counter++
        }
        left++
    }

    return matrix
}

链表算法（1）

Kiramux — Thu, 18 Sep 2025 00:00:00 GMT

对 Go 链表相关算法继续学习，并做了笔记。相关链接：代码随想录

203.移除链表元素

203. 移除链表元素

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

示例 1：
输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]
示例 2：
输入：head = [], val = 1
输出：[]
示例 3：
输入：head = [7,7,7,7], val = 7
输出：[]
提示：

列表中的节点数目在范围 [0, 104] 内

1 <= Node.val <= 50

0 <= val <= 50

使用原链表（力扣超时）

这里以链表 1 4 2 4 来举例，移除元素4。

如果首元节点的值就是要移除的值，例如 head = [7,7,7,7,6], val = 7

直接移除首元节点

for head != nil && head.Val == val {

head = head.Next

}

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func removeElements(head *ListNode, val int) *ListNode {
    // 先删除含 val 的首元节点，可能有多个所以循环
    for head != nil && head.Val == val{// head.Next != nil 不用考虑，因为最后一个节点就是指向nil的
            // head 指向下一个节点，相当于删除了原来的首元节点
            head = head.Next
    }

    // struct(节点)是值类型，传递的是副本
    cur := head
    for cur != nil && cur.Next != nil {
        if cur.Next.Val == val {
            cur.Next = head.Next.Next
        } else {
            cur = cur.Next
        }
    }
    return head
}

虚拟头结点

第一种方法中，移除首元节点和移除之后节点的方法不同。

如果添加一个虚拟头结点，那么对节点的移除操作就一致了。

最后 return dummyHead.Next

func removeElements(head *ListNode, val int) *ListNode {
    dummyHead := &ListNode{}
    dummyHead.Next = head

    cur := dummyHead
    for cur != nil && cur.Next != nil {
        if cur.Next.Val == val {
            cur.Next = cur.Next.Next
        } else {
            cur = cur.Next
        }
    }
    return dummyHead.Next
}

递归（未完成）

java思路

/**
 * 时间复杂度 O(n)
 * 空间复杂度 O(n)
 * @param head
 * @param val
 * @return
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if (head == null) {
            return head;
        }

        // 假设 removeElements() 返回后面完整的已经去掉val节点的子链表
        // 在当前递归层用当前节点接住后面的子链表
        // 随后判断当前层的node是否需要被删除，如果是，就返回
        // 也可以先判断是否需要删除当前node，但是这样条件语句会比较不好想
        head.next = removeElements(head.next, val);
        if (head.val == val) {
            return head.next;
        }
        return head;

        // 实际上就是还原一个从尾部开始重新构建链表的过程
    }
}

707.设计链表

707. 设计链表

中等

你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

MyLinkedList() 初始化 MyLinkedList 对象。

int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。

void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。

void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。

void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。

void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

示例：
输入
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]

解释
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2); // 链表变为 1->2->3
myLinkedList.get(1); // 返回 2
myLinkedList.deleteAtIndex(1); // 现在，链表变为 1->3
myLinkedList.get(1); // 返回 3
提示：

0 <= index, val <= 1000

请不要使用内置的 LinkedList 库。

调用 get、addAtHead、addAtTail、addAtIndex 和 deleteAtIndex 的次数不超过 2000 。

单链表优化

链表设计及其初始化。链表中有链表大小 Size。在实现链表操作方法的时候，不要忘记 l.Size++ 和 l.Size-- 。

type SingleNode struct {
    Val int
    Next *SingleNode
}

type MyLinkedList struct {
    DummyHead *SingleNode
    Size int
}

func Constructor() MyLinkedList {
    NewDummyHead := &SingleNode {
        Val: -1,
        Next: nil,
    }

    return MyLinkedList{
        DummyHead: NewDummyHead,
        Size: 0,
    }
}

具体对链表的操作均使用虚拟头结点的方法，具体思路看下面。

一开始只觉得删除节点可以用这个思想，其他方法的思路都是梦到哪写哪，写的很糟糕。

针对自己写的版本的一些优化：

遍历链表优化：

只遍历到 index 即可。这时 cur 到达 index 的前一个节点。

如果不确定范围对不对，可以代入极端情况，例如 index = 0 的情况。具体看第三点。
```
 for i := 0; i < index; i++ {
 cur = cur.Next
 }
```

对 index 是否合法的判断也进行了优化。

之前自己写的时候，总想把 插入到 index 前 和插入到末尾的情况单独讨论，分别调用 AddAtHead() 和 AddAtTail 。但实际上可以整合到一起处理。

func (l *MyLinkedList) AddAtIndex(index int, val int)  {
    if index < 0 {
        index = 0
    } else if index > l.Size {// 题中 index == l.Size 会将该节点添加到链表末尾，所以是 l.Size 不是 l.Size -
        return
    }
    newNode := &SingleNode{Val: val}
    cur := l.DummyHead
    // cur 指向 index 的前一个节点
    for i := 0; i < index; i++ {
        cur = cur.Next
    }
    newNode.Next = cur.Next
    cur.Next = newNode
    l.Size++
}

统一使用虚拟头结点的思想，规范了变量名。如上面的代码所示。

统一遍历到 cur 指向 index 的前一个节点，然后通过 cur 进行操作。

例如下图的 AddAtIndex() 操作

这时 cur 已经指向了 index 的前一个节点，接下来只要添加节点就好了。

添加节点时， newNode 先指向 indexNode ，cur 再指向 newNode 。如果搞反了，后面的节点就丢失了。

如果不知道这么遍历对不对，可以代入极端情况，例如 index = 0 的情况。

index == 0，不进入循环。cur = DemmyHead

完整代码：

type SingleNode struct {
    Val int
    Next *SingleNode
}

type MyLinkedList struct {
    DummyHead *SingleNode
    Size int
}


func Constructor() MyLinkedList {
    NewDummyHead := &SingleNode {
        Val: -1,
        Next: nil,
    }

    return MyLinkedList{
        DummyHead: NewDummyHead,
        Size: 0,
    }
}


func (l *MyLinkedList) Get(index int) int {
    if l.Size < 1 {
        return -1
    } 
    if l == nil || index > l.Size - 1 || index < 0 {// 加上了 l == nil 的判断
        return -1
    } else {
        cur := l.DummyHead.Next
        for i := 0; i < index; i++ {
            cur = cur.Next
        }
        return cur.Val
    }
    return -1
}


func (l *MyLinkedList) AddAtHead(val int)  {
    newNode := &SingleNode{Val: val}
    newNode.Next = l.DummyHead.Next
    l.DummyHead.Next = newNode
    l.Size++
}


func (l *MyLinkedList) AddAtTail(val int)  {
    newNode := &SingleNode{Val: val}
    cur := l.DummyHead
    for cur.Next != nil {// 遍历到最后一个节点
        cur = cur.Next
    }
    newNode.Next = cur.Next
    cur.Next = newNode
    l.Size++
}


func (l *MyLinkedList) AddAtIndex(index int, val int)  {
    if index < 0 {
        index = 0
    } else if index > l.Size {// 题中 index == l.Size 会将该节点添加到链表末尾，所以是 l.Size 不是 l.Size -
        return
    }
    newNode := &SingleNode{Val: val}
    cur := l.DummyHead
    // cur 指向 index 的前一个节点
    for i := 0; i < index; i++ {
        cur = cur.Next
    }
    newNode.Next = cur.Next
    cur.Next = newNode
    l.Size++
}


func (l *MyLinkedList) DeleteAtIndex(index int)  {
    if index < 0 || index > l.Size - 1 {
        return
    }
    cur := l.DummyHead
    // 遍历到 index 的前一个节点
    for i := 0; i < index; i++ {
        cur = cur.Next
    }
    if cur.Next != nil {
        cur.Next = cur.Next.Next // 当前节点直接指向下下个节点，即删除了下一个节点
        l.Size--
    } else { // 链表中没有节点，DummyHead.Next == nil
        return
    }
}

自己思路写的单链表（烂）

思路很乱。虽然用到了虚拟头结点的思想，但是没有统一写法，每个函数想到哪写哪，逻辑不清晰，导致代码冗长。

特别体现在链表的遍历、循环边界、index合法边界上。

type SingleNode struct {
    Val int
    Next *SingleNode
}

type MyLinkedList struct {
    DummyHead *SingleNode
    Size int
}


func Constructor() MyLinkedList {
    NewDummyHead := &SingleNode {
        Val: -1,
        Next: nil,
    }

    return MyLinkedList{
        DummyHead: NewDummyHead,
        Size: 0,
    }
}


func (l *MyLinkedList) Get(index int) int {
    if l.Size < 1 {
        return -1
    } 
    if index > l.Size - 1 || index < 0 {
        return -1
    } else {
        tmpNode := l.DummyHead
        for i := 0; i < l.Size; i++ {
            tmpNode = tmpNode.Next
            if i == index {
                return tmpNode.Val
            }
        }
    }
    return -1
}


func (l *MyLinkedList) AddAtHead(val int)  {
    newNode := &SingleNode{
    Val: val,
    Next: nil,
    }
    if l.Size == 0 {
        l.DummyHead.Next = newNode
        l.Size += 1
    } else if l.Size > 0 {
        // 找到第一个节点
        originalHead := l.DummyHead.Next
        newNode.Next = originalHead
        l.DummyHead.Next = newNode
        l.Size += 1
    }
}


func (l *MyLinkedList) AddAtTail(val int)  {
    newNode := &SingleNode{
    Val: val,
    Next: nil,
    }

    if l.Size == 0 {
        l.DummyHead.Next = newNode
        l.Size += 1
    } else if l.Size > 0 {
        tmpNode := l.DummyHead
        for i := 0; i < l.Size; i++ {
            tmpNode = tmpNode.Next
        }
        tmpNode.Next = newNode
        l.Size += 1
    }
}


func (l *MyLinkedList) AddAtIndex(index int, val int)  {
    if index == 0 {
        l.AddAtHead(val)
    } else if index == l.Size {
        l.AddAtTail(val)
    }else if index > 0 && index < l.Size {
        newNode := &SingleNode{
        Val: val,
        Next: nil,
        }
        // 找到 index 下标的节点
        var prevNode *SingleNode
        indexNode := l.DummyHead
        for i := 0; i < l.Size; i++ {
            indexNode = indexNode.Next
            if i == index - 1 {
                prevNode = indexNode
            }
            if i == index {
                break
            }
        }
        // 把 newNode 插入到 indexNode 前面
        // 先把 newNode 指向 indexNode
        newNode.Next = indexNode
        // 再把 prevNode 指向 newNode
        prevNode.Next = newNode
        l.Size += 1
    } else {// 非法 index 值
        return
    }
}


func (l *MyLinkedList) DeleteAtIndex(index int)  {
    // 如何避免操作空指针？
    if l.Size < 1 {
        return
    } 
    if index == 0 {
        // 找到 indexNode, prevNode 就是 DummyHead
        // indexNode := l.DummyHead.Next
        l.DummyHead.Next = l.DummyHead.Next.Next
        l.Size -= 1
    } else if index > 0 && index <= l.Size - 1 {
        // 找到 prevNode 和 indexNode
        var prevNode *SingleNode
        indexNode := l.DummyHead
        for i := 0; i < l.Size; i++ {
            indexNode = indexNode.Next
            if i == index - 1 {
                prevNode = indexNode
            }
            if i == index {
                break
            }
        }
        prevNode.Next = indexNode.Next
        l.Size -= 1
    }
}


/**
 * Your MyLinkedList object will be instantiated and called as such:
 * obj := Constructor();
 * param_1 := obj.Get(index);
 * obj.AddAtHead(val);
 * obj.AddAtTail(val);
 * obj.AddAtIndex(index,val);
 * obj.DeleteAtIndex(index);
 */

双链表（未完成）

代码随想录上的参考代码

//循环双链表
type MyLinkedList struct {
    dummy *Node
}

type Node struct {
    Val  int
    Next *Node
    Pre  *Node
}

//仅保存哑节点，pre-> rear, next-> head
/** Initialize your data structure here. */
func Constructor() MyLinkedList {
    rear := &Node{
        Val:  -1,
        Next: nil,
        Pre:  nil,
    }
    rear.Next = rear
    rear.Pre = rear
    return MyLinkedList{rear}
}

/** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
func (this *MyLinkedList) Get(index int) int {
    head := this.dummy.Next
    //head == this, 遍历完全
    for head != this.dummy && index > 0 {
        index--
        head = head.Next
    }
    //否则, head == this, 索引无效
    if 0 != index {
        return -1
    }
    return head.Val
}

/** Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list. */
func (this *MyLinkedList) AddAtHead(val int) {
    dummy := this.dummy
    node := &Node{
        Val: val,
        //head.Next指向原头节点
        Next: dummy.Next,
        //head.Pre 指向哑节点
        Pre: dummy,
    }

    //更新原头节点
    dummy.Next.Pre = node
    //更新哑节点
    dummy.Next = node
    //以上两步不能反
}

/** Append a node of value val to the last element of the linked list. */
func (this *MyLinkedList) AddAtTail(val int) {
    dummy := this.dummy
    rear := &Node{
        Val: val,
        //rear.Next = dummy(哑节点)
        Next: dummy,
        //rear.Pre = ori_rear
        Pre: dummy.Pre,
    }

    //ori_rear.Next = rear
    dummy.Pre.Next = rear
    //update dummy
    dummy.Pre = rear
    //以上两步不能反
}

/** Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. */
func (this *MyLinkedList) AddAtIndex(index int, val int) {
    head := this.dummy.Next
    //head = MyLinkedList[index]
    for head != this.dummy && index > 0 {
        head = head.Next
        index--
    }
    if index > 0 {
        return
    }
    node := &Node{
        Val: val,
        //node.Next = MyLinkedList[index]
        Next: head,
        //node.Pre = MyLinkedList[index-1]
        Pre: head.Pre,
    }
    //MyLinkedList[index-1].Next = node
    head.Pre.Next = node
    //MyLinkedList[index].Pre = node
    head.Pre = node
    //以上两步不能反
}

/** Delete the index-th node in the linked list, if the index is valid. */
func (this *MyLinkedList) DeleteAtIndex(index int) {
    //链表为空
    if this.dummy.Next == this.dummy {
        return
    }
    head := this.dummy.Next
    //head = MyLinkedList[index]
    for head.Next != this.dummy && index > 0 {
        head = head.Next
        index--
    }
    //验证index有效
    if index == 0 {
        //MyLinkedList[index].Pre = index[index-2]
        head.Next.Pre = head.Pre
        //MyLinedList[index-2].Next = index[index]
        head.Pre.Next = head.Next
        //以上两步顺序无所谓
    }
}

链表算法（2）

Kiramux — Sat, 20 Sep 2025 00:00:00 GMT

25-09-19 反转链表、两数之和 25-09-20 两两交换链表中的节点昨天和今天在准备速写带画教学内容，学习进度放缓... 相关链接：代码随想录 |> 206.反转链表|24. 两两交换链表中的节点|1. 两数之和

206.反转链表

206. 反转链表

简单

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例 2：
输入：head = [1,2]
输出：[2,1]
示例 3：
输入：head = []
输出：[]
提示：

链表中节点的数目范围是 [0, 5000]

-5000 <= Node.val <= 5000

**进阶：**链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

双指针法

写的时候犯了个小错误，由于基础不牢，不知道怎么直接给 prev nil，然后直接写了 prev := &ListNode{} 再赋值成 nil ，然后这个节点被丢弃掉，等待 GC 回收。多了一次无意义的分配。

应该是： var prev *ListNode

含义：声明了一个指针，初始状态是「空指针」，不指向任何元素。

这证明我对结构体的传递还不熟悉。

大致过程：

prev = nil

cur = head

tmp = cur.Next // tmp 存储下一个节点，防止指针反向后丢失

cur.Next = prev // 指针反向

以上就是一次反向的过程，遍历的条件是

for cur != nil {
    
}

如下图所示：

多次操作后...到达最后一次

当 cur == tail 时是最后一次迭代，接着 cur = nil ，不进循环，tmp 也是 nil。此时 return prev 就是反转后的链表

代码

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func reverseList(head *ListNode) *ListNode {
    // prev := &ListNode{}
    // prev = nil
    var prev *ListNode
    cur := head

    for cur != nil {
        tmp := cur.Next // 存储下一个节点/nil
        cur.Next = prev // 反转指向
        // 向后移动
        prev = cur
        cur = tmp
    }
    return prev
}

24. 两两交换链表中的节点

24. 两两交换链表中的节点

中等

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：
输入：head = [1,2,3,4]
输出：[2,1,4,3]
示例 2：
输入：head = []
输出：[]
示例 3：
输入：head = [1]
输出：[1]
提示：

链表中节点的数目在范围 [0, 100] 内

0 <= Node.val <= 100

虚拟头结点

一定要画图

设一个虚拟头结点指向 head ，然后按照上图的步骤操作。注意这里需要设一个 tmp 存一下节点1。

同时需要注意循环条件。

当链表节点数为偶数时，cur.Next != nil （空链表时也满足）；

当链表节点数为奇数时，cur.Next.Next != nil ；

写循环条件时，cur.Next != nil 应该写在 cur.Next.Next != nil 前面，否则可能会操作空指针。

for cur.Next != nil && cur.Next.Next != nil {
}

完整代码

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func swapPairs(head *ListNode) *ListNode {
    DummyHead := &ListNode{Next: head}
    cur := DummyHead

    for cur.Next != nil && cur.Next.Next != nil {
        tmp := cur.Next
        cur.Next = tmp.Next
        tmp.Next = cur.Next.Next
        cur.Next.Next = tmp

        // 移动 cur
        cur = cur.Next.Next
    }
    return DummyHead.Next
}

链表算法（3）

Kiramux — Mon, 22 Sep 2025 00:00:00 GMT

25-09-21 删除链表的倒数第 N 个结点 25-09-22 链表相交、环形链表 II 相关链接：代码随想录_链表

19. 删除链表的倒数第 N 个结点

19. 删除链表的倒数第 N 个结点

中等

提示

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例 1：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：
输入：head = [1], n = 1
输出：[]
示例 3：
输入：head = [1,2], n = 1
输出：[1]
提示：

链表中结点的数目为 sz

1 <= sz <= 30

0 <= Node.val <= 100

1 <= n <= sz

**进阶：**你能尝试使用一趟扫描实现吗？

题目中标注了 1 <= n <= sz ，所以不用对n做不合法判断。

这道题适合用虚拟头结点，统一节点操作，不需要对头结点特殊处理。

快慢指针法

n 是要删除的倒数第 n 个节点

要求第 size-n 个节点，快指针先走 n ，然后快慢指针一起走。

则快==慢+n 。当快 == size 时，慢 == len - n （即要删除的节点）。

要处理某个节点，需要获取它前面的一个节点，那么我们应该找到 len-n 前面的一个节点。这时让快指针多走一步，那么慢 == len-n-1。

func removeNthFromEnd(head *ListNode, n int) *ListNode {
    DummyHead := &ListNode{Next: head}
    fast, slow := DummyHead, DummyHead
    // 要求删除第 size-n 个节点，快指针先走 n ，再快慢一起走，则 fast == slow + n; 
    // 当 fast == len 时， slow == size - n （需要删除的节点）
    // 要删除某个节点，需要得到前一个节点，所以快指针多走一步(n+1)，slow == size - n - 1;
    for i := 0; i < n + 1; i++ {
        fast = fast.Next
    }
    
    for fast != nil { // fast == nil 时判断不通过，此时 fast 刚好走了 size 步
        fast = fast.Next
        slow = slow.Next
    }
    slow.Next = slow.Next.Next
    return DummyHead.Next
}

双循环法

先遍历链表获得 size，在遍历得到“前一个节点”，从而删除倒数第n个节点。

当时没想到用虚拟头结点，单独处理了头结点。

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func removeNthFromEnd(head *ListNode, n int) *ListNode {
    var size int
    cur := head
    // 获取链表长度
    for cur != nil {
        size++
        cur = cur.Next
    }
    if n == size {
        return head.Next
    } else {
        cur = head
        for i := 0; i < size - n - 1; i++ {
            cur = cur.Next
        }
        cur.Next = cur.Next.Next
        return head
    }
}

面试题 02.07. 链表相交

面试题 02.07. 链表相交

简单

提示

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交**：**

题目数据保证整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

示例 1：
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
示例 2：
输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。
示例 3：
输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。
提示：

listA 中节点数目为 m

listB 中节点数目为 n

0 <= m, n <= 3 * 104

1 <= Node.val <= 105

0 <= skipA <= m

0 <= skipB <= n

如果 listA 和 listB 没有交点，intersectVal 为 0

如果 listA 和 listB 有交点，intersectVal == listA[skipA + 1] == listB[skipB + 1]

**进阶：**你能否设计一个时间复杂度 O(n) 、仅用 O(1) 内存的解决方案？

思路

简单来说，就是求两个链表交点节点的指针。这里要注意，交点不是数值相等，而是指针相等。

为了方便举例，假设节点元素数值相等，则节点指针相等。

看如下两个链表，目前curA指向链表A的头结点，curB指向链表B的头结点：

我们求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB 末尾对齐的位置，如图：

此时我们就可以比较 curA 和 curB 是否相同。

如果不相同： 同时向后移动 curA 和 curB；

如果相同： 则找到交点

否则退出循环，返回空指针。

func getIntersectionNode(headA, headB *ListNode) *ListNode {
    // 分别遍历到最后一个节点，获取到链表长度
    curA := headA
    curB := headB
    lenA, lenB := 0, 0
    for curA != nil {
        lenA++
        curA = curA.Next
    }
    for curB != nil {
        lenB++
        curB = curB.Next
    }

    step := 0
    var fast, slow *ListNode
    if lenA > lenB {
        step = lenA - lenB
        fast, slow = headA, headB
    } else {
        step = lenB - lenA
        fast, slow = headB, headA
    }

    // 先让 fast 走 step 步，将链表对齐
    for i := 0; i < step; i++ {
        fast = fast.Next
    }

    for fast != slow {
        fast = fast.Next
        slow = slow.Next
    }
    return fast
}

go 中两个 nil 可能会不相等吗

同一类型的 nil 值是相等的

var p1 *int = nil
var p2 *int = nil
fmt.Println(p1 == p2) // true

不同类型的 nil 不能直接比较，编译会报错

var p *int = nil
var s []int = nil
fmt.Println(p == s) // ❌ 编译错误：mismatched types *int and []int

接口中存的 nil 可能和直接的 nil 不相等

var x interface{} = nil
var y interface{} = (*int)(nil)

fmt.Println(x == nil) // true
fmt.Println(y == nil) // false，因为 y 的动态类型是 *int，动态值是 nil

142. 环形链表 II

142. 环形链表 II

中等

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：
输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：
输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。
提示：

链表中节点的数目范围在范围 [0, 104] 内

-105 <= Node.val <= 105

pos 的值为 -1 或者链表中的一个有效索引

**进阶：**你是否可以使用 O(1) 空间解决此题？

快慢指针法

判断链表是否有环

可以用快慢指针法，分别定义 fast 和 slow 从头结点出发，fast 每次移动2个节点，slow 每次移动1个节点。如果 fast 和 slow 在途中相遇，说明这个链表有环。

为什么 fast 走2个节点， slow 走一个节点，有环的话，一定在环内相遇呢？

为什么 fast 走2个节点，slow 走一个节点，有环的话一定会在环内相遇呢，而不是永远的错开呢？

首先，fast 一定先进入环中，如果 fast 和 slow 相遇，一定是在环中相遇。（fast 转一圈和 slow 在入口也算在环中相遇）

为什么 fast 和 slow 一定会相遇呢？

相对与 slow 来说，fast 是一个节点一个节点地靠近 slow 的，所以 fast 一定可以和 slow 重合。

如果有环，如何找到这个环的入口

假设从头结点到环形入口节点的节点数为 x ；

从环形入口节点 到 fast 与 slow 相遇节点 的节点数为 y；

从相遇节点 再到 环形节点入口 的节点数为 z。如图所示：

那么相遇时，slow 走过的节点数为 x+y，fast 走过的节点数为 x+y + n(y+z) ， n 为 fast 在环内走了 n 圈才遇到 slow，(y+z) 为一圈内节点的个数。

因为 fast 一次走2个节点，slow 一次走1个节点。

slow走过的节点数 *2 == fast; 即：
(x + y)*2 == x+y + n*(y+z)
两边消掉1个(x+y)
x + y == n*(y+z)
需要求的是x
x == n*(y+z) - y
再提出一个 (y+z) 
x == (n-1)*(y+z) + z

n一定是大于等于1的，因为 fast 一定要多走一圈才能遇到 slow 。

x == (n-1)*(y+z) + z

当 n == 1 时（fast 多走1圈遇到 slow），x == z。这意味着：

从头结点出发一个指针，同时从相遇节点也出发一个指针，这两个指针每次只走一个节点，那么当这两个节点相遇时就找到了环形入口的节点

当 n > 1 时，就是 fast 在环形转n圈后才遇到的 slow 指针，然后两个 index 开始走，和 n == 1 的情况效果是一样的。

详细代码：

func detectCycle(head *ListNode) *ListNode {
    slow, fast := head, head
    for fast != nil && fast.Next != nil {
        // 因为下一行要保证 fast.Next 不是空指针，从而也需要保证 fast 不是空指针
        fast = fast.Next.Next
        slow = slow.Next
        if fast == slow {
            for slow != head {
                slow = slow.Next
                head = head.Next
            }
            return head
        }
    }
    return nil
}

哈希表

遍历链表时，把遍历到的节点存进 map 中。

每次遍历节点时，查询下个节点是否在 map 中，如果在说明就找到了环入口。

func detectCycle(head *ListNode) *ListNode {
    existNodes := make(map[*ListNode]int)
    index := 0
    cur := head
    for cur != nil {
        existNodes[cur] = index
        index++
        cur = cur.Next
        for node, _ := range existNodes {
            if cur == node {// 找到了入口
            return cur
            }
        }
    }
    return nil
}

总结

哈希表算法（1）

Kiramux — Tue, 23 Sep 2025 00:00:00 GMT

哈希表相关算法题 | 代码随想录_哈希表

什么时候可能会用到哈希表？

给一个元素，需要判断它是否在一个集合中出现过，通常就需要用哈希表了。

在 Go 语言中，可以使用数组或者 map 来解题。（例如数组下标存元素、map 的 key 存数据……）

数据量小用数组；数据量散用 map 。

例如要处理 0, 5, 1000000 这三个数，如果用数组下标需要开辟很大的数组，但要处理的数据只有3个，会造成很大的空间浪费，这时使用 map 合适。像 242.有效的字母异位词 中用数组就比较方便。如果用 map 的话还需要进行哈希运算，用数组比较省。

242.有效的字母异位词

242. 有效的字母异位词

简单

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例 1:
输入: s = "anagram", t = "nagaram"
输出: true
示例 2:
输入: s = "rat", t = "car"
输出: false
提示:

1 <= s.length, t.length <= 5 * 104

s 和 t 仅包含小写字母

进阶: 如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？

哈希表

数据比较小用数组，~~数据比较大用set~~，数据比较散用map

构建一个大小为26的数组 hash ，遍历第一个单词 s ，出现一个字母，对应位置+1，a对应0。

再遍历第二个单词 t ，并对对应位置元素-1。

最后遍历 hash，如果出现非0元素，那么这两个单词一定不是字母异位词。（力扣上认为 abc 和 abc 也是字母异位词）

func isAnagram(s string, t string) bool {
    hash := [26]int{}
    for i := 0; i < len(s); i++ {
        hash[s[i] - 'a']++
    }
    for i := 0; i < len(t); i++ {
        hash[t[i] - 'a']--
    }
    for i := 0; i < 26; i++ {
        if hash[i] != 0 {
            return false
        }
    }
    return true
}

349. 两个数组的交集

349. 两个数组的交集

简单

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是唯一的。我们可以 不考虑输出结果的顺序 。

示例 1：
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]
示例 2：
输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
解释：[4,9] 也是可通过的
提示：

1 <= nums1.length, nums2.length <= 1000

0 <= nums1[i], nums2[i] <= 1000

思路：哈希表

哈希表--map

func intersection(nums1 []int, nums2 []int) []int {
    hash := make(map[int]int)
    index := 0
    var result []int
    for i := 0; i < len(nums1); i++ {
        hash[nums1[i]] = index
        index++
    }
    for i := 0; i < len(nums2); i++ {
        if _, ok := hash[nums2[i]]; ok {
            // 先写入 result
            result = append(result, nums2[i])
            // 删除 hash 中这个数值，避免之后 result 元素重复
            delete(hash, nums2[i])
        }
    }
    return result
}

其实一开始写的版本是，每次循环判断 hash 中是否出现过 nums[2]，逻辑很不清晰。

<details> <summary>展开查看</summary> <pre><code> func intersection(nums1 []int, nums2 []int) []int { hash := make(map[int]int) index := 0 var result []int for i := 0; i < len(nums1); i++ { hash[nums1[i]] = index index++ } for i := 0; i < len(nums2); i++ { if _, ok := hash[nums2[i]]; ok { // 写入切片前先判断是否会重复 exist := false for j := 0; j < len(result); j++ { if result[j] == nums2[i] { exist = true // 也可以检测到在 hash 中存在，就删掉 hash 中的这个值。就是这一步遍历的可能多一点。 break } } if !exist { result = append(result, nums2[i]) } } } return result } </code></pre> </details>

哈希表--数组

力扣上新增了以下条件，现在可以用数组求解了。

1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 1000

用数组的下标来存储 nums1 的元素，如果该元素出现过则 hash 中该下标对应的值设为1（顺便可以去重）。

然后用 nums2 中的元素去查询 hash，如果查到了就放进 result，顺便把 hash 对应的值改为 0 实现 result 去重。

func intersection(nums1 []int, nums2 []int) []int {
    hash := [1001]int{}
    result := []int{}
    for i := 0; i < len(nums1); i++ {
        // 用下标存储 nums1 的元素
        hash[nums1[i]] = 1
    }

    for i := 0; i < len(nums2); i++ {
        // 判断 hash 中是否出现过 nums2[i]
        if hash[nums2[i]] == 1 {
            result = append(result, nums2[i])
            hash[nums2[i]] = 0
        }
    }
    return result
}

哈希表算法（2）

Kiramux — Thu, 25 Sep 2025 00:00:00 GMT

202. 快乐数

202. 快乐数

简单

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。

然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。

如果这个过程 结果为 1，那么这个数就是快乐数。

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

示例 1：
输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1
示例 2：
输入：n = 2
输出：false
提示：

1 <= n <= 231 - 1

思路

这道题看上去貌似是一道数学问题，其实并不是！

题中说了会 无限循环，也就是说求和的过程中，sum 会反复出现。

而当我们遇到了要快速判断一个元素是否出现在集合里的时候，就要考虑哈希法了。

所以这道题用哈希法来判断 sum 是否重复出现。如果重复了就 return false，否则一直找到 sum 为止。

判断 sum 是否重复出现可以用 map[int][bool].

还有一个难点是求和的过程，要对取数值各个位上的单数很熟悉。

这道题还学到一点，return n == 1

这里的 n == 1 是个比较表达式，它的值是 bool，并不是把整数当作 bool 来用。等价于
if n == 0 {

	return true

} else {

	return false

}

详细代码：

func isHappy(n int) bool {
    hash := make(map[int]bool)
    for n != 1 && !hash[n] {
        hash[n] = true
        n = getsum(n)
    }
    // 这里是一个比较表达式，值是bool，而不是把整数当作 bool 值
    return n == 1
}

func getsum(n int) int {
    sum := 0
    for n > 0 {
        sum += (n % 10) * (n % 10)
        n /= 10
    }
    return sum
}

1. 两数之和

1. 两数之和

简单

提示

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。

你可以按任意顺序返回答案。

示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：
输入：nums = [3,3], target = 6
输出：[0,1]
提示：

2 <= nums.length <= 104

-109 <= nums[i] <= 109

-109 <= target <= 109

只会存在一个有效答案

**进阶：**你可以想出一个时间复杂度小于 O(n2) 的算法吗？

力扣第一题却难度不低，属于哈希表的题。

暴力解法，2层 for 循环

噩梦开始的地方。。。

第一次写用了两层 for 循环。

func twoSum(nums []int, target int) []int {
    len := len(nums)
    for i, num := range nums {
        for j := i + 1; j < len; j++ {
            if tar := num + nums[j]; tar == target {
                return []int{i,j}
            }
        }
    }
    return nil
}

哈希表（最优解）

map key 存数组的值，value 存数组的下标，来记录出现过的元素。

func twoSum(nums []int, target int) []int {
    m := make(map[int]int) // 值 -> 下标
    for i, num := range nums {
        if j, ok := m[target-num]; ok {
            return []int{j, i}
        }
        m[num] = i
    }
    return nil
}

四数相加 II

454. 四数相加 II

中等

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

0 <= i, j, k, l < n

nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

示例 1：
输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0
示例 2：
输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
输出：1
提示：

n == nums1.length

n == nums2.length

n == nums3.length

n == nums4.length

1 <= n <= 200

-228 <= nums1[i], nums2[i], nums3[i], nums4[i] <= 228

思路--哈希表

先遍历数组 A 和数组 B，用 map 记录 a+b 出现的次数。

再遍历数组 C 和数组 D，查询 map 中是否出现 0-(c+d)，如果出现，counter += value。

相当于转化为了两数之和。

func fourSumCount(nums1 []int, nums2 []int, nums3 []int, nums4 []int) int {
    hash := make(map[int]int)
    counter := 0
    for _, a := range nums1 {
        for _, b := range nums2 {
            hash[a+b]++
        }
    }

    for _, c := range nums3 {
        for _, d := range nums4 {
            if v, ok := hash[0 - (c + d)]; ok {
                counter += v
            }
        }
    }
    return counter
}

为什么遍历 A、B 再遍历 C、D？为什么不能先遍历 A 再遍历 B、C、D？

两两遍历，时间复杂度是 n^2 ；后者的时间复杂度是 n^3。

赎金信

383. 赎金信

简单

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

示例 1：
输入：ransomNote = "a", magazine = "b"
输出：false
示例 2：
输入：ransomNote = "aa", magazine = "ab"
输出：false
示例 3：
输入：ransomNote = "aa", magazine = "aab"
输出：true
提示：

1 <= ransomNote.length, magazine.length <= 105

ransomNote 和 magazine 由小写英文字母组成

思路

这道题和 242.有效的字母异位词很像。242 相当于求字符串a和字符串b是否可以相互组成，而这道题是求字符串a能否组成字符串b，而不用管字符串b能不能组成字符串a。

注意：

magazine 中的每个字符只能在 ransomNote 中使用一次。

由小写英文字母组成

思路就是用哈希表来存每个字母出现的次数。

哈希法--map

func canConstruct(ransomNote string, magazine string) bool {
    hash := make(map[rune]int)
    for _, c := range magazine {
        hash[c]++
    }
    for _, c := range ransomNote {
        if hash[c] == 0 {
            return false
        }
        hash[c]--
    }
    return true
}

哈希法--数组

func canConstruct(ransomNote string, magazine string) bool {
    hash := [26]int{}
    for _, c := range magazine {
        index := c - 'a'
        hash[index]++
    }
    for _, c := range ransomNote {
        index := c - 'a'
        if hash[index] > 0 {
            hash[index]--
        } else if hash[index] == 0 {
            return false
        }
    }
    return true
}

哈希表算法（3）

Kiramux — Sat, 27 Sep 2025 00:00:00 GMT

三数之和和四数之和被放在哈希表章节中，但是其实不适合用哈希表来做，剪枝操作很麻烦。这里主要用双指针法来做。双指针法的好处是可以省一次 for 循环。代码随想录 | 三数之和、四数之和

15. 三数之和

15. 三数之和

中等

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。

**注意：**答案中不可以包含重复的三元组。

示例 1：
输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。
示例 2：
输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。
示例 3：
输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。
提示：

3 <= nums.length <= 3000

-105 <= nums[i] <= 105

双指针法

首先将数组排序，然后有一层for循环，i 从下标0的地方开始，left 在 i+1 的位置上， right 在 len-1 的位置上。

在数组中找到abc使得 a+b+c==0，这里 a = nums[i], b = nums[left]， c = nums[right]。

首先判断 nums[i] 是否大于 0，如果 a 大于0，那么 a+b+c 一定大于0。那么如何移动 left 和 right 呢？

这里需要注意 target > 0 才可以这样写。如果 target < 0，a < 0 也是可以找到三元组的。例如 [-4, -1, 0]， target == 5

如果 a+b+c > 0 说明三数之和大了，因为数组排序过，所以 right 应该向左移动，这样三数之和才能小一点。

如果 a+b+c < 0 说明三数之和小了，应该让 left 向右移动，这样三数之和才能大一点。

当 a+b+c == 0 时开始收集结果，在收集到一个结果之后去重，right 也是一样。

for left < right && nums[left] == nums[left+1] {
    left++
}

在 nums[left] 和下一个数不同时，至少保证一次指针移动

完整代码

func threeSum(nums []int) [][]int {
    sort.Ints(nums)
    len := len(nums)
    result := [][]int{}
    for i := 0; i < len - 2; i++ {
        if nums[0] > 0 {
           break
        }
        // 如果 nums[i] 和前一个重复，则进行下一次循环
        if i > 0 && nums[i] == nums[i - 1] {
            continue
        }
        left := i + 1
        right := len - 1
        for left < right { // 没有=，因为 left == right 时是一个数，不是三数之和了
            if nums[i] + nums[left] + nums[right] == 0 {
                result = append(result, []int{nums[i], nums[left], nums[right]})
                // 在收集到一个结果后去重
                for left < right && nums[left] == nums[left+1] {
                    left++
                }
                for left < right && nums[right] == nums[right-1] {
                    right--
                }
                // 在 nums[left] 和 下一个数不同时，至少保证一次指针移动
                left++
                right--
            } else if nums[i] + nums[left] + nums[right] > 0 {
                right--
            } else {
                left++
            }
        }
    } 
    return result
}

哈希解法（未完成）

func threeSum(nums []int) [][]int {
    res := make([][]int, 0)
    sort.Ints(nums)
    // 找出a + b + c = 0
    // a = nums[i], b = nums[j], c = -(a + b)
    for i := 0; i < len(nums); i++ {
        // 排序之后如果第一个元素已经大于零，那么不可能凑成三元组
        if nums[i] > 0 {
            break
        }
        // 三元组元素a去重
        if i > 0 && nums[i] == nums[i-1] {
            continue
        }
        set := make(map[int]struct{})
        for j := i + 1; j < len(nums); j++ {
            // 三元组元素b去重
            if j > i + 2 && nums[j] == nums[j-1] && nums[j-1] == nums[j-2] {
                continue
            }
            c := -nums[i] - nums[j]
            if _, ok := set[c]; ok {
                res = append(res, []int{nums[i], nums[j], c})
                // 三元组元素c去重
                delete(set, c)
            } else {
                set[nums[j]] = struct{}{}
            }
        }
    }
    return res
}

18.四数之和

18. 四数之和

中等

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n

a、b、c 和 d 互不相同

nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按 任意顺序 返回答案。

示例 1：
输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
示例 2：
输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]
提示：

1 <= nums.length <= 200

-109 <= nums[i] <= 109

-109 <= target <= 109

双指针法

这道题同样使用双指针的思路，就是在 三数之和 的基础上再套一层 for 循环。但是需要注意，四数之和 的 target 不是 0 是可以变的，这时就不能直接根据 n1 > target 来确定没有符合要求的四元组了。因为 target 可能为负数，所以四数之和也可能是越加越小的。

如果 target < 0，a < 0 也是可以找到三元组的。例如 [-4, -1, 0]， target == 5

可以把 a + b 当成一个整体来剪枝，但是剪枝是非必要操作。

if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
    break;
}

另外在去重的时候，边界也有所更改。例如对 b 去重时，（i := k + 1）需要 i > k+1，因为要取 nums[i - 1]， i 必须大于 k 。

完整代码

func fourSum(nums []int, target int) [][]int {
    len := len(nums)
    res := [][]int{}
    if len < 4 {
        return nil
    }
    sort.Ints(nums)
    for k := 0; k < len - 3; k++ {
        n1 := nums[k]
        // if n1 > target { // 不能这样写，因为 target 可能是负数
        //     break
        // }
        if k > 0 && n1 == nums[k-1] { // 对 nums[k] 去重
            continue
        }
        for i := k + 1; i < len - 2; i++ {
            n2 := nums[i]
            if i > k + 1 && n2 == nums[i-1] { // 对 nums[i] 去重
                continue
            }
            left := i + 1
            right := len - 1
            for left < right {
                n3 := nums[left]
                n4 := nums[right]
                sum := n1 + n2 + n3 + n4
                if sum < target {
                    left++
                } else if sum > target {
                    right--
                } else {
                    res = append(res, []int{n1, n2, n3, n4})
                    for left < right && n3 == nums[left+1] { // left 去重
                        left++
                    }
                    for left < right && n4 == nums[right-1] { // right 去重
                        right--
                    }
                    // 找到答案时，双指针同时靠近
                    left++
                    right--
                }
            }
        }
    }
    return res
}

哈希表章节总结

xmind

字符串算法（2）「初探KMP算法」

Kiramux — Sun, 05 Oct 2025 00:00:00 GMT

28. 找出字符串中第一个匹配项的下标

28. 找出字符串中第一个匹配项的下标

简单

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。

示例 1：
输入：haystack = "sadbutsad", needle = "sad"
输出：0
解释："sad" 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ，所以返回 0 。
示例 2：
输入：haystack = "leetcode", needle = "leeto"
输出：-1
解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。
提示：

1 <= haystack.length, needle.length <= 104

haystack 和 needle 仅由小写英文字符组成

什么是KMP

KMP 由 Knuth，Morris、Pratt 三位学者发明，取他们名字的首字母命名，即KMP算法。

KMP有什么用

假设现在有一个文本字符串 aabaabaaf 和一个模板字符串 aabaaf，现在要求在文本串中找出模板串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。

如果不想用双重 for 循环的暴力解法，就需要用到 KMP 算法思想。

KMP的主要思想是当出现字符串不匹配时，可以知道一部分已经匹配的文本内容，从而避免从头重新做匹配。 所以 KMP 的重点是如何记录已经匹配的文本内容。

什么是前缀表

什么是前缀和后缀？

前缀： 必须包含第一个字母但不包含最后一个字母的连续子串

后缀：必须包含最后一个字母但不包含第一个字母的连续子串

aabaaf 的所有前缀：a; aa; aab; aaba; aabaa

aabaaf 的所有后缀：f; af; aaf; baaf; abaaf

后缀也是从左往右读的。

此时就可以引入「最长公共前后缀」（也叫「最长相等前后缀」）的概念了，即一个字符串的前缀集和后缀集中最长的相等的字符串。

前缀表：记录下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。

为什么要使用前缀表？

前缀表的任务是当前位置匹配失败，找到上次已经匹配上的位置，再重新匹配。也就是说在某个字符匹配失败时，前缀表会告诉你下一步匹配时模式串应该跳到哪个位置。这就涉及到计算模式串的完整前缀表。next 数组也是一种前缀表。

只用文字描述可能有点抽象，用下面的图来说明：

要在文本串：aabaabaafa 中查找是否出现过一个模式串：aabaaf。

可以看出，当第六个字符b和f不匹配时，如果使用暴力匹配方法，这时需要从头匹配。如果使用前缀表，就不会从头匹配，而是从上次已经匹配的内容aa后开始匹配。

因为不匹配时，前面的子串aabaa，后缀 aa 和前缀 aa 相等，aa 既是前缀又是后缀，下次匹配时前缀aa一定相等，就不用匹配了，直接从aa的下一位字符b开始匹配就OK了。这里就用到了前五位子串aabaa的最长相等前后缀的长度为2。

所以如果有前缀表，匹配失败时就可以跳到已经匹配过的地方，不用再从头匹配了。

如何计算前缀表

⬆️长度为前1个字符的子串a，最长相同前后缀的长度为0。（注意字符串的前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串；后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串。）

⬆️长度为前2个字符的子串aa，最长相同前后缀的长度为1。

⬆️长度为前3个字符的子串aab，最长相同前后缀的长度为0。

以此类推：

长度为前4个字符的子串aaba，最长相同前后缀的长度为1；
长度为前5个字符的子串aabaa，最长相同前后缀的长度为2；
长度为前6个字符的子串aabaaf，最长相同前后缀的长度为0。

那么把求得的最长相同前后缀的长度组成一个数组，就是对应的前缀表。

可以看出模式串与前缀表对应位置的数字表示的就是：下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。

使用前缀表来匹配

再来看一下如何利用前缀表，在找到不匹配的字符时，指针应该移动到的位置。如动画所示：

找到不匹配的位置，需要看它的前一个字符的前缀表数值是多少（因为要找前面字符串的最长相等前后缀的长度）。前一个字符的前缀表数值是2，所以把下标移动到2的位置继续匹配。

前缀表与next数组

next 数组可以是前缀表，也可以是对前缀表做过处理的数组。

有的人会把前缀表整体右移，首位赋值为-1。因为之前直接使用前缀表的话，需要找模式串匹配失败位置的前一位，整体右移之后可以直接找当前位置，比较方便。

还有一种是先把前缀表都-1，之后再+1，这个思路我还没有理解。

时间复杂度分析

m为模式串长度，n为文本串长度。

暴力解法显然是 O(n × m)

KMP：根据前缀表不断调整匹配的位置，可以看出匹配的过程是O(n)。计算生成next数组，时间复杂度是O(m)。所以整个KMP算法的时间复杂度是O(n+m)。

构造next数组

构造 next 数组其实就是计算模式串s的前缀表的过程，主要有3步：

初始化
处理前后缀不相同的情况
处理前后缀相同的情况

下面先写了从逻辑上易于理解的思路，先处理相同再处理不同。实际上应当是先处理前后缀不相同的情况，再处理前后缀相同的情况

初始化

定义两个指针 i 和 j 。j 指向前缀末尾位置，i 指向后缀末尾位置

// params:
//  	next 前缀表数组
//		s 模式串
j := 0
next[0] = j
for i := 1; i < len(s); i++ {
    // ...
}

处理前后缀相同的情况

此时 s[j] == s[i] -> next[i] = next[j] + 1，i和j同时右移。

if  s[j] == s[i] {
    j++
}
next[i] = j

此时这个求出来的1有什么意义呢？看下面的图：

现在匹配到x和b不相等了，要找它的前一位的前缀表的值，即a对应的值是1，这代表着已经有前缀和后缀a相同的情况，所以已经匹配了a，下一个点需要检查x和b。

⬆️当下一个 s[j] == s[i] 时， s[i] = s[j] + 1，i和j同时右移，所以b对应的是2，c对应的是3。当比较到 d 和 a 时，就是前后缀不相同的情况了。

处理前后缀不相同的情况

s[j] != s[i]，此时j需要移动到前一个字符对应的值（即c对应的值），所以j移动到0，开始比较 s[j] 和 s [i]，发现相等，所以 next[i] = next[j] + 1

为什么要移动到前一个字符？

在 ABACABA 中 ABA 已经构成了最长相等前后缀。

此时 ABA 已经无法与下一个字符构成更长的相等前后缀，那么我们就寻找一下是否存在更短的，比如 A 是可能与下个字符构成相等前后缀的。此时就要判断开头的A和红B前的A是否是相等前后缀。这一步不用暴力求解

其实不用暴力求解，因为我们得知左右两边的 ABA 是相等的，要判断上图两个A是否相同，相当于直接在左边的 ABA 找相等前后缀，而左边的前后缀之前已经计算过了，也就是看 j 的前一位的前缀表的值。

之后就是检查下一位字符是否相同，如果相同则可以构成一个更长的相等前后缀，长度+1即可。

求前缀表全过程的GIF：

![QQ2025105-0017-HD 00_00_00-00_00_30](../images/023/QQ2025105-0017-HD 00_00_00-00_00_30.gif)

这里如果没明白为什么要移动到前一个字符，可以从06:11看这个视频：🔗【最浅显易懂的 KMP 算法讲解】

for j > 0 && s[j] != s[i] {
    j = next[j-1]
}
if  s[j] == s[i] {
    j++
}
next[i] = j

所以经过优化，实际上应当是先处理前后缀不相同的情况，再处理前后缀相同的情况。

// 前缀表无减一或者右移

// getNext 构造前缀表next
// params:
//		  next 前缀表数组
//		  s 模式串
func getNext(next []int, s string) {
    j := 0
    next[0] = j
    for i := 1; i < len(s); i++ {
        for j > 0 && s[i] != s[j] {
            j = next[j-1]
        }
        if s[i] == s[j] {
            j++
        }
        next[i] = j
    }
}

使用next数组来做匹配

func strStr(haystack string, needle string) int {
    n := len(needle)
    if n == 0 {
        return 0
    }
    j := 0
    next := make([]int, n)
    getNext(next, needle)
    for i := 0; i < len(haystack); i++ {
        for j > 0 && haystack[i] != needle[j] {
            j = next[j-1]      // 回退到j的前一位
        }
        if haystack[i] == needle[j] {
            j++
        }
        if j == n {
            return i - n + 1
        }
    }
    return -1
}

完整代码

func strStr(haystack string, needle string) int {
    n := len(needle) // 模式串的长度
    if n == 0 {
        return 0
    }
    j := 0 // 模式串中的指针
    next := make([]int, n)
    getNext(next, needle)
    for i := 0; i < len(haystack); i++ {
        if j > 0 && haystack[i] != needle[j] {
            j = next[j - 1]
        }
        if haystack[i] == needle[j] {
            j++
        }
        if j == n {
            return i - j + 1 // 返回第一个匹配的下标所以+1
        }
    }
    // 遍历完 haystack 都没有和 needle 完全匹配（j != n），说明 needle 不是 haystack 的一部分
    return -1
}

func getNext(next []int, s string) {
    j := 0
    next[0] = j
    for i := 1; i < len(s); i++ {
        for j > 0 && s[j] != s[i] { // 前后缀不相等的情况
            j = next[j-1]
        }
        if s[j] == s[i] {
            j++
        }
        next[i] = j
    }
}

字符串算法（3）

Kiramux — Sun, 05 Oct 2025 00:00:00 GMT

459. 重复的子字符串

459. 重复的子字符串

简单

给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。

示例 1:
输入: s = "abab"
输出: true
解释: 可由子串 "ab" 重复两次构成。
示例 2:
输入: s = "aba"
输出: false
示例 3:
输入: s = "abcabcabcabc"
输出: true
解释: 可由子串 "abc" 重复四次构成。 (或子串 "abcabc" 重复两次构成。)
提示：

1 <= s.length <= 104

s 由小写英文字母组成

暴力解法

s 如果是周期串，要找的 substr 一定满足以下要求：

substr 包括 s 的第一个字符和最后一个字符，所以只需遍历 substr 的结尾字符，不用遍历开头。
substr 的长度不得超过 len(s) 的一半，否则s不可能是周期串。
substr 的长度必须被 len(s) 整除

虽然是暴力解法，但也做了相应的剪枝操作，时间复杂度是 O(n^2)。

is_match := true 这个初始值虽然方便，但是总感觉初始值设为 true 不太好。

func repeatedSubstringPattern(s string) bool {
    // 寻找子串，包含开头，结尾不超过中间，否则不可能由子串重复构成
    n := len(s)
    for l := 1; l <= n/2; l++ {
        if n % l != 0 { // 必须整除，否则不可能由该子串重复构成
            continue
        }
        substr := s[:l]
        is_match := true
        // 检查每一段是不是和 substr 相等
        for i := l; i < n; i = i + l {
            if s[i:i+l] != substr {
                is_match = false
                break
            }
        }
        if is_match {
            return true
        }
    }
    return false
}

双倍字符串法

把字符串翻倍，掐头去尾，如果原字符串在其中，那么原字符串就是周期串。

这里直接使用库函数来查找字符串，实际上就是力扣 28 题。

具体代码：

func repeatedSubstringPattern(s string) bool {
    // 如果2个s拼起来掐头去尾，可以在其中找到s，就说明s是周期串
    t := s + s
    return strings.Contains(t[1:len(t)-1], s)
}

具体解释可以看 🔗周期字符串问题（两种方法），以下内容为搬运。

双倍字符串方法 ¶

把字符串翻倍，掐头去尾，如果原字符串在其中，那么原字符串就是周期串。

假设字符串是 s ，把它的头尾字符分别染上黄色和蓝色：

把字符串 s 接到自身后面，然后掐头去尾，形成新字符串 s'：

匹配意味着周期性

下面讨论原字符串 s 在新字符串 s' 中存在的情况。

一步一步对各部分涂色，使得相等的字符串颜色一样。

经过几轮的染色，可以看到最终 s 确实是一个周期串。

是否巧合？可以做一般性说明。

下图，不妨设右边匹配的少一些。对其中的任一字符 A ，可以按照如下的规则推演：

推演的细致说明：

① 号推演，由于上下字符串匹配。

② 号推演，由于和左上方的自身相等。

如此反复推演。

如此，任一此区间上的字符 A 会在 s 中周期性出现。

即说明字符串 s 是周期串。

周期性意味着匹配

反过来，如果一个字符串 s 是周期串，那么它一定在对应的 s' 中吗？

任何一个周期串可以表达为：由某个模式子串的重复多次构成。

将周期串 s 的头字符对齐在第一个模式串后面，每次右移一个模式串的长度。

可知，s 会在 s' 中有匹配，且可以有多个匹配。

图中可看出，因为模式串重复 n 次，所以会有 n 次匹配。

构造双倍串 s' 时，移除头尾字符，正是为了剔除最左和最右的两次必然匹配。只有中间的 n 次匹配才用到了周期串重复模式串的性质。

结论

综上两方面说明了充分性和必要性，结论：

如果字符串在其掐头去尾的双倍字符串中，它就是周期串。

KMP算法

如果一个字符串 s 是由重复子串组成，那么最长相等前后缀不包含的子串一定是字符串 s 的最小重复子串。

具体原因看 🔗代码随想录_重复的子字符串和 🔗bilibili_字符串这么玩，可有点难度！ | LeetCode：459.重复的子字符串

具体代码：

func repeatedSubstringPattern(s string) bool {
    // 求 next 数组
    n := len(s)
    next := make([]int, n)
    j := 0
    next[0] = j
    for i := 1; i < n; i++ {
        for j > 0 && s[j] != s[i] {
            j = next[j-1]
        }
        if s[j] == s[i] {
            j++
        }
        next[i] = j
    }
    // next[n-1] 是s最长相等前后缀的长度
    if next[n-1] != 0 && n % (n - next[n-1]) == 0 {
        return true
    }
    return false
}

Xmind 总结

🔗Xmind 源文件

字符串算法（1）

Kiramux — Sun, 05 Oct 2025 00:00:00 GMT

344. 反转字符串

344. 反转字符串

简单

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间，你必须**原地修改输入数组**、使用 O(1) 的额外空间解决这一问题。

示例 1：
输入：s = ["h","e","l","l","o"]
输出：["o","l","l","e","h"]
示例 2：
输入：s = ["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]
提示：

1 <= s.length <= 105

s[i] 都是 ASCII 码表中的可打印字符

用 left 和 right 双指针， for left < right {} 循环直接反转字符串即可。不要习惯性地 for i:=0; i<len; i++ {}。

func reverseString(s []byte)  {
    left := 0
    right := len(s) - 1
    for left < right {
        s[left], s[right] = s[right], s[left]
        left++
        right--
    }
}

541.反转字符串 II

541. 反转字符串 II

简单

给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。

如果剩余字符少于 k 个，则将剩余字符全部反转。

如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

示例 1：
输入：s = "abcdefg", k = 2
输出："bacdfeg"
示例 2：
输入：s = "abcd", k = 2
输出："bacd"
提示：

1 <= s.length <= 104

s 仅由小写英文组成

1 <= k <= 104

思路

每隔 2k 个字符的前 k 个字符进行反转
剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符

PS：反转函数和344.反转字符串一样，直接使用库函数也可以。许多库函数的区间都是左闭右开的。

这道题用Go写可以对 s 进行切片，直接对底层数组进行反转操作。

func reverseStr(s string, k int) string {
    ss := []byte(s)
    len := len(ss)
    for i := 0; i < len; i += 2*k {
        if i + k <= len { // 1,2,3 k==2
            // 反转 i ~ i+k （前k个），凑足k个反转
            reverse(ss[i:i+k]) // 左闭右开
        } else {
            // 剩余的不足k个，剩下的都反转
            reverse(ss[i:len])
        }
    }
    return string(ss)
}

func reverse(s []byte) []byte{
    left := 0
    right := len(s)-1
    for left < right {
        s[left], s[right] = s[right], s[left]
        left++
        right--
    }
    return s
}

151. 反转字符串中的单词

151. 反转字符串中的单词

中等

给你一个字符串 s ，请你反转字符串中单词的顺序。

单词是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的单词分隔开。

返回单词顺序颠倒且单词之间用单个空格连接的结果字符串。

**注意：**输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

示例 1：
输入：s = "the sky is blue"
输出："blue is sky the"
示例 2：
输入：s = " hello world "
输出："world hello"
解释：反转后的字符串中不能存在前导空格和尾随空格。
示例 3：
输入：s = "a good example"
输出："example good a"
解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。
提示：

1 <= s.length <= 104

s 包含英文大小写字母、数字和空格 ' '

s 中 至少存在一个 单词

**进阶：**如果字符串在你使用的编程语言中是一种可变数据类型，请尝试使用 O(1) 额外空间复杂度的原地解法。

本题增加难度，在原地进行操作。在 go 语言中将字符串转换为 []byte 来操作。

1. 双指针法（快慢指针）来去除多余的空格。

当快指针 i 读到字母（非空格字符时），开始处理需要写入的内容。

在每个单词前加一个空格（首个单词除外）

// 单词间加上空格
if slow != 0 {
	ss[slow] = ' '
	slow++
}

把需要复制的字符，复制到慢指针，随后快慢指针向后移动（即原地覆盖字符串），截断字符串到有效部分。

2. 翻转字符串

先翻转整个字符串，再翻转每个单词，就实现了题目的要求。

翻转单词的思路就是记录单词的开头位置，同时找到下一个空格或字符串末尾+1的索引 i，reverse(s[start, i])，实现对底层数组的修改。

for 循环的判断条件是 i <= len(s)，因为到 i<len 是遍历到字符串末尾，切片操作是左闭右开，想要包含最后一个字符，就要把 i 向后多移一位。

接着 start = i + 1 （因为第 i 位是空格，下一位才是新的字母）

func reverseWords(s string) string {
    // 1. 双指针去除多余空格
    ss := []byte(s)
    slow := 0
    // 如果 slow == 0，开始复制字符串直到 i 遇到空格，下一次循环
    // 这时 slow != 0，先加个空格，再继续复制字符串
    // 这样就实现了去除多余空格
    for i := 0; i < len(ss); i++ {
        if ss[i] != ' ' {
            // 单词间加上空格
            if slow != 0 {
                ss[slow] = ' '
                slow++
            }
            // 复制逻辑
            for i < len(ss) && ss[i] != ' ' {
                ss[slow] = ss[i]
                slow++
                i++
            }
        }
    } 
    // 截断字符串到实际位置
    ss = ss[0:slow]

    // 2. 反转整个字符串
    reverse(ss)
    // // 3. 反转每个单词
    start := 0
    for i := 0; i <= len(ss); i++ {
        if i == len(ss) || ss[i] == ' ' {
            reverse(ss[start:i])
            // start 是单词的开头，而此时i指向空格或字符串末尾，i+1 才是下一个单词的开头
            start = i + 1
        }
    }
    return string(ss)
}

func reverse(s []byte){
    left := 0
    right := len(s) - 1
    for left < right {
        s[left], s[right] = s[right], s[left]
        left++
        right--
    }
}

栈与队列算法（1）——用栈实现队列

Kiramux — Tue, 07 Oct 2025 00:00:00 GMT

参考资料： 🔗代码随想录_用栈实现队列 🔗稀土掘金_golang 栈数据结构的实现和应用

[toc]

232. 用栈实现队列

232. 用栈实现队列

简单

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

void push(int x) 将元素 x 推到队列的末尾

int pop() 从队列的开头移除并返回元素

int peek() 返回队列开头的元素

boolean empty() 如果队列为空，返回 true ；否则，返回 false

说明：

你只能使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。

你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

示例 1：
输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false
提示：

1 <= x <= 9

最多调用 100 次 push、pop、peek 和 empty

假设所有操作都是有效的（例如，一个空的队列不会调用 pop 或者 peek 操作）

进阶：

你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。

用栈实现队列，需要一个输入栈，一个输出栈。

需要先用 Go 实现一个栈（这里使用 slice），然后再用该栈模拟队列。

原本需要在 stack.Len() 中加读锁，但在 LeetCode 中再多加一个读锁就会时间超限。。

下面动画模拟以下队列的执行过程：

执行语句： queue.push(1); queue.push(2); queue.pop(); 注意此时的输出栈的操作 queue.push(3); queue.push(4); queue.pop(); queue.pop();注意此时的输出栈的操作 queue.pop(); queue.empty();

push 数据，只要把数据放进输入栈即可。

pop 数据：如果输出栈为空，就把输入栈的数据全部导入输出栈，再从输出栈 Pop 数据。

fillStackOut：将数据全部导入输出栈写成一个方法

peek 和 empty：如果输出栈为空，就把输入栈的数据全部导入输出栈，再查看 stackOut 的栈顶元素、判断 stackOut 是否为空。

见详细代码：

// 用 slice 实现栈
type myStack struct {
    Ints []int
    Lock sync.RWMutex
}

func NewStack() *myStack {
    return &myStack{
        Ints: []int{}, // 字面量 []int{} 已经分配好内存空间
    }
}

// Push 入栈
func (s *myStack) Push(t int) {
    s.Lock.Lock()
    defer s.Lock.Unlock()
    s.Ints = append(s.Ints, t)
}

// Pop 出栈
func (s *myStack) Pop() int {
    s.Lock.Lock()
    defer s.Lock.Unlock()
    if s.Empty() {
        return 0
    }
    val := s.Ints[s.Len()-1]
    s.Ints = s.Ints[:s.Len()-1]
    return val
}

// Len 栈内存储的元素数量
func (s *myStack) Len() int {
    return len(s.Ints)
}

// Peek 查看栈顶元素
func (s *myStack) Peek() int {
    if s.Empty() {
        return 0
    }
    return s.Ints[s.Len()-1]
}

// Empty 检查栈是否为空
func (s *myStack) Empty() bool {
    return s.Len() == 0
}


// ==========分割线==========

type MyQueue struct {
    stackIn *myStack
    stackOut *myStack
}


func Constructor() MyQueue {
    return MyQueue {
        stackIn: NewStack(),
        stackOut: NewStack(),
    }
}


func (q *MyQueue) Push(x int)  {
    q.stackIn.Push(x)
}


func (q *MyQueue) Pop() int {
    // 如果 q.stackOut 中没有元素，把 stackIn 元素全部 Push 到 stackOut 中
    q.fillStackOut()
    // 如果 q.stackOut 中有元素则直接 Pop 元素
    return q.stackOut.Pop()

}


func (q *MyQueue) Peek() int {
    q.fillStackOut()
    return q.stackOut.Peek()
}


func (q *MyQueue) Empty() bool {
    q.fillStackOut()
    return q.stackOut.Empty()
}

func (q *MyQueue) fillStackOut() {
    if q.stackOut.Empty() {
        for !q.stackIn.Empty() {
            val := q.stackIn.Pop()
            q.stackOut.Push(val)
        }
    }
}


/**
 * Your MyQueue object will be instantiated and called as such:
 * obj := Constructor();
 * obj.Push(x);
 * param_2 := obj.Pop();
 * param_3 := obj.Peek();
 * param_4 := obj.Empty();
 */

栈与队列算法（2）——用队列实现栈

Kiramux — Wed, 08 Oct 2025 00:00:00 GMT

225. 用队列实现栈

225. 用队列实现栈

简单

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。

int pop() 移除并返回栈顶元素。

int top() 返回栈顶元素。

boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

你只能使用队列的标准操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。

你所使用的语言也许不支持队列。你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：
输入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False
提示：

1 <= x <= 9

最多调用100 次 push、pop、top 和 empty

每次调用 pop 和 top 都保证栈不为空

**进阶：**你能否仅用一个队列来实现栈。

其实感觉用1个队列实现栈，比用2个队列更简单一点。

用2个队列实现栈

push：把元素加到 queue1 中

pop/top：用 MoveWithoutLast() 将 queue1 中除最后一个外所有元素移入 queue2 ，就可以单独对栈顶元素操作了。pop: 返回栈顶元素并删除它；top: 返回栈顶元素，并将其加入 queue2 。最后 queue1 为空，queue2 包含所有元素，交换 queue1 和 queue2

empty：判断 queue1 和 queue2 是否同时为空

动画演示：

模拟的队列执行语句如下：

queue.push(1);        
queue.push(2);        
queue.pop();   // 注意弹出的操作       
queue.push(3);        
queue.push(4);       
queue.pop();  // 注意弹出的操作    
queue.pop();    
queue.pop();    
queue.empty();

完整代码：

type MyStack struct {
    // 2个队列
    queue1 []int
    queue2 []int
}


func Constructor() MyStack {
    return MyStack {
        queue1: []int{},
        queue2: []int{},
    }
}


func (s *MyStack) Push(x int)  {
    s.queue1 = append(s.queue1, x)
}


func (s *MyStack) Pop() int {
    s.MoveWithoutLast()
    val := s.queue1[0]
    s.queue1 = s.queue1[1:] // 去除第一个元素，即变成空切片
    s.queue1, s.queue2 = s.queue2, s.queue1 // 交换，把 queue1 置为 queue2， queue2 置为空
    return val
}

func (s *MyStack) Top() int {
    s.MoveWithoutLast()
    val := s.queue1[0]
    s.queue2 = append(s.queue2, val)
    s.queue1 = s.queue1[1:] // 去除第一个元素，即变成空切片
    s.queue1, s.queue2 = s.queue2, s.queue1 // 交换，把 queue1 置为 queue2， queue2 置为空
    return val
}


func (s *MyStack) Empty() bool {
    return len(s.queue1) == 0 && len(s.queue2) == 0
}

func (s *MyStack) MoveWithoutLast() {
    // 除 queue1 最后一个元素，其余元素转移至 queue2
    for i := 0; i < len(s.queue1) - 1; i++ {
        s.queue2 = append(s.queue2, s.queue1[i])
    }
    // queue1 中只保留最后一个元素
    s.queue1 = s.queue1[len(s.queue1)-1:]
}


/**
 * Your MyStack object will be instantiated and called as such:
 * obj := Constructor();
 * obj.Push(x);
 * param_2 := obj.Pop();
 * param_3 := obj.Top();
 * param_4 := obj.Empty();
 */

用1个队列实现栈

push：直接加到队列末尾

pop/top：把除栈顶元素（最后一个元素）以外的所有元素，一个一个移到队列尾，就可以对栈顶元素操作了。pop：读取并删除它；top：读取并将其添加到 queue 末尾。

empty：判断 queue 是否为空

可以用以下方法快速找到栈顶元素，并将其他元素放到 queue 末尾：

    for range len(s.queue) - 1 {
        first := s.queue[0]
        // 把第一个元素移到queue末尾
        s.queue = append(s.queue, first)
        s.queue = s.queue[1:] // 移除第一个元素
    }

完整代码：

type MyStack struct {
    queue []int
}


func Constructor() MyStack {
    return MyStack {
        queue: []int{},
    }
}


func (s *MyStack) Push(x int)  {
   s.queue = append(s.queue, x) 
}


func (s *MyStack) Pop() int {
    s.MoveWithoutLast()
    val := s.queue[0]
    s.queue = s.queue[1:]
    return val
}


func (s *MyStack) Top() int {
    s.MoveWithoutLast()
    val := s.queue[0]
    s.queue = append(s.queue, val)
    s.queue = s.queue[1:]
    return val
}


func (s *MyStack) Empty() bool {
    return len(s.queue) == 0
}

func (s *MyStack) MoveWithoutLast() {
    for range len(s.queue) - 1 {
        first := s.queue[0]
        // 把第一个元素移到queue末尾
        s.queue = append(s.queue, first)
        s.queue = s.queue[1:]
    }
}


/**
 * Your MyStack object will be instantiated and called as such:
 * obj := Constructor();
 * obj.Push(x);
 * param_2 := obj.Pop();
 * param_3 := obj.Top();
 * param_4 := obj.Empty();
 */

栈与队列算法（3）——总结

Kiramux — Tue, 14 Oct 2025 00:00:00 GMT

20. 有效的括号

20. 有效的括号

简单

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。

左括号必须以正确的顺序闭合。

每个右括号都有一个对应的相同类型的左括号。

示例 1：

**输入：**s = "()"

**输出：**true

示例 2：

**输入：**s = "()[]{}"

**输出：**true

示例 3：

**输入：**s = "(]"

**输出：**false

示例 4：

**输入：**s = "([])"

**输出：**true

示例 5：

**输入：**s = "([)]"

**输出：**false

提示：

1 <= s.length <= 104

s 仅由括号 '()[]{}' 组成

栈

用 map 来存括号的对应关系。

遍历到的左括号存入栈中，当遇到右括号时，与栈顶元素对应的右括号做匹配，若相等则说明括号有效，同时弹出栈顶元素，不等则括号无效。

另外需要注意，如果 len(s) 为奇数则一定不匹配，如果遇到右括号时栈中无元素，则说明多了右括号，不匹配返回false

如果匹配完毕，栈中无元素，说明所有括号都有效匹配。

func isValid(s string) bool {
    if len(s) % 2 != 0 {
        return false
    }
    // 用切片模拟栈
    stack := make([]rune, 0)

    // 哈希表 m 记录右括号对应的左括号
    m := make(map[rune]rune)
    m[')'] = '('
    m['}'] = '{'
    m[']'] = '['

    for _, v := range s {
        if v == '(' || v == '{' || v == '[' {
            stack = append(stack, v)
        } else {
            // 如果是右括号，先判断栈内是否有元素
            if len(stack) == 0 {
                return false
            }
            peek := stack[len(stack)-1]
            if peek != m[v] {
                return false
            } else {
                // 弹出栈顶元素
                stack = stack[:len(stack)-1]
            }
        }
    }
    // 如果栈中不包含元素，则代表完全匹配
    return len(stack) == 0
}

1047. 删除字符串中的所有相邻重复项

1047. 删除字符串中的所有相邻重复项

简单

给出由小写字母组成的字符串 s，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 s 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

示例：
输入："abbaca"
输出："ca"
解释：
例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。
提示：

1 <= s.length <= 105

s 仅由小写英文字母组成。

func removeDuplicates(s string) string {
    var stack []byte
    // 用字符串模拟栈，字符串尾部是栈入口，字符串头部是栈底部

    for i := 0; i < len(s); i++ {
        // 栈不空且与栈顶元素相等，弹出栈顶元素
        if len(stack) != 0 && s[i] == stack[len(stack)-1] {
            stack = stack[:len(stack)-1]
        } else {
            // 把元素放入栈
            stack = append(stack, s[i])
        }
    }
    return string(stack)
}

150. 逆波兰表达式求值

150. 逆波兰表达式求值

中等

给你一个字符串数组 tokens ，表示一个根据逆波兰表示法表示的算术表达式。

请你计算该表达式。返回一个表示表达式值的整数。

注意：

有效的算符为 '+'、'-'、'*' 和 '/' 。

每个操作数（运算对象）都可以是一个整数或者另一个表达式。

两个整数之间的除法总是 向零截断 。

表达式中不含除零运算。

输入是一个根据逆波兰表示法表示的算术表达式。

答案及所有中间计算结果可以用 32 位 整数表示。

示例 1：
输入：tokens = ["2","1","+","3","*"]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9
示例 2：
输入：tokens = ["4","13","5","/","+"]
输出：6
解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6
示例 3：
输入：tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
输出：22
解释：该算式转化为常见的中缀算术表达式为：
 ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22
提示：

1 <= tokens.length <= 104

tokens[i] 是一个算符（"+"、"-"、"*" 或 "/"），或是在范围 [-200, 200] 内的一个整数

逆波兰表达式：

逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。

平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。

该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。

逆波兰表达式主要有以下两个优点：

去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。

适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中

栈

遍历 tokens 读到数字放入栈中，读到运算符就弹出栈顶的2个元素做运算，需要注意相减和相除时的元素顺序。

在判断元素是否是运算符，第一想到的是用哈希表。然而在用哈希表时遇到很多类型方面的问题。

首先是要判断元素是否在map中，最省空间的是用空struct，初始化时用 "+": {},，对map中元素赋值时用 set["+"] = struct{}{}

遍历的 token 是字符串，遇到例如 token“12” 时，不是单个字符 '1' 或 '2'，而是整体的 "12"字符串，长度为2。因此不能用 map[byte]struct{}，它只适合处理单字符场景。

把数字放入栈中，需要提前将 string 转为 int

下面的代码几乎没有用到库函数。

func evalRPN(tokens []string) int {
    stack := []int{}
    set := map[string]struct{} {
        "+": {},
        "-": {},
        "*": {},
        "/": {},
    }
    for i := 0; i < len(tokens); i++ {
        if _, ok := set[tokens[i]]; ok {
            // 从栈中取值做运算
            b := stack[len(stack)-1]
            a := stack[len(stack)-2]
            c := tokens[i]
            stack = stack[:len(stack)-2]
            switch {
                case c == "+":
                    stack = append(stack, a+b)
                case c == "-":
                    stack = append(stack, a-b)
                case c == "*":
                    stack = append(stack, a*b)
                case c == "/":
                    stack = append(stack, a/b) 
            }
        } else {
            // 把数字放入栈中
            num, _ := strconv.Atoi(tokens[i])
            stack = append(stack, num)
        }
    }
    return stack[len(stack)-1]
}

使用库函数，判断元素是否是数字

func evalRPN(tokens []string) int {
	stack := []int{}
	for _, token := range tokens {
		val, err := strconv.Atoi(token)
		if err == nil {
			stack = append(stack, val)
		} else {   // 如果err不为nil说明不是数字
			num1, num2 := stack[len(stack)-2], stack[(len(stack))-1]
			stack = stack[:len(stack)-2]
			switch token {
			case "+":
				stack = append(stack, num1+num2)
			case "-":
				stack = append(stack, num1-num2)
			case "*":
				stack = append(stack, num1*num2)
			case "/":
				stack = append(stack, num1/num2)
			}
		}
	}
	return stack[0]
}

239.滑动窗口最大值

239. 滑动窗口最大值

困难

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回 滑动窗口中的最大值 。

示例 1：
输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置 最大值
--------------- -----
[1 3 -1] -3 5 3 6 7 3
 1 [3 -1 -3] 5 3 6 7 3
 1 3 [-1 -3 5] 3 6 7 5
 1 3 -1 [-3 5 3] 6 7 5
 1 3 -1 -3 [5 3 6] 7 6
 1 3 -1 -3 5 [3 6 7] 7
示例 2：
输入：nums = [1], k = 1
输出：[1]
提示：

1 <= nums.length <= 105

-104 <= nums[i] <= 104

1 <= k <= nums.length

单调队列（仅适用于本题）

队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队列里的元素数值是由大到小的。

设计单调队列的时候，pop，和push操作要保持如下规则：

pop(value)：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作
```
func (m *MyQueue) Pop(val int) {
    if !m.Empty() && val == m.Front() {
        m.queue = m.queue[1:]
    }
}
```
push(value)：如果push的元素value大于入口元素的数值，那么就将队列入口的元素弹出，直到push元素的数值小于等于队列入口元素的数值为止
```
func (m *MyQueue) Push(val int) {
    for !m.Empty() && val > m.Back() {
        m.queue = m.queue[:len(m.queue)-1]
    }
    m.queue = append(m.queue, val)
}
```

动画演示：

// 封装单调队列的方式解题
type MyQueue struct {
    queue []int
}

func NewMyQueue() *MyQueue {
    return &MyQueue{
        queue: make([]int, 0),
    }
}

func (m *MyQueue) Front() int {
    return m.queue[0]
}

func (m *MyQueue) Back() int {
    return m.queue[len(m.queue)-1]
}

func (m *MyQueue) Empty() bool {
    return len(m.queue) == 0
}

func (m *MyQueue) Push(val int) {
    for !m.Empty() && val > m.Back() {
        m.queue = m.queue[:len(m.queue)-1]
    }
    m.queue = append(m.queue, val)
}

func (m *MyQueue) Pop(val int) {
    if !m.Empty() && val == m.Front() {
        m.queue = m.queue[1:]
    }
}

func maxSlidingWindow(nums []int, k int) []int {
    queue := NewMyQueue()
    length := len(nums)
    res := make([]int, 0)
    // 先将前k个元素放入队列
    for i := 0; i < k; i++ {
        queue.Push(nums[i])
    }
    // 记录前k个元素的最大值
    res = append(res, queue.Front())

    for i := k; i < length; i++ {
        // 滑动窗口移除最前面的元素
        queue.Pop(nums[i-k])
        // 滑动窗口添加最后面的元素
        queue.Push(nums[i])
        // 记录最大值
        res = append(res, queue.Front())
    }
    return res
}

347. 前 K 个高频元素

347. 前 K 个高频元素

中等

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

示例 1：

**输入：**nums = [1,1,1,2,2,3], k = 2

输出：[1,2]

示例 2：

**输入：**nums = [1], k = 1

输出：[1]

示例 3：

**输入：**nums = [1,2,1,2,1,2,3,1,3,2], k = 2

输出：[1,2]

提示：

1 <= nums.length <= 105

k 的取值范围是 [1, 数组中不相同的元素的个数]

题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的

**进阶：**你所设计算法的时间复杂度必须优于 O(n log n) ，其中 n 是数组大小。

map+排序

先用 map 统计元素出现次数，再根据出现次数排序。

使用了 sort.Slice() 库函数

func topKFrequent(nums []int, k int) []int {
    ans := []int{}
    map_num := map[int]int{}
    // 统计元素出现次数
    for _, v := range nums {
        map_num[v]++
    }
    // 统计出现过的元素（去重）
    for k, _ := range map_num {
        ans = append(ans, k)
    }

    // 根据出现频率排序元素
    sort.Slice(ans, func(i, j int) bool {
        return map_num[ans[i]] > map_num[ans[j]]
    })
    return ans[:k]
}

xmind 总结

🔗xmind 源文件

二叉树的前/中/后序遍历（深度优先遍历）

Kiramux — Fri, 17 Oct 2025 00:00:00 GMT

力扣题目链接

🔗144.二叉树的前序遍历(opens new window)

🔗145.二叉树的后序遍历(opens new window)

🔗94.二叉树的中序遍历

[TOC]

递归遍历

写递归遍历一定要确定以下3点：

确定递归函数的参数和返回值：确定哪些参数是递归的工程中需要处理的，就在递归函数中加上这个参数；明确每次递归的返回值，从而确定递归函数的返回类型。
确定终止条件：运行递归时遇到栈溢出错误，一般就是没写终止条件或终止条件写的不对。操作系统是用一个栈结构来保存每一层的递归信息，如果递归没有终止，操作系统的内存栈必然会溢出。
确定单层递归的逻辑：确定每一层递归需要处理的信息，在这里也就会重复调用自己来实现递归的过程。

前序遍历

在 Go 中如果使用命名返回值（给返回值起了名字 res，并且类型是 []int），相当于在函数内部自动声明了一个变量 res ，类型为 []int ，自动分配内存，并初始化为对应类型的零值 nil。

函数变量声明 var traversal func(node *TreeNode)

声明一个变量 traversal ，它的类型是 func(node *TreeNode)，也就是“接受一个*TreeNode参数，没有返回值”的函数类型。
后续再给它赋值一个具体的函数实现。

通常在匿名函数递归中使用，因为 Go 中的匿名函数不能在函数内调用自己，因此要先声明一个函数变量，再赋值匿名函数。

这样不用在外部声明递归函数，也不需要传指针了。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func preorderTraversal(root *TreeNode) (res []int) {
    var traversal func(node *TreeNode)
    traversal = func(node *TreeNode) {
        // 确定终止条件
        if node == nil {
            return
        }
        // 确定单层递归的逻辑
        res = append(res, node.Val)// 中
        // 左
        traversal(node.Left)
        // 右
        traversal(node.Right)
    }
    traversal(root)
    return res
}

后序遍历

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func postorderTraversal(root *TreeNode) (res []int) {
    var traversal func(node *TreeNode)
    traversal = func(node *TreeNode) {
        // 确定终止条件
        if node == nil {
            return
        }
        // 确定单层递归的逻辑
        // 左
        traversal(node.Left)
        // 右
        traversal(node.Right)
        res = append(res, node.Val)// 中
    }
    traversal(root)
    return res
}

中序遍历（尝试外部递归函数）

三道题目一样都可以用匿名递归函数解决，这里尝试使用外部定义的递归函数来实现。

func inorderTraversal(root *TreeNode) []int {
    res := []int{}
    traversal(root, &res)
    return res
}

func traversal(cur *TreeNode, res *[]int) {
    // 确定终止条件
    if cur == nil {
        return
    }
    // 确定每层递归逻辑
    traversal(cur.Left, res) // 左
    *res = append(*res, cur.Val) // 中
    traversal(cur.Right, res) // 右
}

迭代遍历

在计算机中递归就是用栈实现的：递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因。

因此用栈就可以实现二叉树的前后中序遍历了。

前序遍历--迭代法

前序遍历是「中左右」，每次先处理根节点，在处理左、右。那么就可以先把根节点放入栈中，再把右孩子加入栈，再加入左孩子。因为栈是先入后出，先加入右孩子才能保证出栈的时候是「中左右」的顺序

注意空节点不入栈，因为要对左右孩子操作，如果空节点入栈就操作空指针了。

用到了 List 包来作为栈。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func preorderTraversal(root *TreeNode) []int {
    res := []int{}
    if root == nil {
        return res
    }
    st := list.New()
    st.PushBack(root)
    for st.Len() > 0 {
        // func (l *List) Remove(e *Element) any
        // 如果e是列表l的一个元素，Remove方法将e从l中移除，并返回元素值e.Value。该元素不能是nil。
        // any 需要断言成需要的类型
        node := st.Remove(st.Back()).(*TreeNode) // pop 栈顶元素
        res = append(res, node.Val)

        // 把右、左孩子放入栈
        if node.Right != nil {
            st.PushBack(node.Right)
        }
        if node.Left != nil {
            st.PushBack(node.Left)
        }
    }
    return res
}

后序遍历--迭代法

前序遍历最后数组的顺序是「中左右」，那么把左右调换位置「中右左」，再把res数组 reverse 一下就变成了后序遍历「左右中」的输出顺序。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func postorderTraversal(root *TreeNode) []int {
    res := []int{}
    if root == nil {
        return res
    }
    st := list.New()
    st.PushBack(root)
    for st.Len() > 0 {
        // func (l *List) Remove(e *Element) any
        // 如果e是列表l的一个元素，Remove方法将e从l中移除，并返回元素值e.Value。该元素不能是nil。any 需要断言成需要的类型
        node := st.Remove(st.Back()).(*TreeNode) // pop 栈顶元素
        res = append(res, node.Val)

        // 前序遍历最后数组的顺序是 中左右，那么把左右调换位置「中右左」，再把res数组 reverse 一下就变成了后序遍历「左右中」 
        if node.Left != nil {
            st.PushBack(node.Left)
        }
        if node.Right != nil {
            st.PushBack(node.Right)
        }
        
    }
    return reverse(res)
}

func reverse(s []int) []int {
    left := 0
    right := len(s) - 1
    for left < right {
        s[left], s[right] = s[right], s[left]
        left++
        right--
    }
    return s
}

中序遍历--迭代法

和迭代法前、后序遍历不同，迭代法中序遍历需要遍历过程和处理过程分开。

声明一个 cur TreeNode ，把它当指针遍历二叉树的左孩子，一边遍历一边把它放进栈中，一路向左~~（一路向西）~~走到黑，直到 cur.Left == nil。

此时 cur 就是「中」，弹出 cur 写入 result 数组（处理元素），cur = cur.Right，再继续遍历 cur 的左孩子……

（当 cur.Left == nil 时，左节点已经在上一步处理过了，此时 cur 就是中节点，需要处理的就是中节点。cur.Right 相当于一个「新的二叉树」，需要从它的左孩子遍历）

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func inorderTraversal(root *TreeNode) []int {
    res := []int{}
    if root == nil {
        return res
    }
    st := list.New()
    cur := root
    
    for cur != nil || st.Len() > 0 {
        if cur != nil {
            st.PushBack(cur)
            cur = cur.Left
        } else {
            cur = st.Remove(st.Back()).(*TreeNode)
            res = append(res, cur.Val)
            cur = cur.Right
        }
    }
    return res
}

二叉树的层序遍历（广度优先遍历）

Kiramux — Sat, 01 Nov 2025 00:00:00 GMT

二叉树的层序遍历——使用队列

层序遍历一个二叉树，就是从左到右一层一层地遍历二叉树，需要用队列来实现。

可以用 slice 或 list 来模拟队列。

队列先进先出，符合一层一层遍历的逻辑，广度优先逻辑。

栈先进后出，适合模拟深度优先遍历，也就是递归的逻辑。

102.二叉树的层序遍历

🔗102.二叉树的层序遍历_LeetCode

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。（即逐层地，从左到右访问所有节点）。

用切片模拟队列

先判断 root 如果为空则返回 nil；root 不为空则把 root 放入 queue 中。

第一层 for 循环在队列中没有元素时终止

第二层 for 循环需要提前确定 size 的数值，而不能直接用 len(queue)，因为 queue 中的元素是实时在变化的。其实这里用 for range size 更合适，之后的题目大多用了这个。

处理队列中的元素:

确定好该层的元素个数，循环弹出队列中第一个元素，记录它的值（并做相关操作），如果 node 有 Left 和 Right 则放入队列中。

最后把每层收集到的数组放入 result 中返回。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func levelOrder(root *TreeNode) [][]int {
    result := [][]int{}
    if root == nil {
        return result
    }
    queue := []*TreeNode{}
    queue = append(queue, root)

    for len(queue) > 0 {
        size := len(queue)
        curLevelVal := []int{}
        for size > 0 {
            // 弹出队列第一个元素
            a := queue[0]
            curLevelVal = append(curLevelVal, a.Val)
            queue = queue[1:]
            if a.Left != nil {
                queue = append(queue, a.Left)
            }
            if a.Right != nil {
                queue = append(queue, a.Right)
            }
            size--
        }
        result = append(result, curLevelVal)
    }
    return result
}

107.二叉树的层次遍历II

🔗107.二叉树的层次遍历II_LeetCode

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

就是上面的 102 题的结果反转一下。

这次用 container 中的 list 来模拟队列。

func levelOrderBottom(root *TreeNode) [][]int {
    result := [][]int{}

    if root == nil {
        return nil
    }
    queue := list.New() //这里的list是包名，不是List类型
    queue.PushBack(root)

    for queue.Len() > 0 {
        curLevelVal := []int{} // 用于存储当前层节点值
        size := queue.Len() // 保存当前层的节点个数，再循环操作该层节点
        for range size { // 这个循环结束也就代表处理完该层元素了
            // Element结构体是链表List中的一个元素，里面的 Val 才是存的值，所以在 Remove() 时传入的是元素指针，不会出现相等元素删除错误的情况
            // 弹出队列第一个元素
            node := queue.Remove(queue.Front()).(*TreeNode)
            curLevelVal = append(curLevelVal, node.Val)
            if node.Left != nil {
                queue.PushBack(node.Left)
            }
            if node.Right != nil {
                queue.PushBack(node.Right)
            }
        }
        // 这层处理完了，把这层的节点值数组放进 result 中
        result = append(result, curLevelVal)
    }

    return reverse(result)
}

func reverse(s [][]int) [][]int {
    left := 0
    right := len(s)-1
    for left < right {
        s[left], s[right] = s[right], s[left]
        left++
        right--
    }
    return s
}

199.二叉树的右视图

🔗199.二叉树的右视图_LeetCode

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

相同的遍历思路，只记录队列中的该层元素的最后一个（最右侧的）节点值。

func rightSideView(root *TreeNode) []int {
    result := []int{}
    if root == nil {
        return nil
    }
    queue := list.New()
    queue.PushBack(root)

    for queue.Len() > 0 {
        size := queue.Len()
        for i := range size { // 遍历该层元素
            node := queue.Remove(queue.Front()).(*TreeNode)
            if node.Left != nil {
                queue.PushBack(node.Left)
            }
            if node.Right != nil {
                queue.PushBack(node.Right)
            }
            // 只记录队列中的该层元素的最后一个（最右侧的）节点值
            if i == size - 1 {
                result = append(result, node.Val)
            }
        }
    }
    return result
}

637.二叉树的层平均值

🔗637.二叉树的层平均值_LeetCode

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

同 102 思路，给每层的结果分别计算一下平均值。

func averageOfLevels(root *TreeNode) []float64 {
    result := []float64{}
    if root == nil {
        return nil
    }

    queue := list.New()
    queue.PushBack(root)

    for queue.Len() > 0 {
        size := queue.Len()
        curLevelVals := []int{}
        for range size {
            node := queue.Remove(queue.Front()).(*TreeNode)
            curLevelVals = append(curLevelVals, node.Val)
            if node.Left != nil {
                queue.PushBack(node.Left)
            }
            if node.Right != nil {
                queue.PushBack(node.Right)
            }
        }
        // 计算该层数值平均值
        sum := 0
        for i := range len(curLevelVals) {
            sum += curLevelVals[i]
        }
        var avg float64
        avg = float64(sum) / float64(len(curLevelVals))
        result = append(result, avg)
    }
    return result
}

429.N叉树的层序遍历

🔗429.N叉树的层序遍历_LeetCode

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

示例 1：
输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]
示例 2：
输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

处理节点时，用遍历切片的方式代替之前的 Left、Right 判断。

func levelOrder(root *Node) [][]int {
    if root == nil {
        return nil
    }
    result := [][]int{}
    queue := list.New()
    queue.PushBack(root)

    for queue.Len() > 0 {
        size := queue.Len()
        curLevelVals := []int{}
        for range size {
            node := queue.Remove(queue.Front()).(*Node)
            curLevelVals = append(curLevelVals, node.Val)
            if node.Children != nil {
                for i := range node.Children {
                    queue.PushBack(node.Children[i])
                }
            }
        }
        result = append(result, curLevelVals)
    }
    return result
}

515.在每个树行中找最大值

🔗515.在每个树行中找最大值_LeetCode

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

在遍历每一层的 node 时顺便做最大值的判断。

也可以在 102 的结果上做最大值判断，只不过会多一次 for 循环。

func largestValues(root *TreeNode) []int {
    if root == nil {
        return nil
    }
    result := []int{}
    queue := list.New()
    queue.PushBack(root)
    

    for queue.Len() > 0 {
        temp := math.MinInt64
        size := queue.Len()
        curLevelVals := []int{}
        for range size {
            node := queue.Remove(queue.Front()).(*TreeNode)
            curLevelVals = append(curLevelVals, node.Val)
            temp = max(temp, node.Val)

            if node.Left != nil {
                queue.PushBack(node.Left)
            }
            if node.Right != nil {
                queue.PushBack(node.Right)
            }
        }
        // 取最大值
        result = append(result, temp)
    }
    return result
}

func max(x, y int) int {
    if x > y {
        return x
    } 
    return y
}

116.填充每个节点的下一个右侧节点指针

🔗116.填充每个节点的下一个右侧节点指针_LeetCode

给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

示例 1：
输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。
示例 2:
输入：root = []
输出：[]

处理每一层元素时：

if i < size - 1 即此时的 node.Next 还有节点，不为 nil，把 node.Next 指向后面那个节点。这时 node 已经被弹出队列了，因此它原先的下一个节点，就是 queue 现在的第一个节点，读取它并类型断言为 *Node。

node.Next = queue.Front().Value.(*Node)

否则（i >= size -1），此时的 node.Next 为 nil。 i == size -1 时，这个 node 是 queue 中仅有的一个元素，因此 node.Next == nil。

就这样把每一层的节点都指向它队列中的下一个节点，末尾节点指向 nil 即可

func connect(root *Node) *Node {
	if root == nil {
        return nil
    }
    queue := list.New()
    queue.PushBack(root)
    for queue.Len() > 0 {
        size := queue.Len()
        for i := range size {
            node := queue.Remove(queue.Front()).(*Node)
            if i < size - 1 {
                node.Next = queue.Front().Value.(*Node)
            } else {
                node.Next = nil
            }

            if node.Left != nil {
                queue.PushBack(node.Left)
            }
            if node.Right != nil {
                queue.PushBack(node.Right)
            }
        }
    }
    return root
}

117.填充每个节点的下一个右侧节点指针II

🔗117.填充每个节点的下一个右侧节点指针II_LeetCode

给定一个二叉树：
struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。

初始状态下，所有 next 指针都被设置为 NULL 。

示例 1：
输入：root = [1,2,3,4,5,null,7]
输出：[1,#,2,3,#,4,5,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），'#' 表示每层的末尾。
示例 2：
输入：root = []
输出：[]

同116。

104.二叉树的最大深度

🔗104.二叉树的最大深度_LeetCode

给定一个二叉树 root ，返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

示例 1：
输入：root = [3,9,20,null,null,15,7]
输出：3
示例 2：
输入：root = [1,null,2]
输出：2
提示：

树中节点的数量在 [0, 104] 区间内。

-100 <= Node.val <= 100

初始化一个计数器为0，每处理完二叉树的一层就+1，最后返回它。

func maxDepth(root *TreeNode) int {
    if root == nil {
        return 0
    }
    queue := list.New()
    queue.PushBack(root)
    counter := 0
    for queue.Len() > 0 {
        size := queue.Len()
        for range size {
            node := queue.Remove(queue.Front()).(*TreeNode)
            if node.Left != nil {
                queue.PushBack(node.Left)
            }
            if node.Right != nil {
                queue.PushBack(node.Right)
            }
        }
        counter++
    }
    return counter
}

111.二叉树的最小深度

🔗111.二叉树的最小深度_LeetCode

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

**说明：**叶子节点是指没有子节点的节点。

示例 1：
输入：root = [3,9,20,null,null,15,7]
输出：2
示例 2：
输入：root = [2,null,3,null,4,null,5,null,6]
输出：5
提示：

树中节点数的范围在 [0, 105] 内

-1000 <= Node.val <= 1000

思路同 104 ，每遍历完一层，counter++

在层序遍历二叉树时，同时判断 node 是否有左右孩子，如果没有可以直接返回 counter+1

func minDepth(root *TreeNode) int {
    if root == nil {
        return 0
    }
    queue := list.New()
    queue.PushBack(root)
    counter := 0
    for queue.Len() > 0 {
        size := queue.Len()
        for range size {
            node := queue.Remove(queue.Front()).(*TreeNode)
            if node.Left != nil {
                queue.PushBack(node.Left)
            }
            if node.Right != nil {
                queue.PushBack(node.Right)
            }
            if node.Left == nil && node.Right == nil {
                return counter+1
            }
        }
        counter++
    }
    return counter
}

560. 和为 K 的子数组题解

Kiramux — Mon, 02 Feb 2026 00:00:00 GMT

560. 和为 K 的子数组

中等

给你一个整数数组 nums 和一个整数 k ，请你统计并返回 该数组中和为 k 的子数组的个数 。

子数组是数组中元素的连续非空序列。

示例 1：
输入：nums = [1,1,1], k = 2
输出：2
示例 2：
输入：nums = [1,2,3], k = 3
输出：2
提示：

1 <= nums.length <= 2 * 104

-1000 <= nums[i] <= 1000

-107 <= k <= 107

前排提示：由于数组 nums 不单调且存在负数，不适合用滑动窗口来做。

本题是连续子数组和问题，可以用前缀和转化。因此想要解决这道题，需要先理解如何使用前缀和转化问题，这就要先来看看前缀和模板题了。

前缀和模板题

这里有一道整数数组前缀和模板题，可以帮助我们很好地理解前缀和。

303. 区域和检索 - 数组不可变

下面用 a 来代指数组 nums

这道题需要我们设计一个类型 NumArray，实现它的初始化函数 Constructor 和一个用来求 a[i] ~ a[j] 的元素和的 SumRange 方法，。

关键思路

这里有一个数组 a = [1, 2, 3, 4, 5, 6]，要想计算子数组 [3, 4, 5] 的元素和，可以用前缀 [1, 2, 3, 4, 5] 的元素和减去前缀 [1, 2] 的元素和。即:

3+4+5 = (1+2+3+4+5) - (1+2)

相当于前缀 [1, 2, 3, 4, 5] 去掉前缀 [1, 2] 就得到了子数组 [3, 4, 5]

一般地，任意子数组都是一个前缀去掉前缀后的结果。所以任意子数组的和，都可以表示为两个前缀和的差。

a 的子数组有 O(n^2) 个（n*(n+1)/2），但只有 O(n) 个前缀。那么预处理 a 的所有前缀和，就可以 O(1) 计算任意子数组的元素和。

具体思路

nums 记作 a，其长度为n

对于数组 a ，计算它的长为 n+1 的前缀和数组 s，即计算「a 的前 0 个数的和」，「前 1 个数的和」，「前 2 个数的和」 …… 「前 n 个数的和」，这些和组成一个数组 s。

// 注意这里 s[0] = 0
s[0] = 0
s[1] = a[0]
s[2] = a[0] + a[1]
  ⋮
s[i] = a[0] + a[1] + ⋯ + a[i−1]
s[i+1] =a[0] + a[1] + ⋯ + a[i−1] + a[i]
  ⋮
s[n] = a[0] + a[1] + ⋯ + a[n−1]

通过前缀和，我们可以把子数组的元素和转化成两个前缀和的差。

下标区间 [left, right] 的元素和等于前缀 [0, right] 的元素和减去 [0, left-1] 的元素和，即

s[right+1] - s[left]

示例数组 [−2,0,3,−5,2,−1]

对应的前缀和数组 s = [0,−2,−2,1,−4,−2,−3]

需要求子数组 [3,−5,2,−1] 的和

有了这个式子，我们就可以 O(1) 计算出：s[6] - s[2] = -3 -(-2) = -1

为什么要定义 s[0] = 0，这样做有什么好处

当 left == 0 时，要计算的子数组其实是一个前缀（从 a[0] 到 a[right] ）。

如果不定义 s[0] = 0

无法只用一个公式 s[i] = s[i-1] + x 来计算前缀和，此时需要特判 i = 0 的情况了。
同时计算差值时 s[right] - s[left-1] 也需要对 left = 0 进行特判。

通过定义 s[0] = 0, 任意子数组（包括前缀）都可以表示为两个前缀和的差 s[right+1] - s[left]。

此外，如果 a 是空数组，定义 s[0] = 0 可以兼容这种情况，体现在计算前缀和数组 s ：

如果不定义 s[0] = 0，那么当遇到空数组时，s 也会是空数组，需要对空数组的情况进行特判。

这里有点像链表章节题目里常用的虚拟头结点，通过添加虚拟头结点，统一对链表各元素的操作。

另外一种涉及到子数组的时候，前缀和为什么要添加0的解释：

对于范围 [i, j]子数组而言，其和为： s[j] - s[i - 1]

类似于动态规划，为了避免i - 1是负数，我们可以选择把表达式改为： s[j + 1] - s[i] 并在最前面添加一个状态0

https://leetcode.cn/problems/range-sum-query-immutable/solutions/2693498/qian-zhui-he-ji-qi-kuo-zhan-fu-ti-dan-py-vaar/comments/3000111/

代码实现

type NumArray []int

// 构造前缀和数组
func Constructor(nums []int) NumArray {
    s := make(NumArray, len(nums)+1)
    for i, x := range nums {
        s[i+1] = s[i] +x
    }
    return s
}

// 计算区间内前缀和
func (s NumArray) SumRange(left int, right int) int {
    return s[right+1] - s[left]
}


/**
 * Your NumArray object will be instantiated and called as such:
 * obj := Constructor(nums);
 * param_1 := obj.SumRange(left,right);
 */

560. 和为 K 的子数组题解

560. 和为 K 的子数组

关键思路

求整数数组 nums 中和为 k 的子数组的个数（子数组是数组中元素的连续非空序列）。

根据 303 题的前缀和的定义：

nums 是一个长度为 n 的数组。

s 是 nums 的前缀和数字，长为 n+1，第一项 s[0] 设为0，最后一项的下标为 n。

s[0] = 0
s[i] = nums[0] + nums[1] + ⋯ + nums[i-1]

设 i < j，如果 nums[i] 到 nums[j-1] 的元素和等于 k ，用前缀和表示：

s[j] - s[i] = k

问题转化为：

s 中有多少对下标 (i, j) 满足 0≤i<j≤n 且 s[j] - s[i] = k

即 s[j] + (-s[i]) = k，转化为了两数之和的问题。只不过两数之和只需找到一对下标，本题需要计算所有满足条件的下标对的个数。

如果用二重循环暴力枚举满足的下标对，时间复杂度是 O(n^2)。如何加速？

可以根据两数之和的思路， s[j] - s[i] = k 移项得

s[i] = s[j] - k

代码实现

func subarraySum(nums []int, k int) int {
    s := make([]int, len(nums)+1)   // 前缀和数组
    for i, x := range nums {        // 计算前缀和
        s[i+1] = s[i] + x           // s[0] == 0
    }
    // 设 i < j，求 nums[i] 到 nums[j-1] 的元素和等于k
    // 用前缀和表示： s[j] - s[i] == k     (两数之和)
    // s[i] == s[j] - k
    cnt := make(map[int]int, len(s))
    ans := 0
    for _, sj := range s {          // 遍历 s[j] 的时候顺便把出现过的元素（即需要判断的元素s[i] ）存入哈希表了
        ans += cnt[sj-k]            // 寻找有没有符合条件是 s[i]，如果有计数+1
        cnt[sj]++
    }
    return ans
}

遍历 s[j] 的时候顺便把出现过的元素（即需要判断的元素s[i] ）存入哈希表了。相当两次遍历，先遍历了一遍 s[j]，又遍历一遍 s[i]，只不过是把 s[i] 存入哈希表，使遍历时间复杂度降为了 O(1).

答疑

问：为什么这样做可以不重不漏地计算？

答：暴力做法是，外层循环枚举 j，内层循环枚举 i，如果 s[j]−s[i]=k，那么答案加一。我们保留了「外层循环枚举 j」这个过程，把内层循环用哈希表优化成了 O(1)，所以本质是对暴力算法的哈希表优化。既然暴力算法是不重不漏地计算，那么优化做法也是不重不漏地计算。

问：为什么要把 s[0]=0 也加到哈希表中？

答：举个最简单的例子，nums=[1], k=1。如果不把 s[0]=0 加到哈希表中，按照我们的算法，没法算出这里有 1 个符合要求的子数组。也可以这样理解，要想把任意子数组都表示成两个前缀和的差，必须添加 s[0]=0，否则当子数组是前缀时，没法减去一个数，具体见前缀和及其扩展中的讲解。

问：为什么代码中要先更新 ans，再更新 cnt？这两行代码能否交换？

答：不行，这会在 k=0 的时候算错。例如 nums=[2], k=0，正确答案应该是 0，但如果先把 cnt[2] 加一，再把 cnt[2] 加到 ans 中，最后返回的 ans 就不是 0 了。

问：为什么这题不适合用滑动窗口做？

答：滑动窗口需要满足单调性，当右端点元素进入窗口时，窗口元素和是不能减少的。本题 nums 包含负数，当负数进入窗口时，窗口左端点该往哪个方向移动？无法确定。如果没有负数的话，则可以用滑动窗口（恰好型滑动窗口），见 930. 和相同的二元子数组。

一个乙女游戏资源站

Kiramux — Tue, 24 Feb 2026 00:00:00 GMT

不知道什么原因，我建了一个乙女游戏资源站。

我觉得一切的一切的开端，是我偶然看到了一款乙女游戏，觉得 CG 很漂亮，于是下载体验了一下。

其实我会被吸引还是猎奇心理在作祟。明明是一部乙女游戏，女主角的🐻画的那么大，cg 也画的那么涩♥️，我倒要看看这游戏到底怎么样。然后我就体验了一个女性希望被理解和需要的故事，并且感受到了很多共鸣。

从那款游戏开始，我意识到自己是被游戏的 CG 吸引了。我关注到很多乙女游戏的 CG 画得非常漂亮，总结为以下几点：

华丽的服饰：

例如乙女游戏中的主角，通常会身着及其华丽的服饰或可爱的服装，满足少女心玩家。众所周知少女心并不是少女独有的，~~猛男也有少女心~~。女主人公穿着华丽，在故事中和人物进行着一件又一件的互动事件，这是在 GalGame 中无法体验到的特殊感受。
CG 的互动性：

GalGame 中的 event CG 多为男主人公视角。作为一名画画人，人体早已司空见惯，仅仅看着一张 CG 上的人躺着摆个姿势，没有任何互动性，人物动作全靠人物描写，一张图嗯嗯啊啊水过去的事件看了只会犯困，我觉得这类 cg 是没什么意思的，h场景没什么互动性，十分无聊，但是又想看那么一眼 cg，否则会觉得这家游戏厂商也太没诚意了。这也可能是很多 gal 玩家持「我不看 h 剧情，但你不能没有」观点的原因。

OtomeGame 中的 CG 大多表现男女主2人的互动，并且由于游戏性质，男主人公颜值也非常高。因此没有什么比看郎才女貌的主人公涩涩更赏心悦目的事情了。（这也可能是我偶尔喜欢看女性向AV的原因）
「不太」魅宅的画面表现

这里的不太魅宅是针对 GalGame 对比的，或许应该说女主不会突然化身为一只榨汁姬？曾经在玩 YuzuSoft 的一款游戏，角色设定很可爱我很喜欢，日常也十分有趣，然而进线之后，可爱的人物设定不知道哪里去了，只知道天天h。我也因为这个原因弃坑了很多 GalGame，个人线后面的内容实在是无聊至极。

OtomeGame 的 h 场景之后通常会描写女主人公的心理描写，在男性玩家视角中常见的游戏情节，在女性主人公的心理活动中又是另一番镜像。可能是这种体验比较新鲜，目前我更喜欢这种感觉。

(当然我现在玩的日乙不多，仅仅针对我玩过的部分游戏评价，不代表所有的游戏)

许多 GalGame 优质作品中的 CG 画的也非常漂亮，但通常只描绘女主角，在花1分钟欣赏过这张 CG 之后呢？大多 h 场景的文本枯燥，并且很多作品到 h 部分就把人物塑造丢掉了，非常有工业味。其实我被日乙吸引，更多的还是 CG 方面，想要看到人物互动。

有点扯远了。。总之我之后开始找其他日乙的资源，然后发现日乙分享资源有点像活在10年前。举个例子来说，现在我想玩某款乙女游戏，我现在有几个选择：

Steam、DLsite 等网站购入官方中文版/日文版
购入 Switch 并购买游戏
在初音的青葱免费下载部分 PC 版盗版资源，在其他站点下载 ns 游戏用模拟器游玩
给某论坛捐钱，冒着被封论坛账号的风险下载盗版资源
去司马 tb 店铺花钱购买盗版游戏
去贴吧淘资源，很可能会遇到删帖 / 资源到期

目前看起来获取游戏的途径还蛮多的，但是一旦想要去玩比较久远的游戏，就会面临正版售罄、自己不懂日语、汉化版被论坛或店铺垄断的情况，唯一有希望能玩到这款游戏的方式，就是去翻贴吧的陈年老帖，或是向大佬求资源。接下来还有可能面临网盘链接失效的情况，想玩一款游戏的难度可想而知。因此我才会觉得这种分享资源的方式像是 10 年前，游戏资源被垄断，社区封闭，几乎没有公益站分享，打开帖子和网盘链接完全是在开盲盒。

可能因为我比较喜欢建站玩，前阵子也不知道该干嘛了，于是就在 kun-touchgal-next 的基础上简单修改了一下，搭建了一个乙女游戏的公益分享站，照搬 touchgal 的模式（网站 + cloudreve 自建盘）。如果你在 touchgal 仓库的 fork 列表中翻一下，很容易找到我现在使用的仓库。经过近3个月的整理，现在站内已有几百部游戏，也结识了一位做 AI 翻译的朋友，现在正在稳定发展中。

现在上传游戏的热情也没那么高了，随手写下这一篇文章记录一下吧。前阵子有群友关心我最近在做什么，在这里汇报一下😋。网址就不贴了，在 GitHub 仓库上挂着，避免有不喜欢这类游戏的朋友误入了。

有个题外话。那位做 AI 翻译的朋友，ta 的 blog 最近把 AI 翻译补丁都下线了，并联系我把补丁全放在我的站点。我有点担心是不是因为我的站点，导致 ta 有了下架补丁的想法。因为我的站点，让一个 blog 少了很大篇幅的内容，我心里还是很过意不去的。还好刚刚询问 ta ，原来是 xhs 上有小警察天天出警导致的，尽管 ta 并没有 xhs 账号。这种危险的人确实得避一避。

今天就是随意写写，没什么固定的主题。最后放点我喜欢的 CG 插图。有些是直接从网站上摘下来的，所以会有水印。

Kiramux

美术资源备忘录

目录系列

MadlineCG专题推送目录

技术美术 百人计划目录 by May

以求职为导向的入门级Unity攻略

课程 / 视频合集系列

合集·【美感提升】角色设计 by. 不要小白兔

合集·【美感提升】场景设计 by. 不要小白兔

【绘画教程】皮克斯搬运！色彩与光影。外网大佬视频，包看包会，记得收藏

Blender4.0建模入门教程_超细节100集课程 新手必学 by. 阿发你好

Unity2024新手入门教程_超细节100集课程 by. 阿发你好

【缺课】黄捷Unity3d二次元手绘与CG特效制作第48期【画质高清有大部分素材】

西西MOBA游戏特效课程基础篇【画质不错有素材】

单集视频系列

二次元，但写实！首次详解个人作画流程+基础科普 by. mikasamu

Giant Buffalo-Photoshop Manipulation Speed Art Tutorial

个人博客系列

大空昴单推人 的个人图书馆

网站列表

魔法盒

书籍推荐

[OCR] ARTISTS' MASTER SERIES - Color&Light

【转载】 Unity Shader 毛发实现

毛发的特征

通透性-次表面散射：

复杂的遮蔽性：

特殊的高光-各项异性高光：

制作思路

layer实现方式

优化Layer数量

灯光

环境光：

轮廓光：

太阳光：

高光 - Anisotropic（各项异性）

结语

Unity Shader 入门笔记vol1--第一束光

前面的碎碎念

第一束光-Lambert

HalfLambert

HalfLambert 调子映射

Onedrive 迁移方案记录

秒传情况

onedrive/sharepoint >> onedrive/sharepoint

onedrive >> pikpak

1T 以内

超过 1T

onedrive >> 115

探索

实际使用方案

本文用到的工具

Unity Shader 入门笔记vol2--符文·筑基·照

解惑

HelloWorld （ FlatCol ）

代码 Lambert

代码 HalfLambert

委托任务

浑浑噩噩的每一天

初见德加的舞女

前言

初见

舞女

《芭蕾舞团在巴黎歌剧院》

舞女的画家

透过舞女的情感传达

结尾

使用虚拟信用卡注册 Mapbox 过程记录

前言

具体注册方法

Arcgis 三维模型导入 SketchUp

获取数据

在 Arcmap 中处理数据

在 Arcscene 处理模型

使用 FMEx64 转换为 SketchUp 格式

其他可用的方法

疑似失效的方法记录

Arcmap 计算街区开发强度

创建街区范围

连接街区与建筑数据

技术美术百人计划目录 by May

Blender4.0建模入门教程_超细节100集课程新手必学 by. 阿发你好

大空昴单推人的个人图书馆

左闭右闭区间`[left, right]`

左闭右开区间`[left, right)`

暴力解法直接平方排序