Hexo

Hello World

Sun, 31 May 2026 12:57:48 +0000

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

# Quick Start

# Create a new post

$ hexo new "My New Post"

More info: Writing

# Run server

$ hexo server

More info: Server

# Generate static files

$ hexo generate

More info: Generating

# Deploy to remote sites

$ hexo deploy

More info: Deployment

网易云音源解析配置教程

Sun, 31 May 2026 12:00:00 +0000

配置好的网易云api接口地址:

https://www.2006111.xyz (vercel)

音源解析地址:

https://unm-server.focalors.ltd

# 介绍

用于实现对网易云api服务与音源解析的配置

通过api服务能够使用第三方客户端, 音源解析来实现对灰色/vip歌曲的播放

需要两个服务来提供api接口

UnblockNeteaseMusic-utils
NeteaseCloudMusicApiEnhanced/api-enhanced

最终会获取服务的域名,通过这个域名即可访问api服务

eg. http://你的Ubuntu服务器公网IP:5050/match?id=1407551413

即可搜索id为1407551413的音乐,会返回解析的地址

# 通过服务器配置

###配置unblock

UnblockNeteaseMusic-utils api

UnblockNeteaseMusic Utils

居然有现成的api???!

直接部署的核心其实就是三大步：装环境 ➔ 下源码 ➔ 挂后台。下面是详细的裸机（Bare Metal）配置指南：

# 第一步：配置 Node.js 运行环境

UnblockNeteaseMusic-utils 需要较新版本的 Node.js。我们建议安装 Node.js 18 或 20。

更新系统的 apt 包列表：

Bash
```
sudo apt update
```

通过官方 NodeSource 脚本安装 Node.js（推荐，版本更稳）：

Bash

curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt install -y nodejs

验证安装是否成功（如果打印出版本号，代表成功）：

Bash
```
node -v
npm -v
```
安装该项目推荐的 pnpm 包管理工具：

Bash
```
sudo npm install -g pnpm
```

# 第二步：拉取源码并安装依赖

把项目克隆到你喜欢的目录下（例如用户根目录下的 unm-api）：

Bash

cd ~
git clone https://github.com/NeteaseCloudMusicApiEnhanced/UnblockNeteaseMusic-utils.git unm-api
cd unm-api

使用 pnpm 安装项目依赖：

Bash
```
pnpm install
```

# 第三步：使用 PM2 让服务常驻后台

如果你此时在终端直接运行 npm start，服务确实能启动，但当你关闭 SSH 窗口时，服务就会跟着断掉。所以我们需要用 Node.js 社区最常用的进程管理器 PM2，让它在 Ubuntu 后端作为守护进程静默运行。

全局安装 PM2：

Bash
```
sudo npm install -g pm2
```
指定端口并利用 PM2 启动服务：该项目默认运行在 3000 端口。如果你想把它改成 5050（或者任何你想给安卓 App 访问的端口），可以通过传入 PORT 环境变量来直接启动：

Bash
```
PORT=3000 pm2 start app.js --name "unm-rest-api"
```
(注：如果项目根目录没有 app.js，可以查看 package.json，若入口是 index.js，则将上述命令中的 app.js 改为 index.js。或者直接用 PORT=5050 pm2 start npm --name "unm-rest-api" -- start)
设置开机自启（防止服务器重启后服务挂掉）：

Bash
```
pm2 save
pm2 startup
```
(注：运行 pm2 startup 后，终端会打印出一行类似 sudo env PATH=... 的命令，复制并执行它，即可完美锁死开机自启)

####管理和测试你的服务

现在服务已经在后台轻量运行了，你可以随时通过以下命令控制它：

查看运行状态：pm2 list
查看实时日志：pm2 logs unm-rest-api
重启服务：pm2 restart unm-rest-api
停止服务：pm2 stop unm-rest-api

####别忘了防火墙：

如果是在本地测试，请记得放行你设置的端口（例如 5050）：

sudo ufw allow 5050/tcp

(如果是阿里云/腾讯云，依然需要去云控制台的安全组里放行该端口。)

控制台/对应的服务器/防火墙/添加规则

tcp协议放行3000端口

####怎么验证服务是否能用？

服务成功 online 后，你可以在外网（比如你的电脑浏览器或 Postman）访问下面这个链接，测试它是否能正常解析（记得把公网IP换成你自己的）：

http://你的Ubuntu服务器公网IP:5050/match?id=1407551413

###配置enhance_api

NeteaseCloudMusicApiEnhanced/api-enhanced

# 第一步：拉取源码与安装

进入你的用户根目录，克隆核心业务 API 项目：

Bash

cd ~
git clone https://github.com/NeteaseCloudMusicApiEnhanced/NeteaseCloudMusicApiEnhanced.git netease-api
cd netease-api

使用 pnpm 安装依赖：

Bash
```
pnpm install
```

# 第二步：核心配置（创建 `.env` 文件）

该项目支持通过根目录下的 .env 文件来读取配置。对于自研 App 开发，强烈建议创建此文件进行定制。

在 ~/netease-api 目录下创建并编辑 .env 文件：

Bash

nano .env

将以下开发常用配置粘贴进去（根据你的实际情况修改）：

代码段

# 1. 服务运行的端口(我改成了4000)
PORT=4000

# 2. 严格指定运行主机（0.0.0.0 代表允许外网通过服务器公网 IP 访问）
HOST=0.0.0.0

# 3. 开启匿名登录（方便 App 在用户未登录时浏览首页、歌单等公共数据）
ALLOW_ANONYMOUS_LOGIN=true

# 4. 境外 IP 欺骗（极其重要！🌟）
# 如果你的 Ubuntu 服务器是腾讯云香港、香港 AWS、海外 VPS 等，网易云会限制海外 IP 访问。
# 解开下方这行的注释，填入一个合法的中国大陆 IP（例如上海电信/腾讯云国内节点的某个 IP），接口会自动伪装成国内请求。
# X_REAL_IP=116.228.89.233

注：编辑完成后，按 Ctrl + O 保存，再按 Ctrl + X 退出。

####第三步：使用 PM2 启动与守护

配置好 .env 后，不需要在命令行里手动传参了，PM2 会自动读取同目录下的 .env 配置。

直接启动服务：

Bash
```
pm2 start app.js --name "netease-core-api"
```
(注：如果项目根目录下没有 app.js 而是 index.js，请将命令改为 pm2 start index.js --name "netease-core-api")
检查运行状态：

Bash
```
pm2 list
```
你现在应该能同时看到 unm-api (5050端口) 和 netease-core-api (3000端口) 两个服务都在绿色的 online 状态下并存运行。
保存并锁定开机自启：

Bash
```
pm2 save
```
防火墙放行 4000 端口：

Bash
```
sudo ufw allow 4000/tcp
```
(同样，如果是腾讯云/阿里云等服务器，记得去云控制台的安全组里把 TCP 4000 端口也放行。)

# 第四步：验证接口是否正常运作

访问：http://你的服务器公网IP:4000/search?keywords=海阔天空

预期：应该返回包含 Beyond《海阔天空》详细歌曲信息的庞大 JSON 数据。

测试二维码登录流程（安卓 App 开发必用）

访问：http://你的服务器公网IP:4000/login/qr/key

预期：返回一个 unikey。你的安卓 App 拿到这个 key 后，再去请求 /login/qr/create?key=拿到的key 就能生成二维码供用户扫码登录了。

# 进阶(vercel)

有了上面的操作,我们就可以通过 IP:端口号来访问服务api接口.

但是服务器也要钱,于是就有了另一种方案 使用vercel提供的免费部署方案

v4.0.8 加入了 Vercel 配置文件,可以直接在 Vercel 下部署了,不需要自己的服务器(访问 Vercel 部署的接口,需要额外加一个 realIP 参数,如 /song/url?id=1969519579&realIP=116.25.146.177)

v4.29.9 加入了生成随机中国 IP 功能, 在请求时加上 randomCNIP=true 即可使用随机中国 IP, 如 /song/url?id=1969519579&randomCNIP=true

不能正常访问的,绑定下国内备案过的域名,之后即可正常访问

# 操作方法

fork 此项目
在 Vercel 官网点击 New Project
点击 Import Git Repository 并选择你 fork 的此项目并点击import
点击 PERSONAL ACCOUNT 的 select
直接点Continue
PROJECT NAME自己填,FRAMEWORK PRESET 选 Other 然后直接点 Deploy 接着等部署完成即可

###加速访问

在vercel上部署完项目后,点击进入项目就能看到对应的base url,这个就是api接口地址,同理

eg. http://这个地址/match?id=1407551413

即可搜索id为1407551413的音乐,会返回解析的地址

但是,由于服务器在国外.访问速度会比较慢.且dns可能被污染

因此,可以通过cloudflare提供的dns优选功能来提高访问速度,首先要去买一个域名

参考白嫖Cloudflare最优CDN给自己网站加速，尽情享受CF的免费服务_哔哩哔哩_bilibili

然后这个域名就交给cloudflare来解析了,接下来就是到vercel添加这个域名

添加就好了

两个服务都可以通过这样的方式实现加速访问

二叉树常见算法

Sat, 31 May 2025 12:00:00 +0000

# DFS

原来前/中/后序遍历都属于dfs啊 😃

对于二叉树的题目,其要么在从上往下的 "递" 过程进行判断,要么在从下往上的 "归" 过程操作

dfs模板
dfs(node){
    fun(node);
    dfs(node->left);
    dfs(node->right);
    ans=xx;
    return ;
}

//二叉树dfs前序遍历的迭代实现
void dfs(root){
    stk.push(root);
    while(!stk.empty()){
        cur=stk.top();
        stk.pop();
        fun(cur);
        stk.push(cur->right);
        stk.push(cur->left);
    }
}
//中序
//优先向左访问,一直到空节点时,才从栈中取出一个节点并操作
//然后尝试向右访问,在向右访问时,访问一个节点,就再把它当作根节点再次操作
void dfs(root){
	while(!stk.empty()&&cur){
        while(cur){
            stk.push(cur);
            cur=cur->left;
        }
        cur=stk.top();
        skt.pop();
        cur=cur->right;
    }
}

671. 二叉树中第二小的节点

问题转化为寻找大于根节点的最大节点 ,主要用来学习lamda函数

考虑剪枝操作 ,因为下面的值是越来越大的,所以用当前值更新过后后面就没必要遍历了

112. 路径总和

//1.递归 ,PathSum(TreeNode* root, int targetSum) 表示从root出发是否有和为root的路径
只需判断是否有从left/right出发和为sum-node->val的路线
故递推式: PathSum(root,Sum)=Path(root->left,Sum-root->val)||Path(root->right,Sum-root->val)
//2.BFS
BFS 使用 队列 保存遍历到每个节点时的路径和，如果该节点恰好是叶子节点，并且 路径和 正好等于 sum，说明找到了解

129. 求根节点到叶节点数字之和

//同理,考虑递归遍历与bfs
1.前序遍历
  若当前节点为叶子节点, 将其和加到sum
  否则 将当前值继续传递给叶子节点 
2.bfs

199. 二叉树的右视图

//使用后序遍历 ,由后序遍历的那个图可知 ,每层最后一次访问的为最右侧结点
function<void(TreeNode*, int)> fun = [&](TreeNode* node, int depth) {
            //利用后序遍历的那个图可知,每层最后一次遍历到的为最右边的节点
            if (!node) return;
            if (depth >= ans.size()) {  // 动态扩展 ans
                ans.resize(depth + 1);
            }
            fun(node->left, depth + 1);
            fun(node->right, depth + 1);
            ans[depth] = node->val; 
        };
//也可以使用 根右左的方法,每层第一个遍历到的是最右侧节点
function<void(TreeNode*, int)> fun = [&](TreeNode* node, int depth) {
            //利用后序遍历的那个图可知,每层最后一次遍历到的为最右边的节点
            if (!node) return;
            if (depth == ans.size()) {  // 动态扩展 ans
                ans.push_back(node->val);
            
            fun(node->right, depth + 1);
            fun(node->left, depth + 1);
        };

1448. 统计二叉树中好节点的数目

//BFS 记录路径上的最大值,比较即可
function<void(TreeNode*,int)> fun=[&](TreeNode* node,int lmax){
            if(!node) return ;
            if(node->val>=lmax) ans++;
            lmax=max(lmax,node->val);
            fun(node->left,lmax);
            fun(node->right,lmax);
        };

1457. 二叉树中的伪回文路径

//很深刻的一题 ,对回溯的应用
1.对于伪回文的判断,要求元素的出现次数满足 0/1奇 多偶,因此只需要记录每条路上元素的出现情况即可
2.在记录路上的情况时,要注意回溯
        dfs=[&](TreeNode* node){
            if(!node) return ;
            count[node->val]++;
            if(!node->left&&!node->right) check();

            dfs(node->left);
            dfs(node->right);
            count[node->val]--;//在遍历完左右子树后撤销对当前节点的遍历,使其在递归返回父节点时保持原样
        };

1315. 祖父节点值为偶数的节点和

非常无脑,dfs即可

988. 从叶结点开始的最小字符串

string smallestFromLeaf(TreeNode* root){
    //暴力写法,自顶向下遍历,记录当前节点到根节点的路径字符串,当遍历到叶子节点时,和答案比较即可
    string ans="~";
    function<void(TreeNode*,string)> dfs;
    dfs=[&](TreeNode* node,string path){
        //path:当前节点到根节点的路径
        char ch=node->val+'a';
        path=ch+path;
        if(!node->left&&!node->right) ans=min(ans,path);
        if(node->left) dfs(node->left,path);
        if(node->right) dfs(node->right,path);
    };
    dfs(root,"");
    return ans;
}

1026. 节点与其祖先之间的最大差值

    int maxAncestorDiff(TreeNode* root) {
        //祖先:在同一条路径上  问题转化为找到同一条路径上的最大/小值,计算差值即可
        int ans=0;
        function<void(TreeNode*,int,int)> dfs;
        dfs=[&](TreeNode* node,int mx,int mn){
            if(!node) ans=max(ans,mx-mn);
            mx=max(mx,node->val);
            mn=min(mn,node->val);
            dfs(node->left,mx,mn);
            dfs(node->right,mx,mn);
        };
        dfs(root,0,root->val);
        return ans;
    }

100. 相同的树

bool isSameTree(TreeNode* p, TreeNode* q) {
        //自上往下(dfs)和自下往上(递归)都可以
        bool flag=true;
        function<void(TreeNode*,TreeNode*)> dfs;
        dfs=[&](TreeNode* node1,TreeNode* node2){
            if(node1&&node2){//两节点值都存在时,比较节点值
                if(node1->val!=node2->val) {flag=false;return ;}
                dfs(node1->left,node2->left);
                dfs(node1->right,node2->right);
            }
            if(!node1&&!node2) return ;//二者都为空节点时,不操作
            flag=false;                //只有一个节点存在,返回false
        };
        dfs(p,q);
        return flag;
    }

    bool isSameTree(TreeNode* p, TreeNode* q) {//判断以p,q为根节点的两棵树是否相同
        //采用递归实现
        if(!p&&!q) return true;//均为空节点,true
        if(!p&&q||!q&&p) return false;
        if(p->val!=q->val) return false;//终止条件,当只有一个节点或节点值不同时,退出
        return isSameTree(p->left,q->left)&&isSameTree(p->right,q->right);
    }

101. 对称二叉树

bool isSymmetric(TreeNode* root) {
        //自上向下遍历dfs(迭代)
        bool flag=true;
        function<void(TreeNode*,TreeNode*)> dfs;
        dfs=[&](TreeNode* t1,TreeNode* t2){
            //比较t1和t2是否轴对称
            if(!t1||!t2) flag=(t1==t2);
            if(t1->val!=t2->val) flag=false;//两个节点,判断是否相等
  			dfs(t1->left,t2->right);
            dfs(t1->right,t2->left);
        };
        dfs(root->left,root->right);
        return flag;
    }

	//递归,判断t1和t2两棵树是否对称
bool isSymmetric(TreeNode* t1,TreeNode* t2) {
    if(!t1||!t2) return t1==t2;//当一个空节点时false,2个空节点时true,0个时不会进入该判断
    if(t1->val!=t2->val) return false;//两个节点,判断是否相等
    return isSymmetric(t1->left,t2->right)&&isSymmetric(t1->right,t2->left);
}

951. 翻转等价二叉树

    bool flipEquiv(TreeNode* root1, TreeNode* root2) {
        //递归, 如果两棵树的左右子树等价,且这两棵树根节点相同,则这两棵树等价
        if(!root1||!root2) return root1==root2;
        if(root1->val!=root2->val) return false;//判断根节点是否相同
        return flipEquiv(root1->left,root2->left)&&flipEquiv(root1->right,root2->right)||
        flipEquiv(root1->left,root2->right)&&flipEquiv(root1->right,root2->left);
    }

找出克隆二叉树中的相同节点

TreeNode* getTargetCopy(TreeNode* original, TreeNode* cloned, TreeNode* target) {
        //两棵树同时遍历,比较original节点与target,二者相同时返回cloned,因为二者同步所以进行一次前序遍历即可
        if(!original) return NULL;
        if(original==target) return cloned;
        TreeNode* lnode=getTargetCopy(original->left,cloned->left,target);
        TreeNode* rnode=getTargetCopy(original->right,cloned->right,target);
        return lnode==NULL?rnode:lnode;
    }

226. 翻转二叉树

814. 二叉树剪枝

/*一道非常有意思的题,巧妙地用返回的node判断root树的子树是否有1   同样巧妙的还有判断平衡二叉树,当不平衡时返回-1;*/
是否需要删除子树?--子树中没有1即可

1325. 删除给定值的叶子节点

跟上一题一样,最后的返回条件改一下即可,返回null表示该树需要删除,否则不需要删除
TreeNode* removeLeafNodes(TreeNode* root, int target) {
        if(!root) return nullptr;
        TreeNode* lnode=removeLeafNodes(root->left,target);
        TreeNode* rnode=removeLeafNodes(root->right,target);
        if(!lnode) root->left=nullptr;
        if(!rnode) root->right=nullptr;
        if(!root->left&&!root->right&&root->val==target) return nullptr;
   		//该节点为叶子且值为target时,返回null,表示该树需要删除
        else return root;//否则返回root
}

1110. 删点成林

如果当前节点被删除，那么就检查左/右孩子 是否被删除，如果没被删除，就加入答案
如果当前节点被删除，返回空节点，否则返回当前节点

# 回溯

每次执行完一次函数后,都会恢复到进入函数之前的状态,此乃回溯之法 ⏲️

257. 二叉树的所有路径

//1.使用临时变量,表示当前路径0.上的字符串
vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> ans;
        function<void(TreeNode*,string)> dfs;
        dfs=[&](TreeNode* node,string path){
            if(!node) return ;
            path+=to_string(node->val);
            if(!node->left&&!node->right){
                ans.push_back(path);
                return ;
            }
            path+="->";
            dfs(node->left,path);
            dfs(node->right,path);
        };
        dfs(root,"");
        return ans;
    }
//2.回溯,使用外部变量,记录当前的路径
    dfs = [&](TreeNode* node) {
        if (!node) return;
        int old_len = path.size();
        path += to_string(node->val);
        if (!node->left && !node->right) {
            ans.push_back(path);
            path.resize(old_len);
            return;
        }
        path += "->";
        dfs(node->left);
        dfs(node->right);
        // 回溯
        
        path.resize(old_len);//因为函数每执行一次就回溯一次,故回溯完的结果是上一层刚执行完的结果,即认为当前字符并未添加
    };

113. 路径总和 II

vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        vector<int> path;
        vector<vector<int>> ans;
        int sum=0;
        function<void(TreeNode*)> dfs;
        dfs=[&](TreeNode* node){
            if(!node) return ;
            sum+=node->val;
            path.push_back(node->val);
            if(!node->left&&!node->right&&sum==target) ans.push_back(path);
            dfs(node->left);//执行完不会影响path的值,因为其结束后会恢复到进入之前的状态
            dfs(node->right);
            sum-=node->val;//每次执行完一次函数后,都会恢复到进入函数之前的状态,此乃回溯之法
            path.pop_back();
        };
        dfs(root);
        return ans;
    }

437. 路径总和 III

//对于一般的二叉树的回溯, 其关键词在于 同一条路径
//利用前缀和记录这条路径上的根节点路径和

# 最近公共祖先

//关键在于找到 p,q,ans 三个点的关系 ,最终ans点一定满足 左右各含一个p/q;
//从下往上在回溯的过程中判断,故只能使用后序遍历,从子树中传递
TreeNode* fun(TreeNode* root,p,q) {
    //判断root树中是否含有p/q/ans ,若有,则返回 p/q/ans
    if(!root||root==p||root==q) return root;
    lnode=fun(root->left,p,q);	//在左子树中寻找
    rnode=fun(root->right,p,q); //在右子树中寻找
    if(lnode&&rnode) return root;//左右各一个,一定是答案点
    if(lnode) return rnode;
    return lnode;
}
//对于 搜索树
更改最终ans的判定条件即可  ans一定满足 p<root<q 且ans
TreeNode* fun(TreeNode* root,p,q){
    int cur=root->val;
        if(cur>p->val&&cur>q->val) return fun(root->left,p,q);
        if(cur<p->val&&cur<q->val) return fun(root->right,p,q);
        return root;
}

98. 验证二叉搜索树

bool isValidBST(TreeNode* root){
    //"递"的思想,按照中序遍历,判断是否为递增即可
    if(!isbst(root->left)) return false;
    if(root->val<=pre) return false;
    pre=root->val;//更新pre的值
    return isbst(root->right);
}

bool isBST(TreeNode* root,int mn,int mx){
    //前序遍历,根据bst的定义来
    //按照前序遍历构建bst的过程来看,在添加每个节点时,其只需满足一定范围即可,故思路就是将这个范围逐渐往下传递,判断每个节点是否满足条件	若当前为左,其必须小于父节点,**且受到祖先的限制**  若为右,其必须大于父节点,**且受到祖先的限制**
    if(!root) return true;
    int cur=root->val;
    return cur>mn&&cur<mx
        &&isbst(root->left,mn,cur)
        &&isbst(root->right,cur,mx);
}

# BFS

//每一层XXX ,此时que中存储一整行的元素,每次都处理一行
while(!que.empty()){
    int n=que.siz();
    for(int i=.;i<n;i++){
        node=que.front();
        que.pop();
        if(node->left) que.push(node->left);
        if(node->right) que.push(node->right);
    }
    
}

515. 在每个树行中找最大值

//que每次存储一行元素,每次操作都处理一行而不是一个
如何判断下一层??---for循环执行完就表示当前层遍历完

2415. 反转二叉树的奇数层

/*方法1 bfs
记录当前访问的层数,若为奇数层就记录当前层的所有数值,反序赋值(利用栈与队列)

方法2 dfs
两颗 对称二叉树的思想,根左右和根右左 同时遍历恰好能得到对称位置,若当前层为奇数,就交换二者数值*/
dfs_swap=[&](TreeNode* node1,TreeNode* node2,int is_odd){
    		//对于对称节点node1和node2,若当前层为奇数就交换二者
            if(!node1) return ;
            if(is_odd){
                int temp=node1->val;
                node1->val=node2->val;
                node2->val=temp;
            }
            dfs_swap(node1->left,node2->right,is_odd^1);
            dfs_swap(node1->right,node2->left,is_odd^1);
        };

# 二叉搜索树

bro觉得最

# 递归

222. 完全二叉树的节点个数

判断当前节点是不是左叶子是无法判断的，必须要通过节点的父节点来判断其左孩子是不是左叶子

110. 平衡二叉树

/*最小不平衡树的左右高度差>1,故可以

对于所有的不平衡二叉树,其一定会有这样的最小不平衡部分

654. 最大二叉树

404. 左叶子之和

/*对于一个节点,是无法通过它自身来判断其是否为左叶子的,所以只能通过父节点来判断其左孩子是否为叶子.

Hexo

Hello World

# Quick Start

# Create a new post

# Run server

# Generate static files

# Deploy to remote sites

网易云音源解析配置教程

# 介绍

# 通过服务器配置

# 第一步：配置 Node.js 运行环境

# 第二步：拉取源码并安装依赖

# 第三步：使用 PM2 让服务常驻后台

# 第一步：拉取源码与安装

# 第二步：核心配置（创建 .env 文件）

# 第四步：验证接口是否正常运作

# 进阶(vercel)

# 操作方法

二叉树常见算法

# DFS

# 回溯

# 最近公共祖先

# BFS

# 二叉搜索树

# 递归

# 第二步：核心配置（创建 `.env` 文件）