C++操作积累

体会思想的题目：

111.二叉树的最小深度

1.问题整理

没看懂题解，（insert）

class Solution {
public:
    bool canPartitionKSubsets(vector<int>& nums, int k) {
        //排除一些特殊情况
        if(k>nums.size()){
            return false;
        }
        int sum=0;
        for(int v:nums){
            sum+=v;
        }
        if(sum%k!=0){
            return false;
        }
        int used=0;//使用位图技巧
        int target=sum/k;
        //K号桶初始什么都没装，从nums[0]开始做选择
        return backtrack(k,0,nums,0,used,target);
        


    }
    unordered_map<int,bool>memo;
    bool backtrack(int k,int bucket,vector<int>nums,int start,int used,int target){
        //base case
        if(k==0){
            return true;
        }
        if(bucket==target){
            //装满了当前桶，递归穷举下一个桶的选择
            //让下一个桶从nums[0]开始选数字
            bool res=backtrack(k-1,0,nums,0,used,target);
            //缓存结果
            memo.insert(used,res);
            return res;
        }
        if(memo.find(used)]){
            //避免冗余计算
            return memo[used];
        }
        for(int i=start;i<nums.size();i++){
            //剪枝
            if((used>>i)&1){
                //判断第i位数是否是1
                //nums[i]已经被装入别的桶中
                continue;
            }
            if(nums[i]+bucket>target){
                continue;
            }
            //做选择
            used|=1<<i;//讲i位置为1
            bucket+=nums[i];
            //递归穷举下一个数字是否装入当前桶中
            if(backtrack(k,bucket,nums,i+1,used,target)){
                return true;
        }
        //撤销选择
        used^=1<<i;//将i位置为0；
        bucket-=nums[i];

    }
    }
};

1.

l1是一个向量

int n1 = l1 ? l1->val: 0;

三目运算符,若l1不是空指针,则返回l1的value,

2.

vector<string>mat(r,string(c,0));？

【c/c++】string、vector和数组_jiangwei0512的博客-CSDN博客

3.这种for循环的形式

for(auto&row:mat){

for(char ch:row){

if(ch){

ans+=ch;

}

}

}

4.vector 用法

vector<vector<int>>sums;

sums.resize(m,vector<int>(n+1));

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        // 虚拟头结点
        ListNode dummy = new ListNode(-1), p = dummy;
        ListNode p1 = l1, p2 = l2;

        while (p1 != null && p2 != null) {
            // 比较 p1 和 p2 两个指针
            // 将值较小的的节点接到 p 指针
            if (p1.val > p2.val) {
                p.next = p2;
                p2 = p2.next;
            } else {
                p.next = p1;
                p1 = p1.next;
            }
            // p 指针不断前进
            p = p.next;
        }

        if (p1 != null) {
            p.next = p1;
        }

        if (p2 != null) {
            p.next = p2;
        }

        return dummy.next;
    }
}
// 详细解析参见：
// https://labuladong.github.io/article/?qno=21

c++数组的长度用size来判断，而不是length 

V​​​​​​利用vector实现一对一（pair＜int,int＞）_天天向上的菜鸡杰！！的博客-CSDN博客_vector<pair<int,int>>

vector 

stack

stack<int>left;

s.empty()  left.top())

出错积累：

7.24出错代码

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        //记录nums2的每个元素的下一个更大的元素
        vector<int>greater=nextGreaterElement(nums2);

        
        //转化成映射
        unordered_set<int,int>greaterMap;
        for(int i=0;i<nums2.size();i++){
            greaterMap.insert(nums2[i],greater[i]);
        }
        //nums1是nums2的子集
        vector<int>res(nums1.size());
        for(int i=0;i<nums1.size();i++){
            res[i]=greaterMap.count(nums1[i]);
        }
        return res;
    }
    //计算nums中每个元素的下一个更大的元素
    vector<int>nextGreaterElement(vector<int>nums){
        int n=nums.size();
        vector<int>res(n);
        stack<int>s;
        for(int i=n-1;i>=0;i--){
            //判定个子高矮
            while(!s.empty()&&s.top()<=nums[i]){
                s.pop();
            }
            res[i]=s.empty()?-1:s.top();
            s.push(nums[i]);
        }
        return res;
    }
};

 vector<int>ret(n,-1);/

vector<int>ret(n,-1);//n个元素=-1的数组

 106题目，想不明白哪里出错了

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
private:
    unordered_map<int,int>valToIndex;
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        for(int i=0;i<inorder.size();i++){
            valToIndex[inorder[i]]=i;

        }
        return build(inorder,0,inorder.size()-1,postorder,0,postorder.size()-1);


    }
    TreeNode *build(vector<int>inorder,int inStart,int inEnd,vector<int>postorder,int postStart,int postEnd){
        if(inStart>inEnd){
            return nullptr;
        }
        //root节点对应的值是后续遍历的最后一个
        TreeNode *root=new TreeNode(postorder[postEnd]);
        int index=valToIndex[inorder[postorder[postEnd]]];
        int leftSize=index-inStart;
        //递归构造左右子树
        root->left=build(inorder,inStart,index-1,postorder,postStart,postStart+leftSize-1);
        root->right=build(inorder,index+1,inEnd,postorder,postStart+leftSize,postEnd-1);
        return root;
    }
};

整数变成字符

 

 

C++课程，黑马程序员

Vector存放自定义数据类型

#include<iostream>
using namespace std;
#include<vector> 
//目标 vector容器存放自定义的数据类型
class Person {
public:
	string m_Name;
	int m_Age;
	//构造函数：
	Person(string name, int age) {
		this->m_Name = name;
		this->m_Age = age;
		 
	}
};
void test01(){
	vector<Person>v;
	Person p1("p1", 1);
	Person p2("p2", 1);
	Person p3("p3", 1);
	Person p4("p4", 1);
	Person p5("p5", 1);
	//向容器中添加数据包
	v.push_back(p1);	
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);

	//遍历容器中的数据,*it是什么是一个Person的数据类型，解决指针 it是一个指针，可以->出来属性
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++) {
		cout << "姓名：" << (*it).m_Name << "年龄："<<(*it).m_Age<<endl;  
		cout << "姓名：" << it->m_Name << "年龄：" << it->m_Age << endl;
	}
	
}
int main() {
	test01();
	return 0;

}

C++定义二维数组  7.31

 

力扣 215. 数组中的第K个最大元素

class Solution {
    public:int findKthLargest(vector<int>nums, int k) {
        // 小顶堆，堆顶是最小元素
        priority_queue<int> pq ;
        for (int e : nums) {
            // 每个元素都要过一遍二叉堆
            pq.push(e);
            // 堆中元素多于 k 个时，删除堆顶元素
            if (pq.size() > k) {
                pq.pop();
            }
        }
        // pq 中剩下的是 nums 中 k 个最大元素，
        // 堆顶是最小的那个，即第 k 个最大元素
        return pq.top();
    }
};
// 详细解析参见：
// https://labuladong.github.io/article/?qno=215

315. 计算右侧小于当前元素的个数

class Merge{
    private:static vector<int>temp;
    public:static void sort(vector<int>nums){
        //先给辅助数组开辟内存空间
        temp.resize(nums.size());
        //排序整个数组（原地修改）
        sort(nums,0,nums.size()-1);
    }
    //将子数组nums[lo..hi]进行排序
    private: static void sort(vector<int>nums,int lo,int hi){
        if(lo==hi){
            //单个元素不用排序
            return;
        }
        //这样写为了防止移出
        int mid=lo+(hi-lo)/2;
        //先对左半部分数组 nums[lo..mid]排序
        sort(nums,lo,mid);
        //再对右半部分数组nums[mid+1..hi]排序
        sort(nums,mid+1,hi);
        //将两部分合并成一个有序数组
        merge(nums,lo,mid,hi);
    }
    private: static void merge(vector<int>nums,int lo,int mid,int hi){
        //先把[lo..hi]复制到辅助数组中
        //以便合并后的结果可以直接存入nums
        for(int i=lo;i<=hi;i++){
            temp[i]=nums[i];
        }
        //数组双指针技巧，合并两个有序数组
        int i=lo,j=mid+1;
        for(int p=lo;p<=hi;p++){
            if(i==mid+1){
                //左半数组已被全部合并
                nums[p]=temp[j++];
            }else if(j==hi+1){
                //右半边数组已经被全部合并
                nums[p]=temp[i++];
            }else if(temp[i]>temp[j]){
                nums[p]=temp[j++];
            }else{
                nums[p]=temp[i++];
            }
        }
    }
};
class Solution {
public:
    vector<int> countSmaller(vector<int> &nums) {
        Merge mysolution;
        mysolution.sort(nums);
        return nums;
    }
};

备份代码，虽然是错的

class Pair{
        public:int val,id;
        public:Pair() =default;
        Pair(int val,int id){
        //记录元素的值得
        this->val=val;
        //记录元素id
        this->id=id;
        }
};

class Solution {
public:
    public:
  
    //归并排序用到的辅助数组
    vector<Pair> temp;
    // // 记录每个元素后面比自己小的元素个数
    vector<int>count;
    //主函数
    vector<int> countSmaller(vector<int>&nums) {
        int n=nums.size();
        temp.resize(n);
        count.resize(n);
        
        vector<Pair>arr(n);
        
        //记录元素的原始索引位置,以便在 count 数组中更新结果
        for(int i=0;i<n;i++){
            arr[i]=Pair(nums[i],i);          
        }
        //执行归并排序
        sort(arr,0,n-1);
        vector<int>res;
        for(int c:count){
            res.push_back(c);
        }
        return res;



    }
    //归并排序
    private:void sort(vector<Pair>arr,int lo,int hi){
        if (lo==hi){
            return ;
        }
        int mid=lo+(hi-lo)/2;
        sort(arr,lo,mid);
        sort(arr,mid+1,hi);
        merge(arr,lo,mid,hi);

    }
    //合并两个有序数组
    private:void merge(vector<Pair>arr,int lo,int mid,int hi){
        for(int i=lo;i<hi;i++){
            temp[i]=arr[i];
            
        }
        int i=lo,j=mid+1;
        for(int p=lo;p<=hi;p++){
            if(i==mid+1){
                arr[p]=temp[j++];
            }else if(j==hi+1){
                arr[p]=temp[i++];
                //更新count 数组
                count[arr[p].id] += j - mid - 1;
            }else if(temp[i].val>temp[j].val){
                arr[p]=temp[j++];
            }else{
                arr[p]=temp[i++];
                //更新count数组
                count[arr[p].id] += j - mid - 1;
            }
        }

    }
};

字符串默认以0为结尾

cin.peek();

cin.get();

cin.read();

推荐const int size=50;

char buf[size];

cin.gcount()计数

cout.write(buf,20);

cin.getline(buf,10);

获得10个

cout两个方法

c++关键词太多，语法太多，太灵活

文件I/O

编写文件复制任务

在方法之前声明变量

207. 课程表

class Solution {
      //记录一次traverse递归经过的节点
        vector<bool>onPath;
        //记录遍历过的节点，防止走回头路
        vector<bool>visited;
        //记录途中是否有环
        bool hasCycle=false;
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        vector<int>graph=buildGraph(numCourses,prerequisites);
        vector<bool>visited[numCourses];
        vector<bool>onPath[numCourses];
        for(int i=0;i<numCourses;i++){
            //遍历图中的节点
            traverse(graph,i);
        }
        //只要没有循环依赖就可以完成所有课程
        return !hasCycle;
    }
    void traverse(vector<int>graph,int s){
        if(onPath[s]){
            //出现环
            hasCycle=true;
        }
        if(visited[s]||hasCycle){
            //如果已经找到了环，也不用遍历了
            return;
        }
        //前序遍历位置代码
        visited[s]=true;
        onPath[s]=true;
        for(int t:graph[s]){
            traverse(graph,t);
        }
        //后序遍历位置代码
        onPath[s]=false;
    }
    vector<int>buildGraph(int numCourses,vector<vector<int>>prerequisites){
        //图中共有numCOurses个节点
        vector<int>graph[numCourses];
        for(int i=0;i<numCourses;i++){
            vector<>graph[i];

        }
        for(vector<int>edge:prerequisites){
            int from=edge[1];
            int to=edge[0];
            //修完课程from才能修课程to
            //在图中添加一条从from指向to 的有向边
            graph[from].push_back(to);
        }
        return graph;
    }
};

DPS：深度优先搜索

  尝试自己解决216组合总和三，代码不对，没找到问题

class Solution {
    vector<vector<int>>res;
    vector<int>track;
    int trackSum;
    vector<int>nums={1,2,3,4,5,6,7,8,9};
public:
    vector<vector<int>> combinationSum3(int k, int n) {
        backtrack(nums,0,k,n);
        return res;
    

    }
    void backtrack(vector<int>num,int start,int k,int n){
        if(trackSum>n){
            return ;
        }
        if(trackSum==n){
            res.push_back(track);
            return ;
        }
        if(track.size()>k){
            return ;
        }
        for(int i=start;i<k;i++){
            if(i>0&&(num[i-1]==num[i])){
                continue;
            }
            track.push_back(num[i]);
            trackSum+=num[i];
            backtrack(num,i+1,k,n);
            trackSum-=num[i];
            track.pop_back();
        }
    }
};

695题 岛屿的最大面积

函数加或者不加&差别很大

class Solution {
public:
    
    int maxAreaOfIsland(vector<vector<int>>& grid) {
         int res=0;
        int m=grid.size();
        int n=grid[0].size();

        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]==1){
                    res=max(res,dfs(grid,i,j));
                }
            }
        }
        return res;

    }
    int dfs(vector<vector<int>>&grid,int i,int j){
       int m = grid.size(), n = grid[0].size();
        if (i < 0 || j < 0 || i >= m || j >= n) {
            // 超出索引边界
            return 0;
        }
        if (grid[i][j] == 0) {
            // 已经是海水了
            return 0;
        }
        // 将 (i, j) 变成海水
        grid[i][j] = 0;

        return dfs(grid, i + 1, j)
                + dfs(grid, i, j + 1)
                + dfs(grid, i - 1, j)
                + dfs(grid, i, j - 1) + 1;
    }
    
};

加&符号和不加&有很大区别1020飞地的数量

class Solution {
public:
    int numEnclaves(vector<vector<int>>& grid) {
        int m=grid.size();
        int n=grid[0].size();
        for(int i=0;i<m;i++){
            dfs(grid,i,0);
            dfs(grid,i,n-1);
        }
        for(int j=0;j<n;j++){
            dfs(grid,0,j);
            dfs(grid,m-1,j);
        }
        int res=0;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]==1){
                    res+=1;
                }
            }
        }
        return res;
    }
    void dfs(vector<vector<int>>&grid,int i,int j){
        int m=grid.size();
        int n=grid[0].size();
        if(i<0||j<0||i>=m||j>=n||grid[i][j]==0){
            return;
        }
        grid[i][j]=0;
        dfs(grid,i+1,j);
        dfs(grid,i,j+1);
        dfs(grid,i-1,j);
        dfs(grid,i,j-1);

    }
};

队列

queue

{

两个操作：emplace

pop

}

这是什么语法，来自752题 

 931. 下降路径最小和

class Solution {
public:
    int minFallingPathSum(vector<vector<int>>& matrix) {
        int n=matrix.size();
        int res=INT_MAX;
        //将备忘录的值初始化为6666；
        vector<vector<int>>memo[n][n];
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                matrix[i][j]=66666;
            }

        }
        //终点可能在matrix[n-1]的任意一列
        for(int j=0;j<n;j++){
            res=min(res,dp(matrix,n-1,j));

        }
        return res;


    }
    //备忘录
    vector<vector<int>>memo;
    int dp(vector<vector<int>>&matrix,int i,int j){
        //1.索引合法性检查
        if(i<0||j<0||i>=matrix.size()||j>=matrix[0].size()){
            return 99999;
        }
        //2.base case
        if(i==0){
            return matrix[0][j];
        }
        //3.查找备忘录，防止重复计算
        if(memo[i][j]!=66666){
            return memo[i][j];
        }
        //进行状态转移
        memo[i][j]=matrix[i][j]+zuixiao(dp(matrix,i-1,j),dp(matrix,i-1,j-1),dp(matrix,i-1,j+1));
        return memo[i][j];
    
    }
    int zuixiao(int a,int b,int c){
        return min(a,min(b,c));
    }

};

找不到错误，就是不能运行

vector的用法：

712题目

class Solution {
public:
vector<vector<int>>memo;
    int minimumDeleteSum(string s1, string s2) {
    int m=s1.size();
    int n=s2.size();
    //
    vector<vector<int>>memo(m,vector<int>(n));
    for(int i=0;i<m;i++){
        for(int j=0;j<n;j++){
             memo[i][j]=-1;

        }

      
        
        
    }

      return dp(s1,0,s2,0);
}
    int dp(string s1,int i,string s2,int j){
        int res=0;
        //base case

        if(!s1.size()&&!s2.size()){
            return 0;
        }
        if(i==s1.size()){
            for(;j<s2.size();j++){
                res+=s2[j];
            }
            return res;
        }
        if(j==s2.size()){
            for(;i<s1.size();i++){
                res+=s1[i];
            }
        }
        if(memo[i][j]!=-1){
            return memo[i][j];
        }
        if(s1[i]==s2[j]){
            memo[i][j]=dp(s1,i+1,s2,j+1);
        }else{
            memo[i][j]=min(s1[i]+dp(s1,i+1,s2,j),s2[j]+dp(s1,i,s2,j+1));
        }
        return memo[i][j];
    }


};

最大正方形

class Solution {
public:
    int countSquares(vector<vector<int>>& matrix) {
        if(matrix.size()==0||matrix[0].size==0){
            return 0;
        }
        int maxSide=0;
        int rows=matrix.size(),columns=matrix[0].size();
        for(int i=0;i<rows;i++){
            for(int j=0;j<columns;j++){
                if(matrix[i][j]=='1'){
                    maxSide==max(maxSide,1);
                    //计算可能的最大正方形边长
                    int currentMaxSize=min(rows-i,columns-j);
                    for(int k=1;k<currentMaxSize;k++){
                        //判断新增的一行一列是否均为1
                        bool flag=true;
                        if(matrix[i+k][j+k]=='0'){
                            break;
                        }
                        for(int m=0;m<k;m++){
                            if(matrix[i+k][j+m]=='0'||matrix[i+m][j+k]=='0'){
                                flag==false;
                                break;
                            }
                        }
                        if(flag){
                            maxSide=max(maxSide,k+1);
                        }else{
                            break;
                        }
                    }
                }
            }
        }
        int maxSquare=maxSide*maxSide;
        return maxSquare;

    }
};

Leedcode 周赛  0814

6148. 矩阵中的局部最大值

 

 

 剑指 Offer II 040. 矩阵中最大的矩形 - 力扣（LeetCode）

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n=prices.size();
        int buy1=-prices[0];
        int sell1=0;
        int buy2=-prices[0];
        int sell2=0;
        for(int i=1;i<n;i++){
            buy1=max(buy1,-prices[i]);
            sell1=max(buy1+prices[1],sell1);
            buy2=max(buy2,sell1-prices[i]);
            sell2=max(buy2+prices[2],sell2);
        }
        return sell2;

    }
};

地下城游戏

class Solution {
public:
    int calculateMinimumHP(vector<vector<int>>& dungeon) {
        int m=dungeon.size();
        int n=dungeon[0].size();
        vector<vector<int>>dp(m,vector<int>(n));
        dp=dungeon;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
               
                if(i==0&&j==0){
                    dp[i][j]=dungeon[i][j];
                    continue;
                }
                if(i==0){
                    dp[i][j]=dp[i][j-1]+dp[i][j];
                }
                else if(j==0){
                     dp[i][j]=dp[i-1][j]+dp[i][j];
                     
                }else
                
                dp[i][j]=max(dp[i][j-1],dp[i-1][j])+dp[i][j];


            }
        }
        return dp[m-1][n-1]+1;

    }
};

这里出现的问题是总会有一个溢出，找不到原因 

174题目，力扣

class Solution {
public:
    vector<vector<int>>memo;
    int calculateMinimumHP(vector<vector<int>>& dungeon) {
        int m=dungeon.size();
        int n=dungeon[0].size();
        vector<vector<int>> memo(m,vector<int>(n,-1));
        return  dp(dungeon,0,0);

    }
    int dp(vector<vector<int>>&grid,int i,int j){
        //base case
        int m=grid.size();
        int n=grid[0].size();
      
        if(i==m-1&&j==n-1){
            return grid[i][j]>=0?1:1-grid[i][j];
        }
        if(i==m||j==n){
            return INT_MAX;
        }
        if(memo[i][j]!=-1){
            return memo[i][j];
        }
        
        int res=min(dp(grid,i+1,j),dp(grid,i,j+1))-grid[i][j];
        memo[i][j]=res<=0?1:res;
        return memo[i][j];
    }
};

C++的遍历 

两个问题，（1）为什么会有返回值，null（2）为什么auto &可以代表一个向量

力扣

 

 

#include<stdio.h>
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

int main(){
  int n,m;
  cin>>n;
  cin>>m;
  vector<vector<int>>shouyi;
  for(int i=0;i<m;i++){
    for(int j=0;j<n;j++){
      cin>>shouyi[i][j];
    }
  }
  int sum=0;
  for(int i=0;i<m;i++){
    int maxshou;
    for(int j=0;j<n;j++){
      maxshou=max(maxshou,shouyi[i][j]);
    }
    sum=sum+maxshou;
    maxshou=0;
    
  }
  return sum;
}

输出：定义double的几位小数

 cout<<fixed<<setprecision(1)<<sumLength<<" "<<setprecision(1)<<h<<endl;

getline是干啥用的？

字符串的结束的标志

c++从键盘输入数组

#include<iostream>
using namespace std;
#include<vector>
int main()
{
    char ch;
    int n;
    vector<int> nums;
    cout << "以空格为间隔输入一组数据：";
    while (1) {
        cin >> n;
        nums.push_back(n);
      
        if (cin.get() == '\n')
            break;
    }
    cout << "输入的数据为：" << endl;
    for (int i = 0;i < nums.size();i++) {
        cout << nums[i] << endl;
    }
    return 0;
}

新建一个动态数组

 int *p=new int[n];

 

交换两个数字

#include <iostream>
using namespace std;

// write your code here......
void swap(int *p,int *q){
    int temp=*p;
    *p=*q;
    *q=temp;
    
}
void swapp(int&a,int &b){
    int temp=a;
    a=b;
    b=temp;
    
}
int main() {

    int m, n;
    cin >> m;
    cin >> n;
   swap(m,n);
    // write your code here......
    
   
    

    cout << m << " " << n << endl;

    return 0;
}

#include <iostream>
using namespace std;

// write your code here......
void swap1(int * p, int * q) {
   /* %p是地址*/
    cout << *p << endl;
    cout << p << endl;
    int temp = *p;
    *p = *q;
    *q = temp;

}
void swapp(int& a, int& b) {
  /*  &a是一个地址*/
    cout << &a << endl;
    cout << a << endl;
    int temp = a;
    a = b;
    b = temp;

}
int main() {

    int m, n;
    cin >> m;
    cin >> n;
    swapp(m, n);
    // write your code here......




    cout << m << " " << n << endl;

    return 0;
}

Find函数的用法

统计字符串中子串出现的次数_牛客题霸_牛客网

#include <iostream>
#include <cstring>
using namespace std;

int main() {

    char str[100] = { 0 };
    char substr[100] = { 0 };

    cin.getline(str, sizeof(str));
    cin.getline(substr, sizeof(substr));

    int count = 0;

    // write your code here......
    
    //没有思路
    string str1(str);
    string str2(substr);
    int i=0;
   
    while(str1.find(str2,i)!=-1){
        count+=1;
        i=str1.find(str2,i)+1;
    }
    cout<<count<<endl;
    
    



    return 0;
}

str.length 

用数组操作字符串的错误

#include <iostream>
using namespace std;
class Person{
    friend void showAge(Person &);
    public:
        Person(int age){
            this->age=age;
        }
    private:
        int age;
};
void showAge(Person &p){
    cout<<p.age<<endl;
}
int main() {
    Person p(10);
    showAge(p);
}
// 64 位输出请用 printf("%lld")

 

#include <iostream>
using namespace std;
class Time{
    public:
        int hours;
        int minutes;
        Time(){
            hours=0;
            minutes=0;
        }
        Time(int h,int m){
            this->hours=h;
            this->minutes=m;
        }
        void show(){
            cout<<hours<<" "<<minutes<<endl;

        }
        Time operator+(Time &t){
            Time sum;
            sum.hours=hours+t.hours+(minutes+t.minutes)/60;
            sum.minutes=(minutes+t.minutes)%60;
            return sum;
        }

};









int main() {
   int h;
   int m;
   cin>>h;
   cin>>m;
   Time t1(h,m);
   Time t2(2,20);
   Time t3=t1+t2;
   t3.show();
   return 0;
}
// 64 位输出请用 printf("%lld")

子类中调用父类的构造

子类中调用父类构造_牛客题霸_牛客网

#include <iostream>
using namespace std;

class Base{
    private:
       int x;
       int y;
    public:
     Base(int x,int y){
         this->x=x;
         this->y=y;
     }
     int getX(){
         return x;
     }
     int getY(){
         return y;
     }
};
class Sub:public Base{
    private:
        int z;
    public:
        Sub(int x,int y,int z):Base(x,y){
            this->z=z;
        }
        int getZ(){
            return z;
        }
        int calculate(){
            return  Base::getX()*Base::getY()*this->getZ();
        }
};
int main() {
    int x,y,z;
    cin>>x;
    cin>>y;
    cin>>z;
    Sub sub(x,y,z);
    cout<<sub.calculate()<<endl;
    return 0;
   
}
// 64 位输出请用 printf("%lld")

重写子类的计算逻辑

#include <iostream>
using namespace std;
class Base{
    private:
    int x,y;
    public:
    Base (int x,int y){
        this->x=x;
        this->y=y;
    }
    int getX(){
        return x;
    }
    int getY(){
        return y;
    }
    void calculate(){
        cout<<getX()*getY()<<endl;
    }
};
class Sub : public Base {
public:
    Sub(int x,int y):Base(x,y){}
    void  calculate(){
        if (Base::getY()==0)
            cout<<"Error"<<endl;
        else
            cout<<Base::getX()/Base::getY()<<endl;
    }
};
int main() {
    int x,y,z;
    cin>>x;
    cin>>y;
    Sub sub(x,y);
    sub.calculate();
    return 0;

}
// 64 位输出请用 printf("%lld")

C++ make_pair的用法