刷题感悟w

题目很长的一定要慢慢把题目的意思搞清楚

有重复操作不知道怎么办 可以用数组去标记

你好！在C++中，replace 函数通常是用于替换容器（例如 std::vector 或 std::string）中的特定元素的函数。以下是 std::replace 函数的一般用法：

cpp复制代码

#include <algorithm> // 包含 algorithm 头文件 int main() { std::vector<int> numbers = {1, 2, 3, 4, 2, 5}; // 使用 std::replace 替换所有等于 2 的元素为 6 std::replace(numbers.begin(), numbers.end(), 2, 6); // 打印替换后的容器内容 for (int num : numbers) { std::cout << num << " "; } return 0; }

在上面的示例中，我们包含了 <algorithm> 头文件，然后使用 std::replace 函数来将容器 numbers 中的所有值为 2 的元素替换为 6。这个函数会遍历容器，找到匹配的元素并替换它们。

注意，std::replace 不是用来替换某个特定位置的元素，而是替换容器中所有匹配的元素。如果你只想替换单个元素，可以通过索引或迭代器来访问并修改特定位置的元素。

如果你需要在字符串中替换子字符串，你可以使用 std::string 的 replace 成员函数，如下所示：

cpp复制代码

#include <iostream> #include <string> int main() { std::string text = "Hello, world! Hello, universe!"; // 使用 std::string::replace 替换所有 "Hello" 为 "Hi" size_t found = text.find("Hello"); while (found != std::string::npos) { text.replace(found, 5, "Hi"); found = text.find("Hello", found + 2); // 从下一个位置开始查找 } // 打印替换后的字符串 std::cout << text << std::endl; return 0; }

在上述示例中，我们使用 std::string::replace 函数来查找并替换字符串中的所有匹配项。

#include<iostream>

#include<string>

#include<algorithm>

using namespace std;

int main() {

string essay = "This is a sample essay with spaces";

replace(essay.begin(), essay.end(), ' ', '\0');

cout << essay;

return 0;

}

#include<iostream>

#include<string>

#include<algorithm>

using namespace std;

int main() {

string essay = "This is a sample essay with spaces";

essay.erase(remove(essay.begin(), essay.end(), ' '), essay.end());

return 0;

}

一般的，求解的个数用深搜，求最优解用广搜。

for (int k = 0; k <= 3; k++) {

if (i >= 1 && i <= n && j >= 1 && j <= m && board[i][j])

dfs(i + dir[k][0], j + dir[k][1], t - 1);

}

只要这个点没超过边界就去遍历 要快一点

struct cmp1 {

bool operator()(node x, node y) {

return x.num > y.num;

}

};

priority_queue<node, vector<node>, cmp1>q;

ios::sync_with_stdio(false); 是 C++ 中的一行代码，用于设置 C++ 的输入输出流与 C 标准 I/O 流的同步性。

在 C++ 中，默认情况下，cin 和 cout 这样的 C++ 输入输出流与 C 标准 I/O 流（例如 stdin 和 stdout）是同步的，这意味着它们共享一些状态。这种同步可能会导致性能损失，因为每当切换输入输出方式时（比如，从 cin 到 stdin 或从 cout 到 stdout），程序必须花费额外的开销来同步这些流。

通过使用 ios::sync_with_stdio(false); 可以禁用这种同步。当将其设置为 false 时，C++ 输入输出流与 C 标准 I/O 流之间的同步将被禁用，这可能会提高程序的性能，特别是在大量输入输出操作时。

然而，这样做也会带来一些风险。例如，一旦禁用同步，最好不要混合使用 C++ 输入输出流和 C 标准 I/O 流，因为它们可能会出现未定义的行为或错误。此外，禁用同步可能会导致一些特定的平台依赖问题。

总之，ios::sync_with_stdio(false); 是一个用于禁用 C++ 输入输出流与 C 标准 I/O 流同步的语句。虽然它可以提高程序性能，但同时也带来了一些潜在的风险和限制。

#define re register int

inline int read() {

int x, ff = 1;

char c = getchar();

while (c < '0' || c>'9') {

if (c == '-')ff = -1;

c = getchar();

}

while (c >= '0' && c <= '9') {

x = x << 1 + x << 3 + x ^ 48;

c = getchar();

}

return x * ff;

}

0x7f7f7f7f

• 0x 表示后面的数字是十六进制。
• 7f 在十六进制中表示二进制的 01111111。

因此，0x7f7f7f7f 转换为二进制是 01111111011111110111111101111111。

0x7fffffff;0111111111111111111111.....

：在环形问题中，可以选择(i+1)%n的方式，但也可以将n个元素复制一遍，变成2*n个元素，简化代码。

inline int read() {

register int ans = 0, register char c = getchar();

bool flag = true;

while (c < '0' || c>'9') {

if (c == '-')

flag = false;

c = getchar();

}

while (c >= '0' && c <= '9') {

ans = (ans << 3) + (ans << 1) + c - '0';

c = getchar();

}

return flag * ans;

}

两个数的积等于它们最大公约数和它们最小公倍数的积

end()成员函数返回指向末尾位置的迭代器。这个"末尾位置"指的是最后一个元素再往后一位，也就是说end()所指的位置不包含有效元素，它相当于一个虚设的节点

Iter it = myList.end();
--it;
//C++11中可以直接写成it = prev(myList.end());
//这里prev是头文件<iterator>提供的函数，用于返回将某个迭代器前移一位的结果
Iter it2 = myList.insert(it, 3);
//myList的内容：1,3,2

在C++中，std::unique() 是一个用于处理容器的算法函数，主要用于移除容器中相邻的重复元素。它通常与 std::sort() 结合使用，以确保相同的元素相邻。

tf=scanf("%c",&xg)==1?true:false;//如果下一个没有运算符了，则tf=false，既保证了此次循环的正常运行，又能在下一遍循环跳出

int getin() {

int x = 0; char ch = getchar();

while (ch < '0' || ch>'9')ch = getchar();

while (ch >= '0' && ch <= '9')x = x * 10 + ch - 48, ch = getchar();

return x;

}快速读入整数函数

bool operator < (const node&x) const { return rnd<x.rnd; } 这里的两个const的作用是什么

你好！在这个代码片段中，const 关键字有两个不同的作用：

1. 第一个 const 位于函数参数列表的最后，用于修饰成员函数，表示这个成员函数不会修改对象的成员变量。这是 C++ 中的常见做法，被称为常量成员函数。在这个特定的 operator< 函数中，这意味着它不会修改调用它的对象或对象的成员变量。

2. 第二个 const 位于函数体之前，修饰整个成员函数，表示这个函数不会修改调用对象的任何成员变量。这是一种对函数的额外承诺，可以帮助编译器进行一些优化，并防止在不应该修改对象状态的情况下发生错误的修改。

   //三个函数，感觉这样写可能会比 C++ 自带的快一些
   inline double Max(double a,double b){
   return a > b ? a : b ;
   }
   inline double Min(double a,double b){
   return a < b ? a : b ;
   }
   inline int Abs(int a,int b){
   if(a>b)
   return a-b;
   return b-a;
   }

最短最小 广度 下一点等于上一点+1

改变枚举顺序也是提高效率的好方法

fill(begin,end,value)

void *memset(void *ptr, int value, size_t num);

其中：

• ptr是指向要设置数值的内存起始地址的指针。
• value是要设置的值，通常是一个无符号字符型（unsigned char）的整数。
• num是要设置的字节数。
• getchar_unlocked()函数比getchar()函数更快。

  template< class ForwardIt, class T >
  void replace( ForwardIt first, ForwardIt last, const T& old_value, const T& new_value );

参数说明：

• first 和 last 是迭代器，表示容器中要替换的元素的范围，闭区间为 [first, last)。
• old_value 是要被替换的元素。
• new_value 是替换后的新元素。
• void replaceSubstring(string& str, string olds, string news) {
  int pos = 0;
  while ((pos = str.find(olds, pos) != string::npos)) {
  str.replace(pos, olds.length(), news);
  pos += news.length();
  }
  }
• 搜索的剪枝，做标记，遍历过的跳过

  std::fill(arr, arr + size, 1);

std::fill 函数可以将一个范围内的元素都设置为指定的值。在这里，我们将数组 arr 的所有元素（从 arr 开始的 size 个元素）都设置为1。

使用 std::

深度优先搜索的时候 某个点的值要由周围推过来时，先dfs()周围的点，然后根据周围点来求该点

dfs(nextr, nextc);

s[r][c] = max(s[r][c], s[nextr][nextc] + 1);

但是dp要考虑无后效性。这就是为什么要用priority_queue，先算较低的点，对后面算高的点没有影响。最后遍历一遍整个地图，求出最高的一个点。 有影响。

两个数组。

class MyFunc { public: int operator()(int x, int y) { return x + y; } }; int main() { MyFunc func; int result = func(3, 4); // 等价于调用 func.operator()(3, 4); // result = 7 }

静静静静静静静静静静心心心............................................................................................。

深度优先搜索需要什么参数先搞清楚

状态哪里来

int* arr = (int*)malloc(10 * sizeof(int))

arr = (int*)realloc(arr, 20 * sizeof(int))

void *calloc(size_t n, size_t size);

其中，n表示要分配的元素个数，size表示每个元素的大小，函数返回一个指向已分配内存起始地址的指针。与malloc不同的是，calloc会在分配内存后将其初始化为0。size以字节为单位。

transform(str1.rbegin(), str1.rend(), num1.begin(), [](char c) { return c - '0'; });

transform(str2.rbegin(), str2.rend(), num2.begin(), [](char c) { return c - '0'; });

lambda表达式

[capture list] (parameters) -> return type { // 函数体 }

[]:空捕获列表,表示不捕获任何外部变量

[var]:捕获指定的变量var,可以是局部变量,函数参数或全局变量。

[=]值捕获,表示以值捕获所有外部变量。

[&]引用捕获,表示以引用的方式捕获所有外部变量

[var1,var2]:捕获多个变量

(Parameters):Lambda表达式可以接受参数,参数列表与普通参数的参数列表类似，可以指定参数的类型，也可以使用auto进行自动类型推导

返回类型(Return Type):Lambda表达式的返回类型可以根据函数体自动推导,也可以显示指定返回类型,可以auto进行自动推导类型，或者箭头符号->指定返回类型

Lambda表达式还可以作为算法的参数，例如STL中的std::sort、std::for_each等算法函数都可以接受Lambda表达式作为比较器或操作函数。

[]：空捕获列表，表示不捕获任何外部变量。

[var]：捕获指定的变量var，可以是局部变量、函数参数或全局变量。

[=]：值捕获，表示以值的方式捕获所有外部变量。

[&]：引用捕获，表示以引用的方式捕获所有外部变量。

[var1, var2]：捕获多个变量，以逗号分隔。

分别举出一个例子

2023/11/26 19:51:07

当使用Lambda表达式时，可以根据需求选择不同的捕获方式来访问外部变量。下面是一些示例：

空捕获列表[]，表示不捕获任何外部变量：

cpp

int main() {

int x = 10;

// Lambda表达式没有捕获任何外部变量

auto lambda = []() {

// 在Lambda函数体中无法访问外部变量x

// do something

};

lambda(); // 调用Lambda表达式

return 0;

}

捕获指定的变量var，可以是局部变量、函数参数或全局变量：

cpp

int main() {

int x = 10;

// 捕获外部变量x

auto lambda = [x]() {

// 在Lambda函数体中可以访问外部变量x

// do something with x

};

lambda(); // 调用Lambda表达式

return 0;

}

值捕获[=]，表示以值的方式捕获所有外部变量：

cpp

int main() {

int x = 10;

int y = 20;

// 值捕获所有外部变量

auto lambda = [=]() {

// 在Lambda函数体中可以访问外部变量x和y，但不能修改它们

// do something with x and y

};

lambda(); // 调用Lambda表达式

return 0;

}

引用捕获[&]，表示以引用的方式捕获所有外部变量：

cpp

int main() {

int x = 10;

int y = 20;

// 引用捕获所有外部变量

auto lambda = [&]() {

// 在Lambda函数体中可以访问并修改外部变量x和y

x++;

y++;

};

lambda(); // 调用Lambda表达式，修改了x和y的值

return 0;

}

捕获多个变量，以逗号分隔：

cpp

int main() {

int x = 10;

int y = 20;

int z = 30;

// 捕获多个外部变量x、y和z

auto lambda = [x, &y, &z]() {

// 在Lambda函数体中可以访问x的值，修改y和z的值

x++; // 修改不会影响外部x的值

y++;

z++;

};

lambda(); // 调用Lambda表达式，修改了y和z的值

return 0;

}