刷题感悟w

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

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

你好!在C++中,replace 函数通常是用于替换容器(例如 std::vectorstd::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::stringreplace 成员函数,如下所示:

 

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 fill( ForwardIt first, ForwardIt last, const T& 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;
}

想一想stl库里的函数

bool merge1(int x, int y) {
    x = find(x);
    y = find(y);
    if (x != y)return false;
    return true;//一定要有返回值,不然就是随便一个值了
}

并查集一定要初始化加入一个减一个

根据数据的范围定数据的类型,别一上来就乱写

  • 第一个参数是元素的类型,指定要存储在优先级队列中的数据类型。
  • 第二个参数是底层容器的类型,指定用于存储元素的容器类型。
  • 第三个参数是比较函数,用于确定元素之间的优先级关系,以确定队列中的排序方式。

priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int,int>>>;

int gcd(int a, int b) {
    if (b == 0)return a;
    int r = a % b;
    while (r)a = b, b = r, r = a % b;
    return b;
}

string ds(ull x) {
    if (x == 0)return "";
    string s = ds(x >> 1);
    s.push_back((x & 1) + '0');
    return s;
}

精度处理
例如:我们想要程序判别 0.1+0.2 == 0.3
1.比较法
取等式差值的绝对值小于某一个特别小的数,若差值小于特别小的数则条件成立,反之。

if( fabs(0.2 + 0.1 -0.3) <= 1E-10 ) //一般1的负10次方够用了
        cout<<"true"<<endl;     
    else 
        cout<<"false"<<endl;

B. StORage room (位运算结论可记住:一个数组,a[i] | a[j]得到一个n*n的矩阵,求这个数组,用pow(2,30)-1 & 矩阵的第i行得到一个数即为这个数组的第i个)

其中2^30-1的二进制为1111111...... 

map

主要数据范围啊,开longlong

直接return或者break会导致剩余数据给下一次的

相同的数异或为0

#include<iostream>
using namespace std;
inline void writeInt(int x) {
    if (x < 0) {
        putchar('-');
        x = -x;
    }
    static int buf[21], top;
    while (x) {
        buf[++top] = x % 10;
        x /= 10;
    }
    if (!top)buf[++top] = 0;
    while (top)putchar(buf[top-- ]+'0');
}
int main() {
    writeInt(222);
    return 0;
}

  • 16
    点赞
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值