刷题感悟w_代码007

本文介绍: 题目很长的一定要慢慢把题目的意思搞清楚有重复操作不知道怎么办可以用数组去标记你好！在C++中，replace 函数通常是用于替换容器（例如或）中的特定元素的函数。以下是函数的一般用法：c p p 复制代码在上面的示例中，我们包含了头文件，然后使用函数来将容器numbers中的所有值为 2 的元素替换为 6。这个函数会遍历容器，找到匹配的元素并替换它们。注意，不是用来替换某个特定位置的元素，而是替换容器中所有匹配的元素。如果你只想替换单个元素，可以通过索引或迭代器来访问并修改特定位置的元素。

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

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

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

c p p 复制代码

#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<io stream>
#include<str ing>
#include<algorithm>
using namespace std;
int main() {
   string essay = “This is a sa mple essay with spac es“;
   replace(essay.begin(), essay.end(), ‘ ‘, ”);
   cout << essay;
   return 0;
}

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int main() {
   string essay = “This is a sample essay with spac es“;
   essay.erase(remo ve(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 = get char();
   while (c < ‘0’ || c>’9′) {
       if (c == ‘-‘)ff = -1;
       c = get char();
   }
   while (c >= ‘0’ && c <= ‘9’) {
       x = x << 1 + x << 3 + x ^ 48;
       c = get char();
   }
   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 = get char();
   bool flag = true;
   while (c < ‘0’ || c>’9′) {
       if (c == ‘-‘)
           flag = false;
       c = get char();
   }
   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 关键字有两个不同的作用：

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