Retr67的小站

发表于

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

1
$ hexo new "My New Post"

More info: Writing

Run server

1
$ hexo server

More info: Server

Generate static files

1
$ hexo generate

More info: Generating

Deploy to remote sites

1
$ hexo deploy

More info: Deployment

发表于 更新于

⚠请注意，本方法不一定支持小版本系统更新。

⚠请注意，执行本方法时，中途出现的任何重启都不建议点击（除非你真的知道你在做什么），只需要在最后重启一次就好。

⚠请注意，执行过程中操作不当有可能导致设备变砖，因此导致的任何损失本人概不负责，请自行甄别。

打开Magisk界面->卸载Magisk->还原原厂映像。（如无法还原原厂映像，可前往https://developers.google.com/android/images?hl=zh-cn#cheetah下载与设备当前型号、系统版本相同的出厂映像【可在手机的关于本机页面查看系统Build号和型号】，并提取下载的压缩包中的init_boot放入你能访问的目录当中。回到Magisk->Magisk栏点击安装->选择并修补一个文件->选择刚提取的init_boot->修补完成）

接着来到系统自带的更新页面，进行常规OTA更新，等待安装完成后（请记住不要点击重启，安装完成后不要在此时点击重启）直接回到Magisk->Magisk栏点击安装->安装到未使用的槽位（OTA后）->等待->重启。至此，当你设备重启完成时，系统将保留magisk以及root权限并完成大版本更新。（如果重启后，设备黑屏或者出现其他特殊情况，请检查是否是因为原先安装的各种模块不支持最新的系统版本所导致的。对此，个人认为的简单的解决方法为：系统升级前关闭所有模块【未经核实】）

发表于 更新于

首先我们需要在https://code.google.com/archive/p/mentohust/downloads中下载mentohust_0.3.4-1-2_i386.deb，下载完并运行安装之后，开启终端并sudo vim /etc/mentohust.conf，修改mentohust的配置文件，往里面填入自己学校的账户与密码，然后保存并退出。接着sudo mentohust -v4.44 -w启动mentohust，并在显示认证成功后，保持终端页面不要关闭。最后，好好享受网络吧！。

十分感谢华中大的大佬们制作的montohust。orz

参考博客：

  1. 当出现不允许使用的客户端类型时：https://wap.sciencenet.cn/blog-626917-754039.html?mobile=1
  2. 找到了软件下载地质：https://www.cnblogs.com/Jesse-Luo/archive/2010/09/15/1826889.html

发表于 更新于

设备管理器->通用串行总线控制器->USB根集线器->属性->电源管理->关闭允许计算机关闭此设备以节约电源(如果不能解决，请关闭其他USB的节约电源）

原因：计算机长时间待机会关闭HDMI接口

设备管理器

属性

其他USB

发表于 更新于

题目

给定一棵有根多叉树，请求出指定两个点直接最近的公共祖先。

洛谷题目链接

读入格式

第一行包含三个正整数N、M、S，分别表示树的结点个数、询问的个数和树根结点的序号。

接下来N-1行每行包含两个正整数x、y，表示x结点和y结点之间有一条直接连接的边（数据保证可以构成树）。

接下来M行每行包含两个正整数a、b，表示询问a结点和b结点的最近公共祖先。

输出格式

输出包含M行，每行包含一个正整数，依次为每一个询问的结果。

输入样例一

5 5 4
3 1
2 4
5 1
1 4
2 4
3 2
3 5
1 2
4 5

输出样例一

4
4
1
4
4

题解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
#include <stdio.h>
#include <iostream>
#define re register

//类模板快读 
template <class T> inline void read(T &x) {
    x=0;char c=getchar();
    for(; '0'>c || c>'9'; c=getchar());
    for(; '0'<=c && c<='9'; c=getchar()) x=(x<<1)+(x<<3)+(c^48);
}

//边数 
int cnt;

//双向建边，双倍空间，不做过多解释 
int To[1000005],Next[1000005],head[500005],d[500005];

//fa[u][i]为u往上跳2^i个点所到达的父亲 
int fa[500005][21];

//链式前向星 
inline void add(int u,int v) {
    To[++cnt]=v;
    Next[cnt]=head[u];
    head[u]=cnt;
}

//记录当前节点和父亲节点 
void dfs(int u,int Dad) {

    //当前深度=父亲+1； 
    d[u]=d[Dad]+1;

    //2^0=1,u往上跳1格所到达的父亲; 
    fa[u][0]=Dad;

    //fa[u][1]=fa[fa[u][0]][0]
    //以u为起点跳2格=自己的父亲跳一格
    //以此类推，感性理解 
    for(re int i=1; (1<<i)<=d[u]; ++i) fa[u][i]=fa[fa[u][i-1]][i-1];

    //遍历u节点为起始点的所有边 
    for(re int i=head[u]; i; i=Next[i])

    //因为之前是双向建边，所以为了防止来回跑，故进行判断 
        if(Dad^To[i]) dfs(To[i],u);
}

//重点！倍增LCA 
inline int LCA(int a,int b) {

    //确保a的深度小于b的深度
    if(d[a]>d[b]) std::swap(a,b);

    //接着要让它们跳到同一层,但一个一个慢慢往上跳太慢了，于是得定义它们的跳跃方式 
    //跳跃方式让我们抽象理解一下 
    //a是一个后面长眼睛的人 
    //最初i很大,跳的非常远，远到天边,深度底
    //而我们要做的是让a,b同层,跳到天边的,看不到,不予理会
    //i慢慢的小了,小到跳到a的后面了，能看到了，那就让b跳到这里
    //随着i慢慢缩小,b越来越小步的往前跳,慢慢缩进距离,直到同一层 
     for(re int i=20; i>=0; --i) 
         if(d[a]<=d[fa[b][i]]) b=fa[b][i];

    //如果跳到同一层后数值相同，证明找到LCA了
    if(a==b) return a;

    //如果跳到同一层后数值仍不同，就一起往上跳，跳到fa[a][0]==fa[b][0]为止
    //跳跃方式与上文类似，只是不比较深度，而改为比较数值是否相同，也就是祖先是否一致
    //同一层开始一起跳，比较深度也没意义吧 
    for(re int i=20; i>=0; --i)
        if(fa[a][i] != fa[b][i]) 
            a=fa[a][i],b=fa[b][i];

    //找到啦!
    return fa[a][0]; 
}

int main() {
    int N,M,S;
    read(N),read(M),read(S);
    for(re int i=1,X,Y; i<N; ++i) {
        read(X),read(Y);

        //双向加边
        add(X,Y),add(Y,X);
    }
    dfs(S,0);
    for(re int i=1,A,B; i<=M; ++i) {
        read(A),read(B);

        //求二者的最近公共祖先 
        printf("%d\n",LCA(A,B));
    }
    return 0;
}

发表于 更新于

题目

windy定义了一种windy数。不含前导零且相邻两个数字之差至少为2的正整数被称为windy数。

windy想知道， 在A和B之间，包括A和B，总共有多少个windy数？

100%的数据，满足1<=A<=B<=2000000000

洛谷题目链接

读入格式

包含两个整数，A B。

输出格式

一个整数

输入样例一

1 10

输出样例一

9

题解

数位Dp模板题，不懂的感性理解一下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include <stdio.h>
#define re register

int a[15];
int f[15][15];

inline int Abs(int x) {return x<0?-x:x;}

inline void Next_Dp() {
    //f[i][j] i为位数，j为第i位的数值
    //f[i][j]=f[i-1][k] 如果（j-k）的绝对值大于等于2 即合法 
    //初始化 f[1][j]=1 j属于0-9
    for(re int j=0; j<=9; ++j) f[1][j]=1;
    for(re int i=2; i<=10; ++i)
        for(re int j=0; j<=9; ++j)
            for(re int k=0; k<=9; ++k)
                if(Abs(j-k)>=2) f[i][j]+=f[i-1][k];
}

//求[0,X) 
inline int Solve(int x) {
    int ans=0,len=0;
    //分解每一位数 
    while(x) {
        a[++len]=x%10;
        x/=10;
    }
    //除了最高位，求每一位的0-9的所有f[i][j] i=1->len-1 j=0->9;
    for(re int i=1; i<len; ++i)
        for(re int j=1; j<=9; ++j)
            ans+=f[i][j];
    //求最高位，小于X的f[i][j]
    for(re int j=1; j<a[len]; ++j) ans+=f[len][j];
    //逐位等于X，往下比 
    for(re int i=len-1; i; --i) {
        for(re int j=0; j<=a[i]-1; ++j)
            if(Abs(j-a[i+1])>=2) ans+=f[i][j];
        if(Abs(a[i+1]-a[i])<2) break;
    }
    return ans;
}

int main() {
    Next_Dp();
    int A,B;
    scanf("%d %d",&A,&B);
    printf("%d\n",Solve(B+1)-Solve(A));
    return 0;
}

发表于 更新于

关于我自己个人对随机值的一些了解，以及水分（RP++）模板

srand(unsigned(time(NULL))); 根据当前时间生成随机种子

rand() 根据种子生成值

1
2
3
4
5
6
7
8
9
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#define re register

int main() {
    srand(unsigned(time(NULL)));
    rand()%2?puts("Yes"):puts("No");
}
0%