CCF-CSP认证考试准备第十天

最新推荐文章于 2024-11-09 13:08:09 发布
最新推荐文章于 2024-11-09 13:08:09 发布
阅读量496 收藏 10
点赞数 3
分类专栏： CCF-CSP认证 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80044595/article/details/141871878
版权


### Day10: 1.202206-2 2.202209-2(先放一下) 3.202212-2

#### 1.202206-2:寻宝！大冒险！(枚举，稀疏数组,犯了一个边界判断逻辑错误，只有60，改正即为100) 
(1)一开始漏了绿化图是0但宝藏图是1的这种情况，但加上去只有60分
思路：宝藏图很大，只要存储几个为1的点的坐标即可，有点类似稀疏向量，用set存储即可快速判断一个坐标在宝藏图中是否为1（哈希思想），原来也打算用另一个set存储绿化图，但这样会存在漏了绿化图是0但宝藏图是1的这种情况，考虑绿化图不大，直接用二维数组存储即可
60分代码：
```
#include <bits/stdc++.h>

using namespace std;

int main(){
    ios::sync_with_stdio(false);
    int n,L,S;
    cin>>n>>L>>S;
    set<pair<int,int>> sTreeMap;
    int x,y;
    for(int i=0;i<n;i++){
        cin>>x>>y;
        sTreeMap.insert({x,y});
    }
    vector<vector<int>> vMap(S+1,vector<int>(S+1,0));
    for(int i=S;i>=0;i--){
        for(int j=0;j<=S;j++){
            cin>>vMap[i][j];
        }
    }
    int res=0;
    for(auto it=sTreeMap.begin();it!=sTreeMap.end();it++){
        int offx=it->first;
        int offy=it->second;
        if(offx+S>L && offy+S>L){
            continue;
        }
        bool isMap=true;
        for(int i=0;i<=S;i++){
            for(int j=0;j<=S;j++){
                x=i+offx;
                y=j+offy;
                if(vMap[i][j]==1){                            
                    if(sTreeMap.find({x,y})==sTreeMap.end()){//绿化图是1但宝藏图是0 
                        isMap=false;
                        break;
                    }
                }
                else{
                    if(sTreeMap.find({x,y})!=sTreeMap.end()){//绿化图是0但宝藏图是1 
                        isMap=false;
                        break;
                    }
                }
            }
            if(!isMap){
                break;
            }
        }
        if(isMap){
            res++;
        }
    }
    cout<<res;
    return 0;
}
```
(2)60分原因：
**边界判断**：
if(offx+S>L && offy+S>L){
    continue;
}
&&是错误的，应该为||，就是满分(**重点注意**)
(3)优化学习：
用map<pair<int,int>,int>来存储宝藏图，pair为坐标，最后一个int为值0或1，直接比较vMap[i]  [j]  是否等于mp[{x,y}]即可
代码:
```
#include <bits/stdc++.h>

using namespace std;

int main(){
    ios::sync_with_stdio(false);
    int n,L,S;
    cin>>n>>L>>S;
    map<pair<int,int>,int> mpTreeMap;
    vector<vector<int>> vMap(S+1,vector<int>(S+1,0));
    int x,y;
    for(int i=0;i<n;i++){
        cin>>x>>y;
        mpTreeMap[{x,y}]=1;
    }
    for(int i=S;i>=0;i--){
        for(int j=0;j<=S;j++){
            cin>>vMap[i][j];
        }
    }
    int res=0;
    for(auto ele:mpTreeMap){
        int offx=ele.first.first;
        int offy=ele.first.second;
        if(offx+S>L || offy+S>L){
            continue;
        }
        bool isMap=true;
        for(int i=0;i<=S;i++){
            for(int j=0;j<=S;j++){
                x=i+offx;
                y=j+offy;
                if(vMap[i][j]!=mpTreeMap[{x,y}]){
                    isMap=false;
                    break;
                }
            }
            if(!isMap){
                break;
            }
        }
        if(isMap){
            res++;
        }
    }
    cout<<res;
    return 0;
}
```

#### 2.202209-2:何以包邮？(DP,01背包问题)
(1)枚举70分:
思路：
**子集枚举**：
- 通过 `for (int i = 0; i < (1 << n); ++i)` 枚举所有子集。`(1 << n)` 表示 `2^n`，即总共有 `2^n` 种子集(数学计算得出)。
- 对于每个子集，使用 `i & (1 << j)`(**按位与操作，不是&&**) 判断第 `j` 本书是否在该子集中。如果在，则将其价格加入 `sum` 中。
**解释**:
- 当我们从 0 迭代到 2^n - 1 时，我们实际上遍历了从 `000...0` 到 `111...1` 的所有 n 位二进制数。
- 每个 n 位二进制数可以看作一个子集的表示：
    - 如果第 k 位（从右到左数）是 1，则表示该子集包含第 k 本书。
    - 如果第 k 位是 0，则表示该子集不包含第 k 本书。
**例子**： 假设 i = 5（二进制 `101`），我们想检查第 1 本书是否在子集中。
- `1 << 1` 得到 `0010`。
- 然后，`101` & `0010` 结果为 `0000`，即第 1 本书不在子集中。
**再举一个例子**，假设 i = 6（二进制 `110`），我们想检查第 2 本书是否在子集中。
- `1 << 2` 得到 `0100`。
- 然后，`110` & `0100` 结果为 `0100`，即第 2 本书在子集中。
```
#include <bits/stdc++.h>

using namespace std;

int main(){
    ios::sync_with_stdio(false);
    int n,x;
    cin>>n>>x;
    int minCost=INT_MAX;
    vector<int> v(n,0);
    for(int i=0;i<n;i++){
        cin>>v[i];
    }
    for(int i=0;i<(1<<n);i++){//i<2^n,i表示集合 
        int sum=0;
        for(int j=0;j<n;j++){
            if(i & (1<<j)){//i的j位是否为1(按位与操作),即j本书是否在此次i集合内 
                sum+=v[j];
            }
        }
        if(sum>=x){
            minCost=min(sum,minCost);
        }
    }
    cout<<minCost;
    return 0;
}
```
(2)01背包DP100分（**重点学习优化的两种思路**）:
**学习**:
(1)01背包基础:
[[DP#1.01背包：]]
目的:每种水果都有对应的两种属性：占用的体积V和蕴含的价值W。而你的背包体积为N。老板说：每种水果只能拿一个！因此对于咱们肯定得想一种搭配方式使得**拿的水果总体积不超过背包容积，但是价值总和达到最大!**
**核心: 
f[i]  [j]:表示所有选法集合中,只从前i个物品中选,并且总体积不大于j的选法的集合,它的值是这个集合中每一个选法的最大值。
对于01背包问题选择方法的集合可以分成2种：
1.不选第i个物品，并且总体积不大于j的集合所达到的最大值:f[i-1]  [j]
2.选择1~i个物品，并且总体积不大于j的集合所达到的最大值f[i]  [j]
对于第二种情况我们很难计算，因此需要思考从另一个角度解决问题。(==重点==）当选择1~i个物品，总体积不大于j的集合的最大值可以转化成选择1~i-1个物品，总体积不大于j-V[i]的集合+最后一个物品的价值：f[i-1]  [j-V[i]]+w[i]
**重点**:因此总结：f[i]  [j]= Max{f[i-1]  [j],f[i-1]  [j-v[i]]+w[i]}
(2)应用到本题:
#### 法一:
**不存在背包容量这个概念，只有背包价值，或者理解为背包容量和背包价值都是书本价格（因为限制条件和寻求最优解的都是书本价格）**
书本的总价格>=x并且 最小  
**核心转换**:可以将问题理解为 **选取几本书（所有书中题目所选的书剩下的书）使得书本的总价格<= sum - x的情况下，使得书本的总价格最大**(01背包)，所要求的花费最小值即为sum-dp里面的最大值
**`dp[i][j]`**：在前 `i` 本书中选择若干本书，总价格为 `j` 元时能够得到的最大价格。
**dp核心部分**：
```
for(int i=1;i<=n;i++){//i表示书籍索引
        for(int j=0;j<=sum-x;j++){//j表示最大价格
            if(j<vPrices[i]){//第i本书无法被选择
                dp[i][j]=dp[i-1][j];//继承前i-1本书的最大价格状态
            }
            else{//第i本书可以被选择
                dp[i][j]=max(dp[i-1][j],dp[i-1][j-vPrices[i]]+vPrices[i]);//比较不选择第i本书的最大价格和选择第i本书的最大价格
            }
            maxCost=max(maxCost,dp[i][j]);
        }
    }
```

 ![[01背包1.png]] **代码**:
 ```
 #include <bits/stdc++.h>

using namespace std;

const int N=35;
const int M=300010;
int dp[N][M];

int main(){
    ios::sync_with_stdio(false);
    int n,x;
    cin>>n>>x;
    int sum=0;
    vector<int> vPrices(n+1,0);
    for(int i=1;i<=n;i++){
        cin>>vPrices[i];
        sum+=vPrices[i];
    }
    int maxCost=-1;
    for(int i=1;i<=n;i++){
        for(int j=0;j<=sum-x;j++){
            if(j<vPrices[i]){
                dp[i][j]=dp[i-1][j];
            }
            else{
                dp[i][j]=max(dp[i-1][j],dp[i-1][j-vPrices[i]]+vPrices[i]);
            }
            maxCost=max(maxCost,dp[i][j]);
        }
    }
    cout<<sum-maxCost;
    return 0;
}
 ```
#### **法一优化**（反着求,求补集）:
将二维数组简化为一维数组(如果书本数量太多能大大优化)
在0/1背包问题中，`dp[i][j]` 仅依赖于 `dp[i-1][j]` 和 `dp[i-1][j-重量]` 的值。因此，我们可以通过逆序更新 `dp[j]`，在保证每个物品只被考虑一次的同时，使用一维数组来保存结果。
**`dp[j]` 表示：在前 `i` 本书中，选择若干本书，使得总花费恰好为 `j` 时的最大总价值。**
**重点**:
**逆序遍历的原因**：逆序遍历是为了保证在更新 `dp[j]` 时，`dp[j - vPrices[i]]` 仍然代表的是没有选择第 `i` 本书时的状态(因为这时还没有更新`dp[j - vPrices[i]]`,所以肯定不包含第i本书）。如果我们正序遍历，`dp[j - vPrices[i]]` 可能已经包含了第 `i` 本书(例如：第i本书价格为2，
 更新 `dp[2]` 时，`dp[2] = max(dp[2], dp[2 - 2] + 2) = max(0, 0 + 2) = 2
更新 `dp[4]` 时，`dp[4] = max(dp[4], dp[4 - 2] + 2) = max(0, 2 + 2) = 4`（错误，这里实际上用了当前物品两次））
这样会导致每本书被多次考虑，破坏了0/1背包的约束条件。
**代码**：
```
vector<int> dp(sum+1,0);//求最大值就全赋较小的值
for(int i=1;i<=n;i++){
    for(int j=sum;j>=vPrices[i];j--){//逆序遍历
        dp[j]=max(dp[j],dp[j-vPrices[i]]+vPrices[i]);
    }
}
cout<<sum-dp[sum-x];//输出要注意
```
**注意**：这种dp求最大值所得的dp[j]就是总花费恰好为 `j` 时的最大总价值,所以直接dp[sum-x]就是要求的最大值，与下面的解法二优化区分开来
#### 法二（较难理解）:
整个问题也可以看作是01背包问题  
**从前i本书中选择要被减掉的书，使得总价格>= x的所有选法**  
求所有选法集合中的价格最小值即是答案
![[01背包2.png]]

**`f[i][j]` 的含义**：`f[i][j]` 是动态规划状态，表示在考虑前 `i` 本书时，总花费为 `j` 元时的最小可能花费。
**注意**：因为求最小值，要提前初始化为很大的值
**代码**：
```
#include <bits/stdc++.h>

using namespace std;

const int N=35;
const int M=300010;
int dp[N][M];

int main(){
    ios::sync_with_stdio(false);
    int n,x;
    cin>>n>>x;
    vector<int> vPrices(n+1,0);
    int sum=0;
    for(int i=1;i<=n;i++){
        cin>>vPrices[i];
        sum+=vPrices[i];
    }
    for(int i=1;i<=n;i++){
        dp[i][sum]=sum;
    }
    for(int j=x;j<=sum;j++){
        dp[0][j]=sum;
    }
    int minCost=INT_MAX;
    for(int i=1;i<=n;i++){
        for(int j=sum;j>0;j--){
            if(j+vPrices[i]<=sum){
                dp[i][j]=min(dp[i-1][j],dp[i-1][j+vPrices[i]]-vPrices[i]);
            }
            else{
                dp[i][j]=dp[i-1][j];
            }
            if(dp[i][j]>=x){
                minCost=min(minCost,dp[i][j]);
            }
        }
    }
    cout<<minCost;
    return 0;
}
```
#### **法二优化**（正着求）：
**`dp[j]` 表示：在前 `i` 本书中，选择若干本书，使得总花费恰好为 `j` 时的最小总花费。**(是恰好等于，而不是大于等于)
```
#include <bits/stdc++.h>

using namespace std;

const int M = 300010;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, x;
    cin >> n >> x;

    vector<int> vPrices(n + 1, 0);
    int sum = 0;

    for (int i = 1; i <= n; i++) {
        cin >> vPrices[i];
        sum += vPrices[i];
    }

    vector<int> dp(sum + 1, M);//求最小值就全赋较大的值
    dp[0] = 0;//特殊1

    for (int i = 1; i <= n; i++) {
        for (int j = sum; j >= vPrices[i]; j--) {
            dp[j] = min(dp[j], dp[j - vPrices[i]] + vPrices[i]);
        }
    }
    //特殊2
    int res = M;
    for (int j = x; j <= sum; j++) {
        res = min(res, dp[j]);
    }

    cout << res << endl;//直接输出
    return 0;
}

```
**注意**：
这种DP方法记录总花费恰好为 `j` 时的最小总花费所得的dp[j]的值要么等于初始值M,要么等于j(因为dp[0]=0)，所以最后输出要遍历x到sum找到最小值输出，即为大于等于x，否则输出dp[x]为恰好为x元的最小价值，如果不存在恰好等于，那么dp[x]就为初始化的一个极大的值，错误
与上面的解法一优化区分开来
#### 3.202212-2:训练计划()
(1)一开始只有输出最早时间测试70分，之后加上输出最晚时间还是70分，原因如下：
每项科目最多只依赖一项别的科目，且满足依赖科目的编号小于自己，这句话不能保证一个被依赖的项目所依赖的项目只有一个，可以有多个，我用结构体int类型int backRelyIndex记录反向被依赖索引会出现覆盖问题，产生错误，可以换成数组（**单一的线性依赖关系变成复杂的依赖关系**），以及**注意计算最晚开始时间是后一个依赖索引的最晚结束时间减去前一个被依赖索引的天数**
(2)代码(100):
```
#include <bits/stdc++.h>

using namespace std;

struct Pro{
    int relyIndex;//依赖索引 
    vector<int> backRelyIndex;//反依赖索引(可以有多个,如样例2) 
    int day;
    int first;
    int end;
};

int main(){
    ios::sync_with_stdio(false);
    int n,m;
    cin>>n>>m;
    vector<Pro> v(m+1);
    for(int i=1;i<=m;i++){
        cin>>v[i].relyIndex;
        if(v[i].relyIndex!=0){
            v[v[i].relyIndex].backRelyIndex.push_back(i);
        }    
    }
    for(int i=1;i<=m;i++){
        cin>>v[i].day;    
    }
    //计算最早开始天数 
    int maxlen=-1;
    for(int i=1;i<=m;i++){
        if(v[i].relyIndex==0){
            v[i].first=1;
        }
        else{
            v[i].first=v[v[i].relyIndex].first+v[v[i].relyIndex].day;
        }
        maxlen=max(maxlen,v[i].first+v[i].day-1);
    }
    for(int i=1;i<=m;i++){
        cout<<v[i].first<<" ";
    }
    //计算最晚天数 
    if(maxlen<=n){
        cout<<endl;
        for(int i=m;i>0;i--){
            if(v[i].backRelyIndex.empty()){//没有反依赖的 
                v[i].end=n-v[i].day+1;
            }
            else{
                int minEnd=INT_MAX;//找最小的end才能满足所有 
                for(auto x:v[i].backRelyIndex){
                    minEnd=min(minEnd,v[x].end-v[i].day);//注意这边倒推的计算,是最晚开始时间是后一个依赖索引的最晚结束时间减去前一个被依赖索引的天数，且不需要加1 
                }
                v[i].end=minEnd;
            }                                                
        }
        for(int i=1;i<=m;i++){
            cout<<v[i].end<<" ";
        }
    }
    return 0;
}
```
 

爱coding的橙子
关注
专栏目录
CCF-CSP考试介绍以及复习技巧指导
巡山小妖
09-27 8万+
CCF-CSP考试时间及费用 时间一般是每年3、9、12月的中旬，报名时间一般也是提前一个月，不固定。 非计算机协会会员300元/次，会员180元/次（学生会员需缴纳50元/年的会费），相当于一年可以打三次折。 编程语言及编译器 C/C++：Dev-CPP 5.4.0 (Min GW 4.7.2) Java：Eclipse (Java SDK 1.7.0_15) Pytho...
CCF-CSP认证考试准备第一天
2301_80044595的博客
08-21 560
而使用 **`vector<bool>`** 这个结构用来跟踪变量是否被初始化，每个变量通过索引进行访问，可以在时间复杂度上将查找和插入的操作从 O(log n) 优化到 O(1)，在处理大数据量时会更加高效。对于整数请直接输出整数，**对于可能出现的小数，请输出四舍五入保留 1 位小数的结果。第一行输入一个整数 n，在第二行中存有 n 个有序的整数，表示测量数据，可能为升序或降序排列，可能存在连续多个整数相等。老师给了你一个整数组成的测量数据，保证有序（可能为升序或降序），可能存在重复的数据。
CCF-CSP认证考试准备第二天
2301_80044595的博客
08-23 525
### Day2：1.202006-1 2.202009-1 3.202012-1 4.202209-1 5.202212-1 #### 1.202006-1：线性分类器（计算几何，小模拟） （1）题目： 判断给定的直线能否将所有的 A 类点和 B 类点分隔在平面上的不同区域。判断的方法是： 1. 对于每条查询直线，计算每个点在直线上的位置。 2. 如果所有 A 类点和 B 类点分别位于直线的两侧（即符号不同），则输出 `Yes`；否则输出 `No`。 (2)知识点： 存储一堆点的二维坐标时，常见的选
CCF-CSP历年真题大全附题解(202312已更)
热门推荐
weixin_53919192的博客
05-22 16万+
各位朋友，历年的题目你们要是有不同的解法想和大家进行分享的，可以私聊我发我题目编号和代码，我也可以更新到文章中，给需要的朋友多点参考~~ CCF-CSP真题拿来练手，如果对自己没有拿高分的期望的话，可以就琢磨着写一二三题就好，三题可以就拿最基础的情况，再慢慢添东西更新代码，持续更新，博主的算力有限，努力提升进步中，写一道发一道，目前先从简单慢慢做，有想法的可以一起讨论呀~~
CCF-CSP认证考试准备第六天
2301_80044595的博客
08-27 393
*前缀和优化**：我们完全可以运用类似前缀和的方法，在选取阈值之前，通过一次正向和一次逆向遍历数组，计算出对每一个元素 stu[i]， stu[1]到stu[i-1]中 result=0 的个数和 stu[i]到stu[m]中result=1 的个数。(**注意**:前缀和和前缀积第0号元素的值要注意，不行可以自主添加)遍历两个**有序**列表（在本题中是稀疏向量的非零元素列表）时**减少不必要的比较和迭代**。**关键**:a[0][i]和a[1][i]分别记录前i个数（不包括自己）中0和1的个数。
CCF-CSP认证考试准备第十七天
2301_80044595的博客
09-18 784
5.像这种去匹配n个规则的某一个的，函数传入参数为一个规则，遍历在main函数里面写，**这题的结果string result是作为引用参数传入函数来改变的，而不是作为函数的返回结果**，因为match函数最终是起到bool判断效果判断输出结果，但在判断中途就可以改变result，所以选择为引用参数传入函数。1.规则的相邻两项之间用‘/’分开，所以我们先把所有项分开：(**重点学习**)分离字符串这里用**字符串流处理，先把所有的‘/’变为空格，然后一个一个把各项分开。// 规则是否以 '/' 结尾。
CCF-CSP认证考试准备第十三天：201909-3 字符画(大模拟)
2301_80044595的博客
09-09 717
B m` 更改终端的**前景色（字符的颜色）** 为 (R,G,B)这个根本没有用到，且本题难点就是字符串的格式输入输出以及16进制的字符与16进制的数及10进制的数之间的转换。last=init;
CCF-CSP认证考试准备第十一天
2301_80044595的博客
09-05 626
从左往右算，因为d<<n,而矩阵运算可以交换，为( (1xn) · ( (nxd)x(dxn) ) )x(nxd),从左往右算(nxd)x(dxn)=(nxn)，然后计算(nxn)x(nxd),非常麻烦,而从右往左算(dxn) x(nxd)=(dxd)，然后计算(nxd)x(dxd),大大简化。map记录（不用vector是因为开垦耗时是不连续的，稀疏的），然后类似于后缀和开垦耗时要降低一天就要`flag[i-1]+=flag[i];//flag记录开垦耗时相同的所有区域降低一天的总耗资源量。
CCF-CSP认证考试准备第五天
2301_80044595的博客
08-25 679
（2）优化学习思路：[CCF-CSP 201903-2二十四点 三种方法 满分题解 结尾附惊天方法_ccf csp真题24点-CSDN博客](https://blog.csdn.net/m0_53641110/article/details/120875227?(1)题目理解：题目只有判断一处坐标存不存在垃圾即可，即快速判断一个元素存在不存在（哈希），故而想到用set（或者用map)实现（但对于此题set更好一点，因为次数不是跟每一个元素关联的，不需要使用map键值对，只需要set判断是否存在即可）
CCF-CSP认证考试准备第十五天 202303-3 LDAP
2301_80044595的博客
09-13 636
此题和[[CCF-CSP认证考试准备第十四天 201912-3 化学方程式]]都是字符串解析，但不一样，**201912-3 化学方程式难点在于嵌套括号结合要用到栈**，但**本题难点在于如何储存用户的DN,用户所具有的属性编号和属性编号的值三者关系来条件判断，没有嵌套括号，只有一层括号，所以不需要使用栈**，**但两道题目核心都是字符串解析，先解析大的结构，然后每个大的里面解析小的结构**res.insert(shu_users[shu].begin(),shu_users[shu].end());
2020CCF-CSP-S-第一轮-C++模拟试卷(五).docx
06-08
1. CSP 考试：CCF（中国计算机学会）组织的 CSP（非专业级别软件能力认证）分为入门组（CSP-J）和提高组（CSP-S），每年举办两次，分为两轮进行。NOIP（全国青少年信息学奥林匹克联赛）自1996年开始举办，是CCF组织...
CCF-CSP认证考试介绍以及复习技巧指导
didiaola4003的博客
09-28 2214
CCF-CSP考试时间及费用 时间一般是每年3、9、12月的中旬，报名时间一般也是提前一个月，不固定。 非计算机协会会员300元/次，会员180元/次（学生会员需缴纳50元/年的会费），相当于一年可以打三次折。 编程语言及编译器 C/C++：Dev-CPP 5.4.0 (Min GW 4.7.2) Java：Eclipse (Jav...
历年CCF-CSP认证考试题目解法/思想
董公子的博客
12-02 2万+
每年的题难度都不太一样，这一点在16、17年上尤其明显，难度低的时候前两道题就是送分题，加一起15分钟解决，得分样例水的不行。难度高的时候第二题就让你模拟半天，且测试样例诡异无比，测试样例通过可能只=20分，就别说后面3,4题了。 总结一些技术点、难点： 字符串处理上：lcs(最长公共子序列)，kmp（字符串匹配算法），复杂题设计思维+注释，类的设置，数据封装，多重嵌套解法
CCF-CSP历次考试 第二题答案合集（倒序）
Timothy_Liuu的博客
10-08 3039
本文包含CCF-CSP模拟考试系统中历年考试全部第二题的答案，目前更新至202006-2。 202006-2 稀疏向量 【题目描述】 对于一个n维整数向量v∈Zn，其在第index个维度上的取值记作vindex。这里我们约定index的取值从1开始，即v=(v1,v2,…vn)。下面介绍一种向量的稀疏表示方法。 如果v仅在少量维度上的取值不为0，则称其为稀疏向量。 例如当n=10时，v=(0,0,0,5,0,0,-3,0,0,1)就是一个稀疏向量。 由于稀疏向量的非零值较少，我们可以通过仅存储非零值的方式
C++——C++11新语法（中）
Wangx_wang的博客
11-06 1040
介绍了C++11中的引用折叠、可变模板参数、类的新功能、lambda
C++_用 using 语句继承基类的构造函数
最新发布
学海无涯
11-09 228
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
常用的c++特性--＞day02
m0_69093426的博客
11-06 627
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 301
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
C++ string(2)实现精讲
Jason_from_China的博客
11-06 1709
C++ string的使用我们已经讲解了，接下来我们会讲解string的实现，但是并不是每一个我都会实现，比如string删除有好几个，但是我会删除只是实现一个erase，首先是使用的次数频繁，其次是都大差不差，没有必要实现那么多，我这里只是把string整体的逻辑给实现，对string有一个更深入的了解提升代码能力和思维能力。注意事项1。
CCF CSP历年真题集：2013-2017，含计算机编程难题
"CCF CSP计算机软件能力认证第1-10次真题，包括从2013年至2017年的历年考试题目，覆盖了模拟试题和正式考试题，涉及多种算法与编程问题。" CCF CSP（中国计算机学会软件能力认证）是一项旨在评估个人在计算机软件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值