C/C++ on 蛋蛋忧桑

ST稀疏表 (Sparse Table)

Wed, 20 Aug 2025 15:23:59 +0800

稀疏表常用于解决RMQ问题（区间最大/小值查询问题），稀疏表仅支持高效的查询操作，并不支持动态修改操作。其实现主要基于倍增思想和动态规划。

稀疏表最主要的思想就是将区间分为两个子区间，例如[l,r]分成[l,l+2^k-1]和[r-2^k+1,r]，其中k=log2(r-l+1)向下取整。

其本质上就是用两个长度为 2^k 的重叠区间覆盖 [l,r]，那我们查询区间最值就可以分解为两个子区间最值中的较大/小值，即max[l,r]=max(max[l,l+2^k-1],max[r-2^k+1,r])。

我们用二维数组构造稀疏表，大小为f[N][log2(N)+1]，其中f[i][j]=max[i,i+2^j-1]，状态转移方程为f[i][j]=max(f[i][j-1],f[i+2^(j-1)][j-1]);

vector dt(N);
vector> f(N,vector(log2(N)+1));

void init(int n){
 for(int i=0;i<n;i++) f[i][0]=dt[i];
 for(int j=1;(1<<j)<=n;j++){
 for(int i=0;i+(1<<j)-1<n;i++){
 f[i][j]=max(f[i][j-1],f[i+(1<<(j-1))][j-1]);
 }
 }
}

int query(int l,int r){
 int k=log2(r-l+1);
 return max(f[l][k],f[r-(1<<k)+1][k]);
}

算法竞赛读入数据相关操作

Sat, 05 Apr 2025 02:08:01 +0800

读入带空格的字符串

char str[1024];
scanf("%[^\n]",&str); // 读取到'\n'为止，不读入'\n'
getchar(); // 清除'\n'

int num;
string str;
cin >> num; // 读取数字
cin.ignore(); // 跳过数字后的'\n'
getline(cin, line); // 读取整行输入,包括换行符'\n'，但'\n'不会存储在 line 中。

循环读入

// 快速读取整数（C风格）
int num;
while (scanf("%d", &num) != EOF) { ... }

// 逐字符读取
char ch;
while ((ch = getchar()) != EOF) { ... }

int num;
string line;

// 读取数字
while (cin >> num) { ... }

// 读取行
while (getline(cin, line)) { ... }

快读

int read() {
 int x = 0, f = 1;
 char ch = getchar();
 while (ch '9') { if (ch == '-') f = -1; ch = getchar(); }
 while (ch >= '0' && ch 
- **`%[abc]`**：只读取 `a`、`b` 或 `c`，遇到其他字符停止。

- **`%[^abc]`**：读取直到遇到 `a`、`b` 或 `c` 为止。

- **`%[^\n]`**：读取整行（直到 `\n`，但不包括 `\n`）。c复制char str[100]; scanf("%[^\n]", str); // 读取一行（不含换行符） getchar(); // 吃掉残留的 \n**注意**：`%[^\n]` 不会自动限制长度，容易缓冲区溢出，建议用 `%99[^\n]` 限制。

```cpp
char str[100];
scanf("%[^\n]", str); // 读取一行（不含换行符）
getchar(); // 吃掉残留的 \n

**(2) 跳过输入 `%*`**

%*d：读取但不存储整数（跳过该输入）。

int a, b;
scanf("%d %*d %d", &a, &b); // 输入 "1 2 3"，a=1, b=3（跳过 2）

(3) 宽度限制 `%Ns`

%5s：最多读取 5 个字符（防止缓冲区溢出）。

char name[10];
scanf("%9s", name); // 最多读 9 个字符（留 1 位给 '\0'）

(4) 混合输入数字和字符串

scanf 不会自动跳过空白字符（如 \n、），需要手动处理：

int a;
char c;
scanf("%d", &a); // 读取整数
scanf(" %c", &c); // 注意前面的空格，跳过空白符

(5) 检测输入结束（EOF）

scanf 返回成功读取的变量个数，EOF 表示输入结束：

int num;
while (scanf("%d", &num) != EOF) {
 // 处理 num
}

`printf` 的高级用法

(1) 格式化输出

格式	作用	示例	输出
%5d	固定宽度 5 位（右对齐）	printf("%5d", 123);	123
%-5d	固定宽度 5 位（左对齐）	printf("%-5d", 123);	123
%05d	不足 5 位补 0	printf("%05d", 123);	00123
%.2f	保留 2 位小数	printf("%.2f", 3.14159);	3.14
%x / %X	十六进制（小写/大写）	printf("%x", 255);	ff
%o	八进制	printf("%o", 8);	10
%p	指针地址	printf("%p", &a);	0x7ffd…

(2) 动态指定宽度/精度

用 * 动态传入宽度或精度：

int width = 5, precision = 2;
printf("%*.*f", width, precision, 3.14159); // 输出 " 3.14"

(3) 输出 `%` 符号

用 %% 输出 %：

printf("Success rate: 100%%"); // 输出 "Success rate: 100%"

(4) 打印字符串（限制长度）

%.5s：只打印前 5 个字符：

printf("%.5s", "Hello World"); // 输出 "Hello"

(5) 对齐 + 填充

左对齐 + 填充 -：

printf("%-10s", "Hello"); // 输出 "Hello "

右对齐 + 填充 0：

printf("%05d", 42); // 输出 "00042"

双指针&前缀和

Mon, 31 Mar 2025 22:24:08 +0800

acwing799最长连续不重复子序列

#include
using namespace std;

const int N=1e5+10;
int n;
int q[N];
int cnt[N];

int main()
{
 std::ios::sync_with_stdio(0);
 std::cin.tie(0);

 cin>>n;
 for(int i=1;i>q[i];
 int res=0;
 for(int i=1,j=1;i1)
 {
 cnt[q[j]]--;
 j++;
 }
 res=max(res,i-j+1);
 }
 cout
using namespace std;

const int N=1e5+10;
int n,m;
int a[N],s[N];

int main()
{
 cin>>n>>m;
 for(int i=1;i>a[i];
 s[i]=s[i-1]+a[i];
 }
 while(m--)
 {
 int l,r;
 cin>>l>>r;
 cout
using namespace std;

const int N=1010;
int n,m,k;
int q[N][N],s[N][N];

int main()
{
 cin>>n>>m>>k;
 for(int i=1;i>q[i][j];
 s[i][j]=s[i-1][j]+s[i][j-1]-s[i-1][j-1]+q[i][j];
 }
 }
 while(k--)
 {
 int x1,y1,x2,y2;
 cin>>x1>>y1>>x2>>y2;
 cout
using namespace std;

const int N=1e5+10;
int n,m,x;
int a[N],b[N];

int main()
{
 cin>>n>>m>>x;
 for(int i=1;i>a[i];
 for(int i=1;i>b[i];
 for(int i=1,j=m;i=1&&a[i]+b[j]>x) j--;
 if(a[i]+b[j]==x)
 {
 cout
using namespace std;

const int N=2e5+10;
int n,C;
int q[N];

int main()
{
 std::ios::sync_with_stdio(0);
 std::cin.tie(0);

 cin>>n>>C;
 for(int i=1;i>q[i];
 }
 sort(q+1,q+n+1);
 long long cnt=0;
 for(int a=1,b1=1,b2=1;a=C)
 {
 b1++;
 }
 while(b2C)
 {
 b2++;
 }
 cnt+=b1-b2;
 }
 cout
using namespace std;

const int N=1e5+10;
int n;
int a[N],b[N],c[N];

int main()
{
 cin>>n;
 for(int i=1;i>a[i];
 for(int i=1;i>b[i];
 for(int i=1;i>c[i];

 sort(a+1,a+1+n);
 sort(b+1,b+1+n);
 sort(c+1,c+1+n);

 long long res=0;
 for(int i=1,IndexA=1,IndexC=1;i
using namespace std;

const int N=5e4+10;
int n,K;
int a[N];
int cnt_lr[N],cnt_rl[N];

int main()
{
 cin>>n>>K;
 for(int i=1;i>a[i];
 sort(a+1,a+1+n);
 for(int i=1,j=1;iK)j++;
 cnt_lr[i]=max(cnt_lr[i-1],i-j+1);
 }
 for(int i=n,j=n;i>=1;i--)
 {
 while(j>=i&&a[j]-a[i]>K)j--;
 cnt_rl[i]=max(cnt_rl[i+1],j-i+1);
 }
 int res=0;
 for(int i=1;i<=n-1;i++)
 {
 res=max(res,cnt_lr[i]+cnt_rl[i+1]);
 }
 cout<<res<<endl;
 return 0;
}

二分查找与二分答案

Fri, 28 Mar 2025 16:39:26 +0800

原题单链接：https://www.luogu.com.cn/training/111#problems

AcWing789. 数的范围

#include 
using namespace std;

const int N = 1e5 + 10;
int n, q, a[N];

int bs1(int x)
{
 int l = -1, r = n;
 while (l + 1 != r)
 {
 int mid = l + r >> 1;
 if (a[mid] > 1;
 if (a[mid] > n >> q;
 for (int i = 0; i > a[i];
 }
 while (q--)
 {
 int x;
 cin >> x;
 int res1 = bs1(x);
 if (res1 == -1)
 {
 cout 
using namespace std;

double n;

int main()
{
 cin>>n;
 double l=-100,r=100;
 // while(r-l>1e-8)
 for(int i=0;i
using namespace std;

const int N=1e6+10;
int n,m;
int a[N];

int main()
{
 cin>>n>>m;
 for(int i=1;i>a[i];
 }
 while (m--)
 {
 int x;
 cin>>x;
 int l=0,r=n+1;
 while (l+1!=r) // l+1>1;
 if(a[mid]
using namespace std;

const int N=2e5+10;
int n,C;
int q[N];

int bs1(int x)
{
 int l=0,r=n+1;
 while(l+1>n>>C;
 for(int i=1;i>q[i];
 }
 sort(q+1,q+n+1);
 long long cnt=0;
 for(int B=1;B
using namespace std;

const int N=1e6+10;
int n,m;
int q[N];

bool check(int x)
{
 long long sum=0;
 for(int i=1;i=m)return true;
 }
 if(sum>=m)return true;
 else return false;
}

int main()
{
 cin>>n>>m;
 for(int i=1;i>q[i];
 }
 int l=0,r=4e5;
 while(l+1
using namespace std;

const int N = 1e5 + 10;
int n, k;
int q[N];

bool check(int x)
{
 int sum = 0;
 for (int i = 1; i = k)
 return true;
 else
 return false;
}

int main()
{
 cin >> n >> k;
 for (int i = 1; i > q[i];
 }
 int res = 0, sum = 0;
 int l = 0, r = 1e8;
 while (l + 1 
using namespace std;

const int N=5e4+10;
int L,n,m;
int q[N];

bool check(int x)
{
 int cnt=0;
 int i=0,now=0;
 while(i>L>>n>>m;
 for(int i=1;i>q[i];
 }
 q[n+1]=L;

 int l=0,r=L+1;
 while(l+1
using namespace std;

const int N=1e5+10;
int L,n,k;
int q[N],s[N];

bool check(int x)
{
 int cnt=0;
 for(int i=1;ix)
 {
 cnt++;
 int num=s[i]-x;
 while (num>x)
 {
 cnt++;
 num-=x;
 }
 // cnt+=num/x-1;
 // if(num%x)cnt++;
 }
 }
 if(cnt>L>>n>>k;
 for(int i=1;i>q[i];
 s[i]=q[i]-q[i-1];
 }
 q[n+1]=L;
 s[n+1]=L-q[n];
 int l=0,r=1e7+1;
 while(l+1<r)
 {
 int mid=(l+r)/2;
 if(check(mid))r=mid;
 else l=mid;
 }
 if(check(l))cout<<l<<'\n';
 else cout<<r<<'\n';
 return 0;
}

动态规划做题步骤

Mon, 24 Mar 2025 11:26:18 +0800

原题单链接：https://rentry.org/ozd34yrn

例题

重述问题
找到最后一步
去掉最后一步，是否能划分出子问题
考虑边界

746. 使用最小花费爬楼梯

const int N=1010;

class Solution {
public:
 int mem[N];
 int dfs(vector& cost, int x)
 {
 if(mem[x])return mem[x];

 int sum=0;
 if(x==1||x==0)sum=0;
 else sum=min(dfs(cost,x-1)+cost[x-1],dfs(cost,x-2)+cost[x-2]);
 mem[x]=sum;
 return sum;
 }

 int minCostClimbingStairs(vector& cost) {
 int n=cost.size();
 // int ans=dfs(cost,n);
 int f[N];
 f[0]=f[1]=0;
 for(int i=2;i& nums, int x) {
 if (mem[x])
 return mem[x];

 int res = 0;
 for (int i = 0; i & nums) {
 int n = nums.size();
 int res=-1e9;
 // for(int i=0;i& coins, int amount) {
 if (mem[amount])
 return mem[amount];
 int n = coins.size();
 if (amount == 0)
 return 0;
 int res = 1e9;
 for (int i = 0; i = coins[i])
 res = min(res, dfs(coins, amount - coins[i]) + 1);
 }
 mem[amount] = res;
 return res;
 }

 int coinChange(vector& coins, int amount) {
 int n = coins.size();
 // int ans = dfs(coins, amount);
 // ans=ans==1e9?-1:ans;
 int f[N];
 memset(f, 0x3f, sizeof f);
 f[0] = 0;
 for (int i = 1; i =coins[j])
 f[i]=min(f[i], f[i-coins[j]] + 1);
 }
 }
 return f[amount]>1e9?-1:f[amount];
 }
};

剑指 Offer 42. 连续子数组的最大和

const int N=100010;

class Solution {
public:
 int mem[N];
 int dfs(vector& sales,int x)
 {
 if(x& sales) {
 int n=sales.size();
 int f[N];
 int ans=-101;
 // for(int i=0;i<n;i++)
 // {
 // ans=max(ans,dfs(sales,i));
 // }
 f[0]=sales[0];
 for(int i=1;i<n;i++)
 {
 f[i]=max(sales[i],f[i-1]+sales[i]);
 }
 for(int i=0;i<n;i++)
 {
 ans=max(ans,f[i]);
 }
 return ans;
 }
};

343. 整数拆分

const int N=110;

class Solution {
public:
 int mem[N]={0};
 int dfs(int x)
 {
 if(mem[x])return mem[x];
 if(x==0)return 1;

 int res=0;
 for(int i=1;i<x;i++)
 {
 res=max(res,max(i*(x-i),dfs(x-i)*i));
 }
 return mem[x]=res;
 }

 int integerBreak(int n) {
 int ans;
 // ans=dfs(n);
 int dp[N];
 dp[0] = dp[1] = 1;
 for (int i = 2; i <= n; ++i) {
 for (int j = 1; j < i; ++j) {
 dp[i] = max(dp[i], max(j * (i - j), dp[i - j] * j));
 }
 }
 ans=dp[n];
 return ans;
 }
};

下期待更新的dp题单（2024.2.25编）

413. 等差数列划分如果满足等差，则f[i] = f[i - 1] + 1, 否则为0

279. 完全平方数简单预处理，最后一步：选择某个数作为最后一个

646. 最长数对链最长上升子序列模板 + 排序

918. 环形子数组的最大和找找最大和、最小和和总和的关系

376. 摆动序列考虑相邻两个数大小问题，枚举选哪个模型，dp转移可以直接01转移

2786. 访问数组中的位置使分数最大枚举每个数选或不选，记录上的数的奇偶性，01转移实现dfs不需要传vector的参数

213. 打家劫舍 II 考虑选不选第一个物品，可以把问题分为两个子问题

368. 最大整除子集 pre数组记录路径，更新时实现记录，而不是以前的max不知道更新没更新

1105. 填充书架枚举选哪个，转移方程有教学意义

1416. 恢复数组枚举选哪个，集合转移

2400. 恰好移动 k 步到达某一位置的方法数目要对mem数组做偏移，`mem[now + N][cnt]` ，选其中一个的思路

1335. 工作计划的最低难度枚举选哪个思路，集合转移

7006. 销售利润最大化集合转移，预处理endi，选或不选

1235. 规划兼职工作选或不选 1751. 最多可以参加的会议数目 II 类似 2054. 两个最好的不重叠活动

01转移

376. 摆动序列考虑相邻两个数大小问题，枚举选哪个模型，dp转移可以直接01转移

2786. 访问数组中的位置使分数最大枚举每个数选或不选，记录上的数的奇偶性

1186. 删除一次得到子数组最大和子数组最大和 + 记录删没删

2369. 检查数组是否存在有效划分划分型dp 好像用不了记忆化搜索？

并查集

Sat, 22 Mar 2025 12:08:20 +0800

#include 
using namespace std;

const int N = 10010;
int fa[N];

inline void init(int n)
{
 for (int i = 1; i > n >> m;
 init(n);
 for (int i = 1; i > child >> parent;
 merge(child, parent);
 }
 for (int i = 1; i <= n; i++)
 {
 cout << find(i) << " ";
 }
 return 0;
}

前缀和

Sat, 22 Mar 2025 11:58:17 +0800

#include
using namespace std;

const int N = 10010;
int a[N], s[N];
int n;

int main(){
 cin >> n;
 for (int i = 1; i > a[i];
 s[i] = s[i - 1] + a[i];
 }
 for(int i = 1; i <= n; i ++ ){
 cout << s[i] << " ";
 }
 return 0;
}

背包问题

Sat, 22 Mar 2025 10:31:12 +0800

01背包问题

#include 
#include 
#include 

using namespace std;

const int N = 1010;

int n, m;
int v[N], w[N];
int f[N];
int g[N];

int main()
{
 scanf("%d %d", &n, &m);
 for (int i = 1; i = 1; i--)
 // {
 // for (int j = 0; j = v[i])
 // {
 // g[j] = max(f[j], f[j - v[i]] + w[i]);
 // }
 // }
 // memcpy(f, g, sizeof g);
 // }
 // cout= v[i])
 // {
 // g[j] = max(f[j], f[j - v[i]] + w[i]);
 // }
 // }
 // memcpy(f, g, sizeof g);
 // }
 // cout = 0; j--)
 // {
 // if (j >= v[i])
 // {
 // f[j] = max(f[j], f[j - v[i]] + w[i]);
 // }
 // }
 // }
 // cout = 1; i--)
 {
 for (int j = m; j >= 0; j--)
 {
 if (j >= v[i])
 {
 f[j] = max(f[j], f[j - v[i]] + w[i]);
 }
 }
 }
 cout 
using namespace std;

const int N = 1010;

int n, m;
int v[N], w[N];
int mem[N][N];
int f[N][N];
int g[N];

int dfs(int x, int spV)
{
 if (mem[x][spV])
 return mem[x][spV];

 int sum = 0;
 if (x > n)
 sum = 0;
 else if (spV > n >> m;
 for (int i = 1; i > v[i] >> w[i];

 // int res=dfs(1,m);
 // cout 
using namespace std;

const int N = 1010;

int n, V, M;
int v[N], m[N], w[N];
int mem[N][110][110];
int f[N][110][110];
int g[110][110];

int dfs(int x, int spV, int spM)
{
 if (mem[x][spV][spM])
 return mem[x][spV][spM];

 int sum = 0;
 if (x > n)
 sum = 0;
 else if (spV > n >> V >> M;
 for (int i = 1; i > v[i] >> m[i] >> w[i];

 // int res=dfs(1,V,M);
 // cout= 1; i--)
 // for (int j = 0; j = v[i]; j--)
 // for (int k = M; k >= m[i]; k--)
 // {
 // g[j][k] = max(g[j][k], g[j - v[i]][k - m[i]] + w[i]);
 // }
 // cout = 1; i--)
 for (int j = V; j >= v[i]; j--)
 for (int k = M; k >= m[i]; k--)
 {
 g[j][k] = max(g[j][k], g[j - v[i]][k - m[i]] + w[i]);
 }
 cout << g[V][M] << endl;

 return 0;
}

动态规划入门

Sat, 22 Mar 2025 01:52:48 +0800

原题单链接：https://rentry.org/2f76axt4

见到很有意思的问题 : 以往见过许多教材，对动态规划（DP）的引入属于“奉天承运，皇帝诏曰”式：不给出一点引入，见面即拿出一大堆公式吓人；学生则死啃书本，然后突然顿悟。针对入门者的教材不应该是这样的。(看到一位知乎的大佬说的, 深有感悟~)

动态规划 就是 : 给定一个问题，我们把它拆成一个个子问题，直到子问题可以直接解决。然后把子问题的答案保存起来，以减少重复计算。再根据子问题答案反推，得出原问题解的一种方法.

那么我们今天就来带给大家 新手入门动态规划的正确方法!

记忆化搜索 = 暴力dfs + 记录答案

动态规划入门思路: dfs暴力 — 记忆化搜索 — 递推

1dfs > 2记忆化搜索 > 3逆序递推 > 4顺序递推 > 5优化空间 !

递归的过程:

“递” 的过程是: 分解子问题的过程;

“归” 的过程才是: 产生答案的过程;

“递” – 自顶向下, “归” – 自底向上 ，其中 “底” 是 递归搜索树 的底

写出递推公式的方法:

递推的公式 = dfs 向下递归的公式

递推数组的初始值 = 递归的边界

例题

acwing821.跳台阶 \或者\ P1255. 数楼梯

#include 

using namespace std;

const int N = 100;
int n;
int f[N];

int main()
{
 f[1] = 1, f[2] = 2;
 cin >> n;
 int newf = 0, tmp1 = 1, tmp2 = 2;
 for(int i = 3; i 

using namespace std;

const int N = 100010;
int n, T;
int home[N];
int men[N];
int f[N];

int dfs(int x)
{
 if (men[x])
 return men[x];

 int sum = 0;
 if (x > n)
 sum = 0;
 else
 sum = max(dfs(x + 1), dfs(x + 2) + home[x]);

 men[x] = sum;
 return sum;
}

int main()
{
 cin >> T;
 while (T--)
 {
 memset(men, 0, sizeof men);
 cin >> n;
 for (int i = 1; i > home[i];
 }
 // int res = dfs(1);
 // cout = 1; i--)
 // {
 // f[i] = max(f[i+1],f[i+2]+home[i]);
 // }
 // cout 

using namespace std;

const int N = 1010;
int n;
int g[N][N];
int mem[N][N];
int f[N][N];
int h[N];

int dfs(int x, int y)
{
 if (mem[x][y])
 return mem[x][y];

 // if (x>n||y>n) return 0;
 // // 求 最优子问题 dfs(x)=max(dfs(x+1),dfs(x+2))
 // // 求 子问题的和 dfs(x)=dfs(x+1)+dfs(x+2)
 // else return max(dfs(x+1,y),dfs(x+1,y+1))+g[x][y];
 int sum = 0;
 if (x > n || y > n)
 sum = 0;
 else
 sum = max(dfs(x + 1, y), dfs(x + 1, y + 1)) + g[x][y];
 mem[x][y] = sum;
 return sum;
}

int main()
{
 cin >> n;
 for (int i = 1; i > g[i][j];
 // int res = dfs(1, 1);
 // cout = 1; i -- )
 // for (int j = 1; j = 1; i--)
 // for (int j = 1; j = 1; i--)
 for (int j = 1; j 
#include 
#include 

using namespace std;

const int N = 1010;

int n, m;
int v[N], w[N];
int res = 0;

void dfs(int x, int sumV, int sumW)
{
 if (x > n)
 {
 if (sumV = res)
 {
 res = sumW;
 }
 return;
 }

 // 不选
 dfs(x + 1, sumV, sumW);

 // 选
 if (sumV + v[x] 
#include 
#include 

using namespace std;

const int N = 1010;

int n, m;
int v[N], w[N];
int res = 0;
int mem[N][N];
int f[N][N];
int g[N];

int dfs(int x, int spV)
{
 if (mem[x][spV])
 {
 return mem[x][spV];
 }

 int sum = 0;
 if (x > n)
 {
 sum = 0;
 }
 else if (spV = v[x])
 {
 sum = max(dfs(x + 1, spV), dfs(x + 1, spV - v[x]) + w[x]);
 }
 mem[x][spV] = sum;
 return sum;
}

int main()
{
 scanf("%d %d", &n, &m);
 for (int i = 1; i = 1; i--)
 // {
 // for (int j = 0; j = v[i])
 // {
 // f[i][j] = max(f[i + 1][j], f[i + 1][j - v[i]] + w[i]);
 // }
 // }
 // }
 // cout= v[i])
 {
 f[i][j] = max(f[i - 1][j], f[i - 1][j - v[i]] + w[i]);
 }
 }
 }
 cout 

## 下期待更新的dp题单（2024.2.25编）

### [LCR 091. 粉刷房子](https://leetcode.cn/problems/JEj789/) 简单dp

### [413. 等差数列划分](https://leetcode.cn/problems/arithmetic-slices/) 如果满足等差，则f[i] = f[i - 1] + 1, 否则为0

### [279. 完全平方数](https://leetcode.cn/problems/perfect-squares/) 简单预处理，最后一步：选择某个数作为最后一个

### [91. 解码方法](https://leetcode.cn/problems/decode-ways/) 正序dfs好写

### [646. 最长数对链](https://leetcode.cn/problems/maximum-length-of-pair-chain/) 最长上升子序列模板 + 排序

### [918. 环形子数组的最大和](https://leetcode.cn/problems/maximum-sum-circular-subarray/) 找找最大和 、 最小和 和 总和的关系

### [376. 摆动序列](https://leetcode.cn/problems/wiggle-subsequence/) 考虑相邻两个数大小问题，枚举选哪个模型，dp转移可以直接**01转移**

### [2786. 访问数组中的位置使分数最大](https://leetcode.cn/problems/visit-array-positions-to-maximize-score/) 枚举每个数选或不选，记录上的数的奇偶性，**01转移** 实现dfs不需要传vector的参数

### [213. 打家劫舍 II](https://leetcode.cn/problems/house-robber-ii/) 考虑选不选第一个物品，可以把问题分为两个子问题

### [122. 买卖股票的最佳时机 II](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/) 状态机模型

### [368. 最大整除子集](https://leetcode.cn/problems/largest-divisible-subset/) pre数组**记录路径**，更新时实现记录，而不是以前的max不知道更新没更新

### [1105. 填充书架](https://leetcode.cn/problems/filling-bookcase-shelves/) 枚举选哪个，**转移方程**有教学意义

### [1416. 恢复数组](https://leetcode.cn/problems/restore-the-array/) 枚举选哪个，**集合转移**

### [2466. 统计构造好字符串的方案数](https://leetcode.cn/problems/count-ways-to-build-good-strings/) 爬楼梯

### [1043. 分隔数组以得到最大和](https://leetcode.cn/problems/partition-array-for-maximum-sum/) 枚举选哪个，**集合转移**

### [2400. 恰好移动 k 步到达某一位置的方法数目](https://leetcode.cn/problems/number-of-ways-to-reach-a-position-after-exactly-k-steps/) 要对mem数组做偏移，`mem[now + N][cnt]` ，选其中一个的思路

### [1335. 工作计划的最低难度](https://leetcode.cn/problems/minimum-difficulty-of-a-job-schedule/) 枚举选哪个思路，**集合转移**

### [7006. 销售利润最大化](https://leetcode.cn/problems/maximize-the-profit-as-the-salesman/) **集合转移**， 预处理endi，选或不选

### [2008. 出租车的最大盈利](https://leetcode.cn/problems/maximum-earnings-from-taxi/) 选或不选

### [1235. 规划兼职工作](https://leetcode.cn/problems/maximum-profit-in-job-scheduling/) 选或不选 [1751. 最多可以参加的会议数目 II](https://leetcode.cn/problems/maximum-number-of-events-that-can-be-attended-ii/) 类似 [2054. 两个最好的不重叠活动](https://leetcode.cn/problems/two-best-non-overlapping-events/)

## 01转移

### [376. 摆动序列](https://leetcode.cn/problems/wiggle-subsequence/) 考虑相邻两个数大小问题，枚举选哪个模型，dp转移可以直接01转移

### [2786. 访问数组中的位置使分数最大](https://leetcode.cn/problems/visit-array-positions-to-maximize-score/) 枚举每个数选或不选，记录上的数的奇偶性

### [122. 买卖股票的最佳时机 II](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/) 状态机模型

### [1186. 删除一次得到子数组最大和](https://leetcode.cn/problems/maximum-subarray-sum-with-one-deletion/) 子数组最大和 + 记录删没删

### [2369. 检查数组是否存在有效划分](https://leetcode.cn/problems/check-if-there-is-a-valid-partition-for-the-array/) **划分型dp** 好像用不了记忆化搜索？

### [2466. 统计构造好字符串的方案数](https://leetcode.cn/problems/count-ways-to-build-good-strings/) 爬楼梯

C++的cin和cout取消同步

Mon, 10 Mar 2025 21:56:59 +0800

C++的cin和cout加快读写速度，用以下代码：

std::ios::sync_with_stdio(false);
std::cin.tie(0);

BFS 广度优先搜索 ( Breadth-First-Search )

Sun, 02 Mar 2025 19:02:19 +0800

原题单链接：https://www.luogu.com.cn/paste/sa0zary9 || https://rentry.org/3r68rga7

广度优先搜索算法(Breadth First Search)，又称为"宽度优先搜索", BFS是用于图的查找算法(要求能用图表示出问题的关联性)。

BFS可用于解决2类问题：

1.从A出发是否存在到达B的路径；DFS也可求

2.从A出发到达B的最短路径；数据小20以内的话, DFS也不是不可以题眼

整体思路

其思路为从图上一个节点出发，访问先访问其直接相连的子节点，若子节点不符合，再问其子节点的子节点，按级别顺序(一层一层)依次访问，直到访问到目标节点。

步骤

起始：将起点（源点，树的根节点）放入队列中
扩散：从队列中取出队头的结点，将它的相邻结点放入队列，不断重复这一步
终止：当队列为空时，说明我们遍历了所有的能到的结点，整个图能到的点都被搜索了一遍

时空复杂度

时间复杂度 : 最差情形下，BFS必须寻找所有到可能节点的所有路径，因此其时间复杂度为O(|V| + |E|)，其中|V|是节点的数目，而|E|是图中边的数目。

空间复杂度 : BFS的空间复杂度为 O(B^h)，其中B是最大分支系数，而h是树的最长路径长度(树的高度) 。由于对空间的大量需求，因此BFS并不适合解非常大的问题。

对于所有边长度相同的情况，比如地图的模型，bfs第一次遇到目标点，此时就一定是从根节点到目标节点最短的路径（因为每一次所有点都是向外扩张一步，你先遇到，那你就一定最短）。bfs先找到的一定是最短的。但是如果是加权边的话这样就会出问题了，bfs传回的是经过边数最少的解，但是因为加权了，这个解到根节点的距离不一定最短。比如1000+1000是只有两段，1+1+1+1有4段，由于bfs返回的经过边数最少的解，这里会返回总长度2000的那个解，显然不是距离最短的路径。此时我们就应该采用Dijkstra最短路算法解决加权路径的最短路了。

SPFA

例题

acw844. 走迷宫 ,

#include 

#define x first
#define y second

using namespace std;

const int N = 110;
typedef pair pii;

int n,m;
int g[N][N];
int dist[N][N];
queue q;

int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};

int bfs(int sx,int sy)
{
 memset(dist,-1,sizeof dist); // -1 means not visited
 q.push({sx,sy});
 dist[sx][sy]=0; // start point

 while (q.size()&&!q.empty()) // while queue is not empty
 {
 auto t=q.front();
 q.pop();

 for (int i = 0; i n||bm) continue; // out of bound
 if(g[a][b]!=0) continue; // if there is a wall
 if(dist[a][b]>0) continue; // if already visited

 q.push({a,b}); // push the next point
 dist[a][b]=dist[t.x][t.y]+1;

 if(a==n&&b==m)
 {
 return dist[a][b];
 }
 }
 }
 return dist[n][m];
}

int main()
{
 cin >> n >> m;
 for(int i=1;i> g[i][j];
 }
 }
 int res=bfs(1,1);
 cout 若打不开这个题就看这个 [P1746 离开中山路](https://www.luogu.com.cn/problem/P1746)

代码见下文。


# 习题课

### 热身 - 简单迷宫问题

#### [P1746 离开中山路](https://www.luogu.com.cn/problem/P1746) 1

```cpp
#include 

using namespace std;

typedef pair pii;

const int N=1010;
int n;
int mx1,my1,mx2,my2;
char g[N][N];
int dist[N][N];
int res;
queue q;

int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};

int bfs(int x,int y)
{
 memset(dist,-1,sizeof(dist));
 q.push({x,y});
 dist[x][y]=0;

 while (!q.empty())
 {
 auto t=q.front();
 q.pop();

 for(int i=0;in||bn)continue;
 if(g[a][b]!='0')continue;
 if(dist[a][b]>=0)continue;

 q.push({a,b});
 dist[a][b]=dist[t.first][t.second]+1;

 if(a==mx2&&b==my2)
 {
 return dist[a][b];
 }
 }
 }
 return dist[mx2][my2];
}

int main()
{
 cin>>n;
 for(int i=1;i>g[i][j];
 }
 }
 // for(int i=1;i>g[i]+1;
 // }
 cin>>mx1>>my1;
 cin>>mx2>>my2;
 res=bfs(mx1,my1);
 cout

using namespace std;
typedef pair pii;

const int N=410;
int n,m,x,y;
int dist[N][N];
pii q[N*N];

int dx[]={-2,-1,1,2,2,1,-1,-2};
int dy[]={1,2,2,1,-1,-2,-2,-1};

void bfs(int x,int y)
{
 memset(dist,-1,sizeof(dist));
 q[0]={x,y};
 dist[x][y]=0;
 int hh=0,tt=0;

 while(hhn||bm)continue;
 if(dist[a][b]>=0)continue;

 dist[a][b]=dist[t.first][t.second]+1;
 q[++tt]={a,b};
 }
 }
}

int main()
{ 
 scanf("%d %d %d %d",&n,&m,&x,&y);
 bfs(x,y);
 for(int i=1;i

using namespace std;

typedef pair pii;

const int N=510;
int n,m,a,b;
int dist[N][N];
pii q[N*N];

int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};
int hh=0,tt=-1;

void bfs()
{
 while(hhn||bm)continue;
 if(dist[a][b]>=0)continue;

 dist[a][b]=dist[t.first][t.second]+1;
 q[++tt]={a,b};
 }
 }
}

int main()
{ 
 cin>>n>>m>>a>>b;
 memset(dist,-1,sizeof(dist));
 while(a--)
 {
 int x,y;
 cin>>x>>y;
 q[++tt]={x,y};
 dist[x][y]=0;
 }
 bfs();
 while(b--)
 {
 int x,y;
 cin>>x>>y;
 cout

using namespace std;

typedef pair pii;

const int N=40;
int n;
int g[N][N];
bool st[N][N];
pii q[N*N];

int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};

void bfs(int x,int y)
{
 q[0]={x,y};
 st[x][y]=true;
 int hh=0,tt=0;

 while(hhn+1||bn+1)continue;
 if(st[a][b])continue;
 if(g[a][b]==1)continue;

 st[a][b]=true;
 q[++tt]={a,b};
 }
 }

 return;
}

int main()
{ 
 cin>>n;
 for(int i=1;i>g[i][j];
 }
 }
 bfs(0,0);
 for(int i=1;i

using namespace std;

typedef pair pii;

const int N=310;

int m;
int dist[N][N];
int fire[N][N];
pii q[N*N];

int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};

int bfs()
{
 q[0]={0,0};
 dist[0][0]=0;
 int hh=0,tt=0;

 while(hh=0)continue; // 已访问过
 if(dist[t.first][t.second]+1>=fire[a][b])continue; // 预先检查，如果被砸死了就不用管这个点了

 dist[a][b]=dist[t.first][t.second]+1;
 q[++tt]={a,b};

 if(fire[a][b]==0x3f3f3f3f)return dist[a][b];
 }
 }
 return -1;
}

int main()
{ 
 cin>>m;
 memset(fire,0x3f,sizeof(fire));
 memset(dist,-1,sizeof(dist));
 while (m--)
 {
 int x,y,t;
 cin>>x>>y>>t;
 fire[x][y]=min(t,fire[x][y]);
 for(int i=0;i301||b301)continue;
 fire[a][b]=min(t,fire[a][b]);
 }
 }
 int res=bfs();
 cout

using namespace std;

typedef pair pii;

const int N = 510;
int m, n;
int high[N][N];
int flag[N][N];
int cnt_flag = 0;
pii q[N * N];
int x = 0, y = 0;
bool st[N][N];

int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};

bool check(int mid)
{
 q[0] = {x, y};
 st[x][y]=true;
 int cnt = 1;
 int hh = 0, tt = 0;

 while (hh m || b n)
 continue;
 if (st[a][b])
 continue;
 if (abs(high[t.first][t.second] - high[a][b]) > mid)
 continue;

 q[++tt] = {a, b};
 st[a][b] = true;

 if (flag[a][b] == 1)
 {
 cnt++;
 if (cnt == cnt_flag)
 {
 return true;
 }
 }
 }
 }
 return false;
}

int main()
{
 cin >> m >> n;
 for (int i = 1; i > high[i][j];
 }
 }
 for (int i = 1; i > flag[i][j];
 if (flag[i][j] == 1)
 {
 cnt_flag++;
 }
 }
 }
 for (int i = 1; i 

using namespace std;

int g[2][4];
unordered_map dist;
unordered_map> pre;
queue q;

void set1(string state)
{
 for (int i = 0; i = 0; i--, j++)
 {
 g[1][i] = state[j];
 }
}

string get1()
{
 string res;
 for (int i = 0; i = 0; i--)
 {
 res += g[1][i];
 }
 return res;
}

// 交换上下两行，A
string move0(string state)
{
 set1(state);
 for (int i = 0; i 0; i--)
 {
 g[0][i] = g[0][i - 1];
 g[1][i] = g[1][i - 1];
 }
 g[0][0] = v0, g[1][0] = v1;
 return get1();
}

// 中央四个元素顺时针旋转，C
string move2(string state)
{
 set1(state);
 char v0 = g[0][1], v1 = g[0][2], v2 = g[1][2], v3 = g[1][1];
 g[0][1] = v3, g[0][2] = v0, g[1][2] = v1, g[1][1] = v2;
 return get1();
}

int bfs(string start, string end)
{
 q.push(start);
 dist[start] = 0;
 while (q.size())
 {
 auto t = q.front();
 q.pop();

 if (t == end)
 {
 return dist[t];
 }

 string m[3];
 m[0] = move0(t), m[1] = move1(t), m[2] = move2(t);
 for (int i = 0; i > x)
 {
 end += char(x + '0');
 }
 int res = bfs(start, end);
 cout 

using namespace std;

typedef pair pii;

const int N = 510;
int n,m,xx1,yy1,xx2,yy2;
char g[N][N];
int dist[N][N];
deque q;

int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};

int bfs(int x,int y)
{
 q.push_back({x,y});
 dist[x][y]=0;

 while (q.size())
 {
 auto t=q.front();
 q.pop_front();
 char ch=g[t.first][t.second];

 for (int i = 0; i =n||b=m)continue;
 if(dist[a][b]>=0)continue;

 if(g[a][b]==ch)
 {
 dist[a][b]=dist[t.first][t.second];
 q.push_front({a,b});
 }

 if(g[a][b]!=ch)
 {
 dist[a][b]=dist[t.first][t.second]+1;
 q.push_back({a,b});
 }

 if(a==xx2&&b==yy2)return dist[xx2][yy2];
 }
 }
 return -1;
}

int main()
{
 while (cin >> n >> m, n != 0 && m != 0)
 {
 for (int i = 0; i > g[i];
 }
 memset(dist,-1,sizeof(dist));
 q.clear();
 cin>>xx1>>yy1>>xx2>>yy2;
 int res =bfs(xx1,yy1);
 cout

using namespace std;

typedef pair pii;
const int N=1100;

int n;
char g[N][N];
int dist[N][N];
int vis[N][N];
pii q[N*N];
int xx1,yy1,xx2,yy2;

int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};

int bfs()
{
 memset(dist,-1,sizeof(dist));
 memset(vis,-1,sizeof(vis));

 dist[xx1][yy1]=0,dist[xx2][yy2]=0;
 vis[xx1][yy1]=1,vis[xx2][yy2]=2;
 q[0]={xx1,yy1},q[1]={xx2,yy2};
 int hh=0,tt=1;

 while(hhn||bn)continue;
 if(g[a][b]!='0')continue;

 if(vis[a][b]+vis[t.first][t.second]==3)
 {
 return dist[t.first][t.second]+dist[a][b]+1;
 }

 if(dist[a][b]>=0)continue;

 dist[a][b]=dist[t.first][t.second]+1;
 if(vis[a][b]==-1)vis[a][b]=vis[t.first][t.second];
 q[++tt]={a,b};
 }
 }
 return -1;
}

int main()
{
 cin>>n;
 for(int i=1;i>g[i]+1;
 }
 cin>>xx1>>yy1>>xx2>>yy2;
 int res=bfs();
 cout

using namespace std;

string end1="123804765";
unordered_map umap;
queue q;

int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};

int bfs(string st)
{
 q.push(st);
 umap[st]=0;

 while(q.size())
 {
 auto t=q.front();
 q.pop();

 if(t==end1)return umap[t];
 int distance=umap[t];

 int a=t.find('0');
 int xx1=a/3,yy1=a%3; //一维数组下标转换为二维数组下标

 for (int i = 0; i =3||yy2=3)continue;
 int tmp=xx2*3+yy2;
 swap(t[a],t[tmp]);

 if(!umap.count(t))
 {
 umap[t]=distance+1;
 q.push(t);
 }
 swap(t[a],t[tmp]);
 }
 }
 return -1;
}

int main()
{
 string start1;
 cin>>start1;
 int res=bfs(start1);
 cout

```cpp
#include 

using namespace std;

string start1;
string end1="123804765";
queue q;
unordered_map dist;
unordered_map vis;

int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};

int bfs(string st)
{
 dist[st]=0;
 dist[end1]=0;
 q.push(st),q.push(end1);
 vis[st]=1,vis[end1]=2;

 while(q.size())
 {
 auto t=q.front();
 q.pop();

 int distance=dist[t];
 int flag=vis[t];

 int a=t.find('0');
 int xx1=a/3,yy1=a%3; //一维数组下标转换为二维数组下标

 for (int i = 0; i =3||yy2=3)continue;
 int tmp=xx2*3+yy2;
 swap(t[a],t[tmp]);

 if(vis[t]+flag==3)
 {
 int res1=dist[t];
 swap(t[a],t[tmp]);
 int res2=dist[t];
 return res1+res2+1;
 }
 if(!dist.count(t))
 {
 dist[t]=distance+1;
 vis[t]=flag;
 q.push(t);
 }
 swap(t[a],t[tmp]);
 }
 }
 return -1;
}

int main()
{
 cin>>start1;
 if(start1==end1)
 {
 cout

## 作业 (上节课DFS过不去, 这节课可以用BFS试一试~)

#### [P1135 奇怪的电梯](https://www.luogu.com.cn/problem/P1135) dfs暴力过不去

### **Flood fill** --- **找连通块**

#### [P1596 Lake Counting S](https://www.luogu.com.cn/problem/P1596)

#### [P1451求细胞数量](https://www.luogu.com.cn/problem/P1451)

#### [P1331 海战](https://www.luogu.com.cn/problem/P1331)

#### [P1767 家族](https://www.luogu.com.cn/problem/P1767)

#### [SP15436 UCV2013H - Slick](https://www.luogu.com.cn/problem/SP15436)

### 迷宫问题

#### [P1683 入门](https://www.luogu.com.cn/problem/P1683)

#### [P1605 迷宫](https://www.luogu.com.cn/problem/P1605)

#### [P1443 马的遍历](https://www.luogu.com.cn/problem/P1443)

#### [P1747 好奇怪的游戏](https://www.luogu.com.cn/problem/P1747)

#### [P2298 Mzc和男家丁的游戏](https://www.luogu.com.cn/problem/P2298)

# 关于memset和0x3f

int a[100];

### memset(a,0x3f,sizeof(a) );

0x3f=0011 1111=63

C++中**int**型变量所占的位数为**4个字节**，即32位

0x3f显然不是int型变量中单个字节的最大值，应该是0x7f=0111 1111 B

**那为什么要赋值0x3f ??**

int

### 1.作为无穷大使用

因为4个字节均为0x3f时，0x3f3f3f3f的十进制是1061109567，也就是10^ 9级别的（和0x7fffffff一个数量级），而一般场合下的数据都是小于10^9的，所以它可以作为无穷大使用而不致出现数据大于无穷大的情形。

### 2.可以保证无穷大加无穷大仍然不会超限。

另一方面，由于一般的数据都不会大于10^9，所以当我们把无穷大加上一个数据时，它并不会溢出（这就满足了**“无穷大加一个有穷的数依然是无穷大”**），事实上0x3f3f3f3f+0x3f3f3f3f=2122219134，这非常大但却没有超过32-bit int_MAX的表示范围，所以0x3f3f3f3f**还满足了我们“无穷大加无穷大还是无穷大”的需求**。

首先要知道memset函数是**以字节为单位**进行赋值的；

#### void memset(void *s, int ch, size_t n)\;

函数解释：将s中前n个字节 （typedef unsigned int size_t ）用 ch 替换并返回 s 。

其实这里面的ch就是ascii为ch的字符；

将s所指向的某一块内存中的前n个 字节的内容全部设置为ch指定的ASCII值

递推与递归 DFS深度优先搜索

Thu, 27 Feb 2025 11:30:18 +0800

原题单链接：https://www.luogu.com/paste/vjf2z3hi || https://rentry.org/5yhk52ow

例题

跳台阶

#include 
using namespace std;
const int N=1e5;
int a[N];

int f(int n)
{
 if(a[n])return a[n];
 if(n==1)return 1;
 if(n==2)return 2;
 a[n]=f(n-1)+f(n-2);
 return a[n];
}

int main()
{
 int n;
 cin>>n;
 cout
using namespace std;

const int N=20;
int st[N];
int maxn;

void dfs(int n) // n 表示当前走到第n个位置，1表示不选，2表示选，0表示还没选
{
 if(n>maxn){
 for(int i=1;i>maxn;
 dfs(1);
 return 0;
}

递归实现排列型枚举

#include 
using namespace std;

const int N=20;

int n;
bool st[N];
int arr[N];

void dfs(int x)
{
 if(x>n){
 for(int i=1;i>n;
 dfs(1);
 return 0;
}

递归实现组合型枚举

#include 
using namespace std;

const int N=25;

int n,r;
int arr[N];

void dfs(int x,int start)
{
 if(x>r){
 for(int i=1;i>n>>r;
 dfs(1,1);
 return 0;
}

P1036 选数

#include 
using namespace std;

const int N=25;

int n,k;
int arr[N],xn[N];
int ans=0;

bool isprime(int x)
{
 if(xk)
 {
 int sum=0;
 for (int i = 1; i >n>>k;
 for(int i=1;i>xn[i];
 }
 dfs(1,1);
 cout
using namespace std;

const int N = 20;

int n;
int arr[N];
int ans = 0;
vector> ansarr;

void dfs(int x, int sum)
{
 if (sum > n)
 {
 return;
 }

 if (x > 10)
 {
 if (sum == n)
 {
 ans++;
 vector temp;
 for (int i = 1; i > n;
 dfs(1, 0);
 cout 
using namespace std;

const int N = 6;

int n,m;
int arr[N],mars[N],res=0;
bool st[N];

void dfs(int x)
{
 if(x>n)
 {
 res++;
 if(res==m+1)
 for (int i = 1; i > n >> m;
 for(int i = 1; i > mars[i];
 }
 dfs(1);
 return 0;
}

P1149 火柴棒等式指数 + 预处理

#include 
using namespace std;

int n;
int num[10010] = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6};
int a[5];
int ans = 0;

int col(int x){
 if(num[x]){
 return num[x];
 }
 else{
 int tempsum = 0;
 while(x){
 tempsum += num[x % 10];
 x /= 10;
 }
 return tempsum;
 }
}

void dfs(int x,int sum)
{
 if (sum > n-4)
 {
 return;
 }
 if (x > 3)
 {
 if (a[1] + a[2] == a[3] && sum == n - 4)
 {
 ans++;
 }
 return;
 }

 for (int i = 0; i > n;
 for (int i = 10; i 
using namespace std;

int n;
int s[15];
int b[15];
int st[15];
int ans = 1e9;

void dfs(int x)
{
 if (x > n)
 {
 bool has_tl = false;
 int sums = 1;
 int sumb = 0;
 for (int i = 1; i > n;
 for (int i = 1; i > s[i] >> b[i];
 }
 dfs(1);
 cout 
using namespace std;

int n, a, b;
int k[210];
bool st[210];
int ans[210];

void dfs(int x, int cnt)
{
 // if (cnt >= ans)
 // return;
 if (x n)
 return;

 // if (x == b)
 // {
 // ans = min(ans, cnt);
 // return;
 // }

 ans[x] = cnt;
 // 上楼
 if (x + k[x] 0 && !st[x - k[x]] && cnt + 1 > n >> a >> b;
 for (int i = 1; i > k[i];
 }
 dfs(a, 0);
 if (ans[b] == 1e9)
 ans[b] = -1;
 cout 
using namespace std;

const int N = 25;
char g[N][N];
int w, h;
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};
bool vis[N][N];
int res=0;

void dfs(int a, int b)
{
 for(int i=0;i= h || y = w)continue;
 if(g[x][y] != '.')continue;
 if(vis[x][y])continue;
 vis[x][y] = true;
 res++;
 dfs(x, y);
 }
}

int main()
{
 cin >> w >> h;
 for (int i = 0; i > g[i][j];
 for (int i = 0; i 
using namespace std;

const int N = 110;
int n, m;
char g[N][N];
bool st[N][N];
int res = 0;
int dx[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
int dy[8] = {-1, 0, 1, 1, 1, 0, -1, -1};

void dfs(int x, int y)
{
 for(int i = 0; i = n || b = m)
 {
 continue;
 }
 if(g[a][b] == 'W' && !st[a][b])
 {
 st[a][b] = true;
 dfs(a, b);
 }
 }
}

int main()
{
 cin >> n >> m;
 for (int i = 0; i > g[i][j];
 }
 }
 for (int i = 0; i 
using namespace std;

const int N = 10;
int n, k;
char g[N][N];
bool st[N];
int res = 0;

void dfs(int x, int cnt)
{
 if (cnt == k)
 {
 res++;
 return;
 }
 if (x >= n)
 return;
 for (int i = 0; i > n >> k, n > 0 && k > 0)
 {
 for (int i = 0; i > g[i];
 res = 0;
 dfs(0, 0);
 cout 
using namespace std;

const int N = 10;
int n, k;
int ans = 0;
int arr[N];

void dfs(int x, int start, int sum)
{
 if (sum > n)
 return;
 if (x > k)
 {
 if (sum == n)
 {
 ans++;
 }
 return;
 };
 for (int i = start; sum + i * (k - x + 1) > n >> k;
 dfs(1, 1, 0);
 cout 
using namespace std;

const int N = 25;
int n;
int ans = 0;
int used[N];
string s[N];
int g[N][N];

// dragon: the current dragon string
// x: the current index of the string
void dfs(string dragon, int x)
{
 ans = max(ans, (int)dragon.size());

 used[x]++;
 for(int i=0;i> n;
 for (int i = 0; i > s[i];
 }
 char start;
 cin >> start;

 for (int i = 0; i < n; i++)
 for (int j = 0; j < n; j++)
 {
 string a=s[i],b=s[j];
 for (int k = 1; k < min(a.size(),b.size()); k++)
 {
 if (a.substr(a.size()-k,k)==b.substr(0,k))
 {
 g[i][j]=k;
 break;
 }
 }
 
 }
 for (int i = 0; i < n; i++)
 {
 if (s[i][0] == start)
 {
 dfs(s[i], i);
 }
 }
 cout << ans << '\n';
 return 0;
}

最大公因数（GCD）和最小公倍数（LCM）

Tue, 18 Feb 2025 01:24:30 +0800

// 计算两个数的 GCD
int gcd(int a, int b)
{
 while (b) // b!=0
 {
 int r = a % b;
 a = b;
 b = r;
 }
 return a;
}

// 计算两个数的 LCM
int lcm(int a, int b)
{
 return a / gcd(a, b) * b; // 先除后乘，避免溢出
}

// 计算三个数的 GCD
int gcd3(int a, int b, int c) {
 return gcd(gcd(a, b), c);
}

// 计算三个数的 LCM
int lcm3(int a, int b, int c) {
 return lcm(lcm(a, b), c);
}

C/C++ on 蛋蛋忧桑

ST稀疏表 (Sparse Table)

算法竞赛读入数据相关操作

读入带空格的字符串

循环读入

快读

(2) 跳过输入 %*

(3) 宽度限制 %Ns

(4) 混合输入数字和字符串

(5) 检测输入结束（EOF）

printf 的高级用法

(1) 格式化输出

(2) 动态指定宽度/精度

(3) 输出 % 符号

(4) 打印字符串（限制长度）

(5) 对齐 + 填充

双指针&前缀和

acwing799最长连续不重复子序列

二分查找与二分答案

AcWing789. 数的范围

P1182数列分段 Section II

P1163银行贷款

P3743小鸟的设备

动态规划做题步骤

例题

下期待更新的dp题单（2024.2.25编）

LCR 091. 粉刷房子 简单dp

413. 等差数列划分 如果满足等差，则f[i] = f[i - 1] + 1, 否则为0

279. 完全平方数 简单预处理，最后一步：选择某个数作为最后一个

91. 解码方法 正序dfs好写

646. 最长数对链 最长上升子序列模板 + 排序

918. 环形子数组的最大和 找找最大和 、 最小和 和 总和的关系

376. 摆动序列 考虑相邻两个数大小问题，枚举选哪个模型，dp转移可以直接01转移

2786. 访问数组中的位置使分数最大 枚举每个数选或不选，记录上的数的奇偶性，01转移 实现dfs不需要传vector的参数

213. 打家劫舍 II 考虑选不选第一个物品，可以把问题分为两个子问题

122. 买卖股票的最佳时机 II 状态机模型

368. 最大整除子集 pre数组记录路径，更新时实现记录，而不是以前的max不知道更新没更新

1105. 填充书架 枚举选哪个，转移方程有教学意义

1416. 恢复数组 枚举选哪个，集合转移

2466. 统计构造好字符串的方案数 爬楼梯

1043. 分隔数组以得到最大和 枚举选哪个，集合转移

2400. 恰好移动 k 步到达某一位置的方法数目 要对mem数组做偏移，mem[now + N][cnt] ，选其中一个的思路

1335. 工作计划的最低难度 枚举选哪个思路，集合转移

7006. 销售利润最大化 集合转移， 预处理endi，选或不选

2008. 出租车的最大盈利 选或不选

1235. 规划兼职工作 选或不选 1751. 最多可以参加的会议数目 II 类似 2054. 两个最好的不重叠活动

01转移

376. 摆动序列 考虑相邻两个数大小问题，枚举选哪个模型，dp转移可以直接01转移

2786. 访问数组中的位置使分数最大 枚举每个数选或不选，记录上的数的奇偶性

122. 买卖股票的最佳时机 II 状态机模型

1186. 删除一次得到子数组最大和 子数组最大和 + 记录删没删

2369. 检查数组是否存在有效划分 划分型dp 好像用不了记忆化搜索？

2466. 统计构造好字符串的方案数 爬楼梯

并查集

前缀和

背包问题

动态规划入门

递归的过程:

写出递推公式的方法:

例题

acwing821.跳台阶 \或者\ P1255. 数楼梯

C++的cin和cout取消同步

BFS 广度优先搜索 ( Breadth-First-Search )

BFS可用于解决2类问题：

整体思路

步骤

时空复杂度

例题

递推与递归 DFS深度优先搜索

例题

P1149 火柴棒等式 指数 + 预处理

最大公因数（GCD）和最小公倍数（LCM）

**(2) 跳过输入 `%*`**

(3) 宽度限制 `%Ns`

`printf` 的高级用法

(3) 输出 `%` 符号

LCR 091. 粉刷房子简单dp

413. 等差数列划分如果满足等差，则f[i] = f[i - 1] + 1, 否则为0

279. 完全平方数简单预处理，最后一步：选择某个数作为最后一个

91. 解码方法正序dfs好写

646. 最长数对链最长上升子序列模板 + 排序

918. 环形子数组的最大和找找最大和、最小和和总和的关系

376. 摆动序列考虑相邻两个数大小问题，枚举选哪个模型，dp转移可以直接01转移

2786. 访问数组中的位置使分数最大枚举每个数选或不选，记录上的数的奇偶性，01转移实现dfs不需要传vector的参数

1105. 填充书架枚举选哪个，转移方程有教学意义

1416. 恢复数组枚举选哪个，集合转移

2466. 统计构造好字符串的方案数爬楼梯

1043. 分隔数组以得到最大和枚举选哪个，集合转移

2400. 恰好移动 k 步到达某一位置的方法数目要对mem数组做偏移，`mem[now + N][cnt]` ，选其中一个的思路

1335. 工作计划的最低难度枚举选哪个思路，集合转移

7006. 销售利润最大化集合转移，预处理endi，选或不选

2008. 出租车的最大盈利选或不选

1235. 规划兼职工作选或不选 1751. 最多可以参加的会议数目 II 类似 2054. 两个最好的不重叠活动

376. 摆动序列考虑相邻两个数大小问题，枚举选哪个模型，dp转移可以直接01转移

2786. 访问数组中的位置使分数最大枚举每个数选或不选，记录上的数的奇偶性

1186. 删除一次得到子数组最大和子数组最大和 + 记录删没删

2369. 检查数组是否存在有效划分划分型dp 好像用不了记忆化搜索？

2466. 统计构造好字符串的方案数爬楼梯

P1149 火柴棒等式指数 + 预处理