上次发帖都一年多前了～～～

🎁 免费领取服务器、CDN和域名的网站：www.rainyun.com/webpon_

rt

我在初始化Spring Boot+MySQL+MyBatis Plus项目时，通常会利用MyBatisX插件来生成mapper、entity、service层的代码，但是增删改查等逻辑还是需要自己编写，有没有可以提高工作效率的方法？比如说代码生成器、项目模板等。

前端项目是否也有类似的模板？

DeepSeek里用的GRPO算法。

目前是按时间排序，但是大家喜欢看热门帖子，应该加个按热度排序。

有点无聊 想看看大家最近都在思考些什么 烦恼也好开心事也好 都可以回复在下面

1. 在桌面端访问本网站
2. 按下f12
3. 通过中间的分界条调整窗口的大小

可以发现本站在不同大小的窗口下会有不同的样式，比如宽度很小时消息卡片与边界的间距为0，而且卡片的圆角消失了，请问这个是怎么实现的？

国内的互联网生态怎么了？一个个都拿着手机APP刷抖音。用户完全被几个大型APP圈养了。这么好的网站都没人气。

我花一周做了一个网站，欢迎大家来这里交流。

来https://nbnn.net分享见解

我在做一个分享观点的公益网站，找不到合适的富文本编辑器。能推荐一个简易的富文本编辑器吗

请问下，大厂的APP用的是原生技术还是react native还是flutter呢？比如b站、知乎、小红书、tiktok这种。

比如欢迎语：

const text = `hello, {name}! Welcome to {website}!`; 

提取出占位变量 name 和 website，方便注入。 可以使用 Typescript 的类型迭代 + infer：

type ExtractPlaceholders<T extends string> =
  T extends `${string}{${infer Placeholder}}${infer Rest}`
    ? Placeholder | ExtractPlaceholders<Rest>
    : never;

上面利用首次 infer 得到第一个结果 Placeholder 和后续的字付串 Rest，对 Rest 进行迭代就得到全部的 Placeholder。具体使用 ⬇️

const text = `hello, {name}! Welcome to {website}!`;
type Placeholders = ExtractPlaceholders<typeof text>;
type Params = Record<Placeholders, string>;

const params: Params = { name: 'HD_Superman', website: 'HackerTalk.net' };

这样 params 就类型安全了，如果字符串模板改变，Params 会自动改变，提示报错。

在重构编辑器，魔改 Markdown 的 AST，其中一部分是自定义 emoji 渲染，支持换成 google/twitter/facebook 的 emoji，这部份比较通用，写一个 remark 库发布出来。

remark-gfm-emoji

有 react-markdown 的例子，可以自定义 emoji 组件：

emoji.tsx

import clsx from 'clsx';
import * as emoji from 'node-emoji';
import type { ReactNode } from 'react';

type EmojiProps = {
  className?: string;
  children: string;
};

export type EmojiComponents = {
  emoji: (props: EmojiProps) => ReactNode;
};

export function Emoji({ children, className = 'size-5' }: EmojiProps) {
  const value = emoji.get(text) ?? '💔';
  return <span className="size-5">{value}</span>;
}

markdown.tsx

import { memo } from 'react';
import ReactMarkdown, { type Components } from 'react-markdown';
import Emoji, { EmojiComponents } from './emoji';

const components: Partial<Components & EmojiComponents> = {
  emoji: Emoji,
  // other components...
};

const Markdown = ({ children, className }: { children: string; className?: string }) => {
  const { theme } = useTheme();
  return (
    <div className={className}>
      <ReactMarkdown components={components} remarkPlugins={[remarkGfm, remarkGfmEmoji]}>
        {children}
      </ReactMarkdown>
    </div>
  );
};

export default memo(Markdown, (prev, next) => prev.children === next.children);

本文是为了教一个小学弟写的，为了文章完整性我全面总结了一些 OI 中经常用到的哪些输入输出技巧以及注意事项

std::cin 与 std::cout

我相信你的第一行 C++ 代码一定是下面这个：

#include <bits/stdc++.h>

using namespace std;

int main() {
    cout << "Hello, world!" << endl;
    return 0;
}

接下来你一定还学过 cout 用于输入。但是这里有两个小问题，第一是在 CCF 举办的 NOI 赛事中，使用 using namespace std 有概率导致你的程序在 Windows 平台正常运行但在测评环境出错；第二是 endl 会强制刷新缓冲区，导致输出效率变慢。所以我更推荐你使用下面的写法：

#include <bits/stdc++.h>

int main() {
    std::cout << "Hello, world!" << '\n';
    return 0;
}

顺带讲一下 using namespace std 的作用吧。这行代码表示“使用 std 命名空间”。如果你不理解，那么你只需要记住，使用这行代码可能会导致你的一些变量名与内置的一些符号产生冲突，经典的案例就是 next 和 y0 等。删除这一行代码之后，你无脑的在调用内置函数之前加上 std:: 前缀即可。特别的，如果某个函数添加 std:: 后出现问题但不添加就能正常运行，那你无脑不添加就好了，这往往是由于某些 C 语言的特性与 C++ 冲突而编译器不能很好地处理导致的。

std::getline

另外值得一提的是，你可以使用 std::getline 读取一整行输入：

std::string s;
std::getline(std::cin, s);

另外还有一个 getline 方法可用于输入一行内容到 char[]：

char s[256];
std::cin.getline(s, 256);

printf 与 scanf

想必你一定也见过这两个函数。敏锐的你也许会注意到，这两个函数我并没有添加 std::，这是由于这两个函数源自 C 语言，因此也被称为 C 风格输入输出；相应地，std::cin 与 std::cout 被称为 C++ 风格的。你也许经常听到有人说这 C 风格的输入输出比 C++ 风格的更快，在一般情况下确实如此。

顺带一提的是 C 风格输入输出的格式化字符串，这里给出一个列表用于快速查询：

整数类型

• 有符号整数
  • %d 或 %i: 十进制整数
  • %ld 或 %li: 长整型（long int）
  • %lld 或 %lli: 长长整型（long long int）
• 无符号整数
  • %u: 无符号十进制整数（unsigned int）
  • %lu: 无符号长整型（unsigned long int）
  • %llu: 无符号长长整型（unsigned long long int）
• 八进制
  • %o: 八进制整数（默认为int）
  • %lo: 无符号长整型的八进制表示（unsigned long int）
  • %llo: 无符号长长整型的八进制表示（unsigned long long int）
• 十六进制
  • %x 或 %X: 十六进制整数（小写或大写字母）（默认为int）
  • %lx 或 %lX: 无符号长整型的十六进制表示（unsigned long int）
  • %llx 或 %llX: 无符号长长整型的十六进制表示（unsigned long long int）

浮点数类型

• 小数形式
  • %f: 小数形式的浮点数（默认为double）
  • %lf: 双精度浮点数（double）
  • %Lf: 长双精度浮点数（long double）
• 科学计数法
  • %e 或 %E: 科学计数法表示的浮点数（小写或大写字母'e'）（默认为double）
  • %le 或 %lE: 双精度浮点数的科学计数法表示（double）
  • %Le 或 %LE: 长双精度浮点数的科学计数法表示（long double）
• 自动选择格式
  • %g 或 %G: 根据数值大小自动选择%f或%e（小写或大写字母）（默认为double）
  • %lg 或 %lG: 双精度浮点数的自动选择格式（double）
  • %Lg 或 %LG: 长双精度浮点数的自动选择格式（long double）

字符和字符串

• %c: 单个字符
• %s: 字符串

指针

• %p: 指针地址

其他

• %n: 将当前已读取或写入的字符数量存入指向的整型变量中
• %%: 输出百分号本身

精度和宽度控制

• 宽度控制
  • %5d: 最少占用5个字符宽度，不足部分用空格填充（左对齐时加-，如%-5d）
  • %05d: 最少占用5个字符宽度，不足部分用0填充
• 精度控制
  • %.2f: 小数点后保留2位小数
  • %.3e: 科学计数法表示，小数点后保留3位小数
  • %.4g: 自动选择格式，小数点后最多保留4位有效数字

事实上，这样的输入输出方式虽然有不少优点，但是也有不少弊端，因此我不是很推荐这种写法。

同步流对速度的影响

前面提到，C 风格的输入输出往往比 C++ 的更快，这是由于默认情况下 C++ 的输入输入输出需要与 C 风格的同步，借助于所谓同步流。我们可以通过关闭同步流解决这一问题：

std::cin.tie(nullptr)->sync_with_stdio(false);

只需要在 main 函数第一行添加上这句代码就可以了，此时 C++ 风格的速度往往与 C 风格的相同甚至更优。需要注意的是，使用这行代码后，你最好不要再使用 C 风格的输入输出，否则极有可能因为没有同步而导致出 bug。

实际上，这行代码不仅关闭了同步流，还解除了 std::cin 与 std::cout 的绑定，也能在一定程度上提升速度。

奇技淫巧：快读快写

你也许还学过所谓快读快写，使用 getchar 和 putchar 来优化输入输出，像下面这样：

int read() {
    int x = 0, w = 1;
    char ch = 0;
    while (ch < '0' || ch > '9') { // ch 不是数字时
        if (ch == '-') w = -1;     // 判断是否为负
        ch = getchar();            // 继续读入
    }
    while (ch >= '0' && ch <= '9') { // ch 是数字时
        x = x * 10 + (ch - '0');     // 将新读入的数字「加」在 x 的后面
        // x 是 int 类型，char 类型的 ch 和 '0' 会被自动转为其对应的
        // ASCII 码，相当于将 ch 转化为对应数字
        // 此处也可以使用 (x<<3)+(x<<1) 的写法来代替 x*10
        ch = getchar(); // 继续读入
    }
    return x * w; // 数字 * 正负号 = 实际数值
}

void write(int x) {
    static int sta[35];
    int top = 0;
    do { sta[top++] = x % 10, x /= 10; } while (x);
    while (top) putchar(sta[--top] + 48); // 48 是 '0'
}

需要注意的是，putchar 与 getchar 都是 C 风格的，因此与关闭同步流的 C++ 风格输入输出不兼容。

当然了，还有更多复杂的技巧，但是个人不推荐使用也不推荐了解。这是由于在输入输出上花费这么多时间和精力得不偿失，只有毒瘤题会折腾输入输出。

文件读写之 freopen

freopen 可用于重定向输入输出到指定文件，使用格式如下：

freopen("test.in", "r", stdin);
freopen("test.out", "w", stdout);

将这两行代码添加到 main 函数开头就可以了。

这也是一个 C 风格的函数，因此不建议使用。优点是可以通过注释或取消注释这两行代码快速实现文件读写与控制台输入输出的切换。

文件读写之 fopen

这种文件读写也是 C 风格的，请自行阅读示例代码：

FILE *in_file  = fopen("test.in", "r"),
     *out_file = fopen("test.out", "w");
int number;
// 从输入文件读取整数
fscanf(in_file, "%d", &number);
// 写入输出文件
fprintf(out_file, "%d", number);
// 关闭文件
fclose(in_file);
fclose(out_file);

在竞赛中没什么优势，不推荐使用。

C++ 风格文件流

全文的重头戏来了！使用 C++ 风格的文件流进行文件读写不仅可以获得极致的速度，还能拥有舒适便捷的编码体验。只需要在 main 函数开头使用下面的代码打开文件：

std::ifstream fin("test.in");
std::ofstream fout("test.in");

接下来就可以使用 fin 与 fout 替换 std::cin 与 std::cout 进行文件读写：

int n;
fin >> n;
fout << n << '\n'; // 仍然不推荐使用 `std::endl` 用于换行

std::string str;
std::getline(fin, str);

char s[256];
fin.getline(s, 256);

当然了，你还可以通过添加下面的代码对 std::cin 与 std::cout 重定向：

std::cin.rdbuf(fin.rdbuf());
std::cout.rdbuf(fout.rdbuf());
std::cin.tie(nullptr)->sync_with_stdio(false);

这样就可以照常使用 std::cin 与 std::cout 进行文件读写了。同时可以通过注释或取消注释这两行代码实现文件读写与控制台输入输出的切换。有测试表明这种方法是不使用奇技淫巧的前提下的普遍最优读写方式。

C++ 风格格式化输入输出

以下是C++中常用的输入输出格式化控制方法示例：

// 1. 浮点数精度控制
double pi = 3.1415926535;
std::cout << std::fixed << std::setprecision(2) << pi << "\n";  // 输出3.14
std::cout << std::scientific << pi << "\n";  // 输出3.14e+00

// 2. 数值进制控制
int num = 255;
std::cout << std::hex << num << "\n";    // 输出ff
std::cout << std::oct << num << "\n";    // 输出377
std::cout << std::dec << num << "\n";    // 恢复十进制

// 3. 宽度与填充
std::cout << std::setw(10) << std::setfill('*') << 123 << "\n";  // 输出*******123

// 4. 对齐方式
std::cout << std::left << std::setw(10) << "Hello" << "\n";     // 左对齐
std::cout << std::right << std::setw(10) << "World" << "\n";    // 右对齐

// 5. 其他常用格式
std::cout << std::boolalpha << true << "\n";    // 输出true（而非1）
std::cout << std::showpos << 42 << "\n";        // 输出+42
std::cout << std::uppercase << 3.14e2 << "\n";  // 输出3.14E+02

// ========== 输入格式化 ==========
int year, month;
// 输入格式：YYYY/MM
std::cin >> year >> std::ws;  // 跳过空白字符
std::cin.ignore(1);           // 跳过分隔符'/'
std::cin >> month;

// 恢复默认设置
std::cout.unsetf(std::ios::fixed | std::ios::scientific);
std::cout.precision(6);  // 恢复默认精度

常用格式化操作符对照表：

重要特性：

1. 持久性设置：多数格式设置会保持生效，直到被显式修改

2. 作用域控制：可通过{}限定格式作用范围

   {
       std::ios_base::fmtflags f = std::cout.flags();  // 保存状态
       std::cout << std::hex << 255;                   // 临时使用十六进制
       std::cout.flags(f);                             // 恢复状态
   }
   

3. 性能影响：频繁切换格式设置可能影响I/O性能（建议批量处理）

对结构体添加输入输出支持

这部分相当简单，请看示例代码：

struct person {
    std::string name;
    int age;

    friend std::istream &operator>>(std::istream &is, const person &p) {
        is >> p.name >> p.age;
        return is;
    }
    friend std::ostream &operator<<(std::ostream &os, const person &p) {
        os << p.name << ": " << p.age;
        return os;
    }
};

person p;
std::cin >> p;
std::cout << p << '\n';

本文主要面向普及/提高组 OIer 和 ACMer。考虑大多数 OIer 的情况，本文默认读者只会矩阵乘法，不了解矩阵的行列式，矩阵的秩等内容。本文使用 C++ 编写代码示例。

什么是二阶线性递推

二阶线性递推数列在 OI 界还有个著名的名字：广义斐波那契数列。其所指为如下数列 ：

其中，，数列前两项为 。

由于该数列的递推关系是线性的，且每一项都和前两项有关，因此称为二阶线性递推数列。

斐波那契数列与朴素算法

当前文的数列 中 时，该数列就是大名鼎鼎的斐波那契数列 ：

基于这样的递推关系，我们可以写出线性复杂度 的朴素算法：

int f(int n) {
    if (n == 0 || n == 1) {
        return 1;
    }
    return f(n - 1) + f(n - 2);
}

对于较为简单的情况，这样的算法是可以接受的。

我们可以很容易的推广到更一般的情况，所以对于一般的二阶线性递推的朴素算法就留给读者练习吧。

通过矩阵乘法来优化递推

直接根据递推式计算虽然简单，但是实在是太慢了，我们需要优化。如果你还没有学过矩阵乘法，请移步至 OI Wiki（记得顺便把方阵的逆看看，后面要用）。如果你学过矩阵乘法，应当对下面的式子不陌生（如果你对这个式子有点陌生的话，请尝试手动计算左面的矩阵乘法）：

这个式子旨在将斐波那契递推关系用矩阵乘法表示，以进行进一步的操作。其中 被称为状态矩阵（在本例中，它也是个向量）， 被称为转移矩阵。这样的转移在线性代数中属于线性变换，其中转移矩阵被称为线性算子。我们可以很容易的推广到一般的二阶线性递推上：

据此可以得出使用矩阵乘法表示的二阶线性递推的通项公式：

通过矩阵快速幂算法就可以将算法优化到对数复杂度 ，这在一般情况下已经是最优的了（至于是不是真的是最优的，我也不知道，我也不会证）。

代码也是很好实现的，以斐波那契为例：

using vec = array<int, 2>;
struct matrix : public array<vec, 2> {
    using array<vec, 2>::array;
    matrix(const vec &a, const vec &b) : array{a, b} {
        (*this)[0] = a;
        (*this)[1] = b;
    }
    matrix &operator*=(const matrix &other) {
        matrix res{};
        for (int i{0}; i < 2; ++i)
            for (int j{0}; j < 2; ++j)
                for (int k{0}; k < 2; ++k)
                    res[i][j] += (*this)[i][k] * other[k][j];
        return *this = res;
    }
} e{{1, 0}, {0, 1}};

matrix qpow(matrix x, int n) {
    auto res{e};
    while (n) {
        if (n & 1)
            res *= x;
        x *= x, n >>= 1;
    }
    return res;
}

int fib(int n) {
    return qpow(matrix{{1, 1}, {1, 0}}, n)[0][0];
}

一种更有趣的优化算法

接下来的这部分内容会有点抽象，如果你学过抽象代数那看这部分内容就再好不过了。

我们可以找到另一种递推的矩阵表示：

如果你乍一眼看不出来，可以计算一下。为了找到这个式子，我思考了一个晚上。注意到在这个式子中所有的矩阵都形如：

每个矩阵都只与两个元素有关，因此我们可以使用一个二元组来表示这类矩阵，并定义二元组上的乘法：

事实上，在抽象代数领域，这是找到了一个特定类型矩阵的同构：

因此矩阵原有的代数性质对于二元组也是成立的，比如最重要的结合律，这是快速幂得以使用的基础。很容易得出使用这种二元组表示的通项公式：

很容易观察到二元组乘法的单位元：

而且不难找到 的逆元：

这样我们就可以方便的实现倒推了。

理论上讲由于这个方法相比矩阵会少算两三次乘法或加法，因此常数会小一点，实际上没什么差距。下面是针对斐波那契数列的代码：

struct phi_tuple : pair<int, int> {
    using pair<int, int>::pair;
    phi_tuple &operator*=(const phi_tuple &other) {
        // 这里计算的时候提取了公因式以减少一次乘法
        return *this = {first * (other.first + other.second) +
                            second * other.first,
                        first * other.first + second * other.second};
    }
} e{0, 1};

phi_tuple qpow(phi_tuple x, int n) {
    auto res{e};
    while (n) {
        if (n & 1)
            res *= x;
        x *= x, n >>= 1;
    }
    return res;
}

int fib(int n) {
    return qpow(phi_tuple{1, 0}, n + 1).first;
}

特征根法求通项公式的线性代数理解

对于二阶线性递推，一种广为人知的求通项公式的方法是特征根法。对于二阶线性递推：

有特征方程：

可以解出该方程的两个复根：

当 时（即 ），有：

当 时（即 ），有：

接下来只需要将 代入求出 即可。

下面我们以斐波那契数列为例。斐波那契数列的特征方程为：

解得：

于是：

将 代入，会得到一坨很复杂的东西，于是方便起见取 ：

这样我们就可以得到取 时的斐波那契通项公式了：

程序实现请继续往后看……

相似对角化和矩阵特征值与特征向量

方便起见，如无特殊说明，本节内容均以 矩阵为例

上面的方法有多种证明，在这里我们从线性代数的角度考虑。一种很自然的想法是想办法展开矩阵表示的通项公式：

显然问题的关键在于展开右侧的方阵幂。乍一看会有点没思路，不妨从更简单的对角矩阵考虑。对角矩阵指的是形如下面的方阵：

其中空白的区域表示省略的 。观察对焦方阵的平方以及立方：

猜测对角矩阵的幂满足：

很容易通过数学归纳法证明。于是我们找到了计算对角矩阵的幂次的方法，接下来考虑推广到一般的方阵。最直接的想法是将方阵转化为对角矩阵。考虑下面的式子：

注意到：

其中 和 成对出现，于是：

接下来只需找到 对应的 和 即可，这个过程被称为矩阵的相似对角化。

在寻找相似对角化的方法之前，我们先补充一些知识。你也许已经知道线性方程组可以用矩阵乘法等价表示：

基于此，线性方程组均可视为 的形式。当 时，称其为齐次线性方程组，每个方阵都唯一对应一个齐次线性方程组。

另外，你还可能听说过行列式：

方阵 的行列式可以显示方阵的一些性质，比如方阵对应的齐次方程组的解的情况和是否可逆：

1. 时，方阵不可逆，有无穷多解，且任意解之间都线性相关，也就是说每个解都可以通过数乘另一个解得到
2. 时，方阵可逆，只有零解

因篇幅有限，在此不做证明。

相似对角化需要利用矩阵的特征值 和特征向量 ，其满足：

等号右侧可以乘上单位矩阵 来变形：

由于 故

这其实就是一个关于 的多项式方程，实际上等号左边被称为矩阵的特征多项式。由于本文以二阶方阵为例，因此特征多项式是一元二次的，那么就有两个根 ，这两个根都是矩阵的特征值。将 回代即可得求出特征向量 ，每个 均对应无穷多组解 。

回到相似对角化，可以证明，如果一个矩阵是可以相似对角化的，那么必然有下面的相似对角化方案：

其中 是任意一个特征值 对应的非零特征向量。其中 被称为特征矩阵。当且仅当 两两不同时，矩阵 可逆，读者自证不难。解线性方程组和求逆矩阵都可以通过高斯消元法，限于篇幅，这里就不展开了。

接下来仍然以斐波那契数列为例。以 为首项。有矩阵通项公式（其中 表示不重要的元素，下同）：

转移矩阵的特征多项式、特征值和特征向量：

相似对角矩阵和特征矩阵：

特征矩阵的逆：

相似对角化求幂次：

于是我们就得到了通项公式：

接下来就是写代码了。方便起见，后文就以 作为首项……（说实话我也不知道我为啥要在这里绕来绕去，但是懒得改了）我们有通项公式：

如果只是要某一项的值的话，那直接在浮点数环境下计算就可以了。事实上，我们可以发现一个常数对半砍的公式：

其中 表示四舍五入到整数。这是由于 ，因此四舍五入可以忽略这部分影响。更加激进的，根据工程经验（其实是懒得误差分析），由于 ，下面的公式可以完美作为通项公式：

代码也很好实现，适用于不需要取模的情况：

float qpow(float x, int n) {
    float r = 1;
    while (n) {
        if (n & 1)
            r *= x;
        x *= x, n >>= 1;
    }
    return r;
}

int fib(int n) {
    return round(0.447 * qpow(1.618, n));
}

但是如果你的需求是斐波那契数列取模，因为涉及到 ，那就比较复杂了。第一想法是二次剩余，但是 在很多常见模数下没有二次剩余（如果你不知道什么是二次剩余，可以简单的理解为模意义下的平方根，这是数论的内容）。如果你了解过抽象代数或者代数数论，你肯能会想到一个东西——二次整数环。

二次整数环

二次整数环就是所有由整数加上一个特殊无理数后，通过加减乘得到的数所组成的集合。这些数不仅保留了整数环的性质，还可以在更广的范围内进行带余除法等操作。如果你学过复数，那就像复数是由实数和虚数部分组成一样，二次整数环是由整数和一个特定的无理数（如 ）的整数倍组合而成的数，这通常表示为 。二次整数环 上的运算和二次根式运算是一致的：

1. 加减法：
2. 乘法：

由于除法较为复杂而且我们现在用不到，就不做讨论了。在模意义下，每次计算完分别对整数部分和根式部分的系数取模即可，这实际上构成了二次整数环的剩余类环，一般记作 ， 是模数。在模意义下二次整数除以一个纯整数依旧是转化为乘上该整数的数论倒数（逆元）。除以二次整数的情况过于复杂且暂时本文用不到，就不做讨论了。

接下来就是愉快的代码实现环节：

using i64 = int64_t;

constexpr i64 m = 1e9 + 7;

template <typename num> constexpr num qpow(num a, i64 n) {
    num r = 1;
    while (n) {
        if (n & 1)
            r *= a;
        a *= a, n >>= 1;
    }
    return r;
}

struct m64 {
    i64 x;
    constexpr m64(const i64 x) : x(((x % m) + m) % m) {
    }
    constexpr operator i64() const {
        return x;
    }
    constexpr m64 operator-() const {
        return m64(-x);
    }
    constexpr m64 operator*(const m64 &o) const {
        return m64((x * o.x) % m);
    }
    constexpr m64 &operator*=(const m64 &o) {
        *this = *this * o;
        return *this;
    }
    constexpr m64 operator/(const m64 &o) const {
        return m64(*this * qpow(o, m - 2));
    }
};

struct sr5m64 {
    m64 x, s;
    constexpr sr5m64(m64 x, m64 s) : x(x), s(s) {
    }
    constexpr sr5m64(i64 x) : x(x), s(0) {
    }
    constexpr sr5m64 operator-() const {
        return sr5m64(-x, -s);
    }
    constexpr sr5m64 operator+(const sr5m64 &o) const {
        return sr5m64(x + o.x, s + o.s);
    }
    constexpr sr5m64 operator-(const sr5m64 &o) const {
        return *this + (-o);
    }
    constexpr sr5m64 operator*(const sr5m64 &o) const {
        return sr5m64(x * o.x + 5 * s * o.s, x * o.s + s * o.x);
    }
    constexpr sr5m64 &operator*=(const sr5m64 &o) {
        *this = *this * o;
        return *this;
    }
    constexpr sr5m64 operator/(const m64 &o) const {
        return sr5m64(x / o, s / o);
    }
};

constexpr m64 fib(i64 n) {
    return ((qpow(sr5m64(1, 1) / 2, n) - qpow(sr5m64(1, -1) / 2, n)) * sr5m64(0, 1) / 5).x;
}

二阶线性递推的一些性质

模意义下的周期性

任何的二阶线性递推在模 下都是具有周期性的。考虑矩阵表示中的状态模

显然状态的每一项最多只有 种，因此所有可能的状态最多有 种，所以在二阶线性递推充分多次后必然产生两个相同的状态，因此会呈现出周期性。这个结论也可以推广到任意阶线性递推。

由于求解最小正周期需要用到二项式定理等内容，在此不做展开，详情参考皮萨诺周期。一道广为流传的题目可能需要这部分知识。

斐波那契数列相邻两项之比趋于黄金分割比

黄金分割比指的是

很显然其是斐波那契数列的一个特征根。本节小标题的意思是：

直接代入通项公式暴力求极限即可：

对于一部分二阶线性递推，也能得出相似的结论。

结语

累了，就先写到这里吧…

hello i am Leo

类比一维 ST 表，我们可以用 表示左上角坐标为 ，右下角坐标为 的矩形区域的最大值，分情况将矩形区域分割为横向或纵向两部分，不难想到状态转移方程：

预处理复杂度 。查询也很简单，只要分成四块区域就可以了：

其中 表示原二维矩阵， 为左上角坐标， 为右下角坐标，，，，。查询复杂度 。

一点小优化：

用库函数来计算 效率比较低，我们可以使用下面的代码实现 计算：

const auto lb = [](const int x) -> const int { return x ? 31 - __builtin_clz(x) : 0; };

原理是利用了 __builtin_clz 内置函数来计算最高有效位的位置。具体来说，__builtin_clz(x) 返回 x 的前导零的数量，31 - __builtin_clz(x) 则计算出 x 的最高有效位的位置，从而得到 floor(log2(x)) 的值。

题目推荐

CF846D Monitor (Luogu Mirror)

请问下，

1. 本网站用的什么组件库？
2. 侧边栏是写死在布局组件中的还是在需要侧边栏的组件中引入的？
3. 评论树功能是怎么实现的？比如：
   1. 评论的子回复和孙子回复的缩进相同；
   2. 点击view x replies可以获取新回复并增量显示（就是避免显示时出现评论的重复或遗漏）。
4. 评论组件是什么？就是这种可以插入Markdown格式的内容的评论组件。
5. 向下滚动时，侧边栏不会随feed流无限滚动，这个是怎么实现的？
6. 获取哪些内容时需要用缓存？帖子详情还是首页内容？
7. 通知功能是怎么实现的？

谢谢。

dds238-1电表与USR-DR404串口服务器连接，小熊派nano开发板作为网关，连接USR-DR404串口服务器的wifi，小熊派nano开发板获得dds238-1电表的电压后，上传thingsboard云平台，小熊派开发板的代码怎么写，有人可以提供一下学习资料或者代码支援吗