刷题感悟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以字节为单位。