笔试强训：Week-6

最新推荐文章于 2026-06-29 19:52:35 发布
原创 最新推荐文章于 2026-06-29 19:52:35 发布 · 1k 阅读 · 22 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#c++ #算法 #动态规划

目录

一、小红的口罩（贪心+优先级队列）

二**、春游（分类讨论+数学）

三**、数位染色（01背包）

四、素数回文（模拟+数学）

五、活动安排（贪心+自定义排序/动规）

六**、合唱团（多状态dp）

七、跳台阶扩展问题（规律）

八、包含不超过两种字符的最长子串（滑动窗口）

九、字符串的排列（排序+dfs全排列带去重）

十、ISBN号码（模拟）

十一、kotori和迷宫（单源最短路bfs）

十二、矩阵最长递增路径（单源bfs / dfs+记忆化）

十三**、奇数位丢弃（找规律）

十四**、求和（dfs）

十五**、计算字符串的编辑距离（dp）

十六、提取不重复的整数（模拟）

十七、哈夫曼编码（模板）

十八**、abb（dp+哈希）

一、小红的口罩（贪心+优先级队列）

小红的口罩

#include<iostream>
#include<queue>
#include<vector>
using namespace std;
int n,k;
int main(){
    //用一个小根堆  每次使用不舒适度最小的
    cin>>n>>k;
    int x;
    priority_queue<int,vector<int>,greater<int>> heap;
    for(int i=0;i<n;++i){
        cin>>x;
        heap.push(x);
    }
    //开始循环
    int sum=0,ret=0;
    while(sum<=k){
        int t=heap.top();
        heap.pop();
        sum+=t;
        if(sum>k)break;
        heap.push(t*2);
        ++ret;
    }
    cout<<ret<<endl;
}

二**、春游（分类讨论+数学）

春游

先考虑恰好可以每条船坐满，那就是看双人船和三人船每个人A多少钱，哪个小就选哪个。如果人数取模于这个更少A的船的人数刚好等于0，那最好了，那就是我们要的方案。

如果有余，就考虑最后余下的那个人，和前面几个人组合。

如果是双人船的方案，最后要么剩下那个人坐双，要么坐单，要么和前面两个人改坐三人。

如果是三人船的方案，最后要么剩下一个要么剩下两个，这个人要么一个人坐便宜的那个，要么和前面三个加上他自己一个组合，双双，要么双三肯定是双三。或者最后剩下两个人，要么这两人一起坐便宜的那个，要么和前面三个人凑三个双，要么就是一双一三，要么就是两三，一双一三和两三不就是前面那个人单独坐的情况。

所以最终就得到上图绿色的，下面开始编写代码

#include<iostream>
#include<cmath>
using namespace std;
typedef long long LL;
LL t,n,a,b;
LL func(){
    if(n<=2) return min(a,b);//做便宜的船
    //ceil向上取整
    if(a>=b) return (LL)ceil(n/3.0)*b;
    LL ret=0;
    if(a*3<b*2){//说明双人船便宜 尽量选择双人船
        ret+=n/2*a;
        if(n%2==1) ret+=min(a,b-a);//多1个人 看看是要直接租双人 还是退掉一个双人租三人
    }
    else{//说明要尽可能租三人船  b*2<=a*3 有可能b更便宜
        ret+=n/3*b;
        //此时可能剩1个人或者2个人
        n%=3;
        if(n==1) ret+=min(a,2*a-b);
        if(n==2) ret+=a;
    }
    return ret;
}
int main(){
    cin>>t;
    while(t--){
        cin>>n>>a>>b;
        cout<<func()<<endl;
    }
}

三**、数位染色（01背包）

数位染色_牛客题霸_牛客网

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

int main() {
    long long x,tmp,sum;
    cin>>x;
    tmp=x;
    sum=0;
    vector<int> arr;
    while(tmp)
    {
        arr.push_back(tmp%10);
        sum+=tmp%10;
        tmp/=10;
    }
    if(sum%2)cout<<"No";
    else{
        long long target=sum/2;
        int n=arr.size();
        vector<vector<bool>> dp(n+1,vector<bool>(target+1));
        dp[0][0]=true;
        for(int i=1;i<=n;++i)
        {
            for(int j=arr[i-1];j<=target;++j)
            {
                dp[i][j]=dp[i-1][j]||dp[i-1][j-arr[i-1]];
            }
        }
        if(dp[n][target])cout<<"Yes";
        else cout<<"No";
    }
    return 0;
}

进一步空间优化，注意要倒着填，否则顺着填当计算dp[j]时，dp[j-arr[i]]可能已经被当前轮次更新过了

#include <iostream>
using namespace std;
const int N=20,M=10*9;//记录所有数位
bool dp[M];//前i个数选 和恰好为target
int arr[N];//标记各个数位
long long x;
int n=0;//统计有多少位
int sum=0;//统计总和
bool func(){
    if(sum%2==1) return false;
    sum/=2;
    dp[0]=true;
    for(int i=0;i<n;++i)
      for(int j=sum;j>=arr[i];--j)
        dp[j]=dp[j]||dp[j-arr[i]];
    return dp[sum]; 
}
int main() {
    cin>>x;
    while(x){
       arr[n++]=x%10;
       sum+=x%10;
       x/=10;
    }
    if(func()) cout<<"Yes"<<endl;
    else cout<<"No"<<endl;
}

四、素数回文（模拟+数学）

素数回文_牛客题霸_牛客网

素数判断前面我们已经掌握了，所以这题就是创建回文数的模拟题

#include <cmath>
#include <iostream>
using namespace std;
bool IsPrime(long long x)
{
    if(x%2==0)return false;
    for(int i=3;i<=sqrt(x);i+=2)
    {
        if(x%i==0)return false;
    }
    return true;
}
int main() {
    string t;
    cin>>t;
    int cur=t.length()-2;
    while(cur>=0)
    {
        t+=t[cur];
        --cur;
    }
    long long x=stoll(t);
    // cur=0;
    // while(cur<t.length()){
    //     x=x*10+t[cur]-'0';
    //     ++cur;
    // }

    if(IsPrime(x))cout<<"prime";
    else cout<<"noprime";

    return 0;
}

五、活动安排（贪心+自定义排序/动规）

活动安排_牛客题霸_牛客网

0位置相等的按1位置降序排，0位置不等的按0位置升序排，dp填表的时候往前找，如果0位置相等跳过，不等的时候就找有没有1位置比我的0位置小的。如果有直接等于该位置长度+1，贪心的break直接将效率最大化

#include <iostream>
#include <vector>
#include<algorithm>
using namespace std;
struct cmp{
    bool operator()(const vector<int> &a1,const vector<int> &a2){
        if(a1[0]==a2[0]){
            return a1[1]>a2[1];
        }
        return a1[0]<a2[0];
    }
};
int main() {
    int n;
    cin>>n;
    vector<vector<int>> arr(n,vector<int>(2));
    for(int i=0;i<n;++i)cin>>arr[i][0]>>arr[i][1];
    sort(arr.begin(),arr.end(),cmp());
    // for(int i=0;i<n;++i)cout<<arr[i][0]<<" "<<arr[i][1]<<endl;
    vector<int> dp(n+1,1);
    for(int i=1;i<=n;++i)
    {
        for(int j=i-1;j>=1;--j)
        {
            if(arr[i-1][0]==arr[j-1][0])continue;
            if(arr[i-1][0]>=arr[j-1][1])
            {
                dp[i]=dp[j]+1;
                break;
            }
        }
    }
    cout<<dp[n];

    return 0;
}

或者不用动规，摘自别人的题解

#include <iostream>
#include <algorithm>
using namespace std;
typedef pair<int,int> PII;
const int N=2e5+1;
int n;
PII arr[N];
int main() {
   cin>>n;
   for(int i=0;i<n;++i) cin>>arr[i].first>>arr[i].second;
   sort(arr,arr+n);
   int ret=0,right=arr[0].second;
   for(int i=1;i<n;++i) 
   //如果有重叠 保留右侧最小的
      if(arr[i].first<right) right=min(right,arr[i].second);
      else{//如果没有重叠 就更新一下 然后++ret
         ++ret;
         right=arr[i].second;
      }
    cout<<ret+1<<endl;
}

六**、合唱团（多状态dp）

合唱团_牛客题霸_牛客网

做的时候意识到是多状态dp，但是选择k个同时保证相连两个距离不超过d，不知道如何处理

对于人数我们可以再开一个维度表示选择了几个人，第一个维度代表从[1,i]中挑选的最大乘积，因为有d的限制，所以我们设置为arr[i]为必选，这样dp填表的时候只需要考虑i~max(j-1,i-d)的位置即可。

看完解析的细节问题，感觉这题配得上困难题

代码最终实现如下：

#include <iostream>
#include <vector>
using namespace std;
const long long N=0x3f3f3f3f3f3f3f3f;
int main() {
    int n,k,d;
    cin>>n;
    vector<int> arr(n+1);
    for(int i=1;i<=n;++i)cin>>arr[i];
    cin>>k>>d;

    //f存正，g存负
    vector<vector<long long>> f(n+1,vector<long long>(k+1,-N));
    vector<vector<long long>> g(n+1,vector<long long>(k+1,N));

    //填表
    for(int i=1;i<=n;++i)
    {
        //初始化
        f[i][1]=g[i][1]=arr[i];
        //从2开始，1我们已经填过了
        for(int j=2;j<=min(i,k);++j)
        {
            for(int prev=i-1;prev>=max(i-d,j-1);--prev)
            {
                if(arr[i]>0)
                {
                    f[i][j]=max(f[i][j],f[prev][j-1]*arr[i]);
                    g[i][j]=min(g[i][j],g[prev][j-1]*arr[i]);
                }
                else if(arr[i]<0)
                {
                    f[i][j]=max(f[i][j],g[prev][j-1]*arr[i]);
                    g[i][j]=min(g[i][j],f[prev][j-1]*arr[i]);
                }
                else f[i][j]=g[i][j]=0;
            }
        }
    }
    long long ans=-N;
    for(int i=k;i<=n;++i)
    {
        ans=max(ans,f[i][k]);
    }
    cout<<ans;
    return 0;
}

今天三题一遍过

七、跳台阶扩展问题（规律）

跳台阶扩展问题_牛客题霸_牛客网

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

int main() {
    int n;
    cin>>n;
    cout<<pow(2,n-1);
    return 0;
}

八、包含不超过两种字符的最长子串（滑动窗口）

包含不超过两种字符的最长子串_牛客题霸_牛客网

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

int main() {
    string n;
    cin>>n;
    int len=0,left=0,right=0;
    unordered_map<char,int> hash;
    while(right<n.size())
    {
        char in=n[right];
        ++hash[in];
        while(hash.size()>2)
        {
            char out=n[left];
            if(--hash[out]==0)hash.erase(out);
            ++left;
        }
        len=max(len,right-left+1);
        ++right;
    }
    cout<<len;
    return 0;
}

九、字符串的排列（排序+dfs全排列带去重）

字符串的排列_牛客题霸_牛客网

牛客好像不能像力扣一样，成员变量当作全局变量自动初始化，得放在类外

#include <vector>
string path;
bool check[11];
vector<string>  ret;
class Solution {
public:
    void dfs(string str,int pos)
    {
        if(pos==str.size())
        {
            ret.push_back(path);
            return;
        }
        for(int i=0;i<str.size();++i)
        {
            if(!check[i])
            {
                if(i==0||str[i]!=str[i-1]||check[i-1])
                {
                    path.push_back(str[i]);
                    check[i]=true;
                    dfs(str,pos+1);
                    path.pop_back();
                    check[i]=false;
                }
            }
        }
    }
    vector<string> Permutation(string str) {
        if(str=="")return ret;

        sort(str.begin(),str.end());
        dfs(str,0);
        return ret;
    }
};

今天三题也拿下了

十、ISBN号码（模拟）

ISBN号码_牛客题霸_牛客网

#include <iostream>
using namespace std;

int main() {
    string s;
    cin>>s;
    int cur=0,num=1,sum=0;
    while(cur<11)
    {
        if(s[cur]=='-')
        {
            ++cur;
            continue;
        }
        int x=s[cur]-'0';
        sum+=(x*num);
        ++cur;
        ++num;
    }
    int right_num=sum%11;
    if(s[12]==right_num+'0'||(s[12]=='X'&&right_num==10))
    {
        cout<<"Right";
    }
    else{
        s.pop_back();
        if(right_num==10)s+='X';
        else{
            s+=(right_num+'0');
        }
        cout<<s;
    }
    return 0;
}

十一、kotori和迷宫（单源最短路bfs）

kotori和迷宫

#include <iostream>
#include <vector>
#include<queue>
using namespace std;
using PII=pair<int,int>;
int dx[4]={-1,1,0,0},dy[4]={0,0,-1,1};
bool check[50][50];
int main() {
    int n,m;
    cin>>n>>m;
    queue<PII> q;
    vector<string> grid(n);
    for(int i=0;i<n;++i)
    {
        cin>>grid[i];
        for(int j=0;j<m;++j)
        {
            if(grid[i][j]=='k')
            {
                check[i][j]=true;
                q.push({i,j});
            }
        }
    }

    int steps=0,ways=0;
    while(!q.empty())
    {
        int sz=q.size();
        if(ways==0)
        {
            ++steps;
        }
        while(sz--)
        {
            auto [i,j]=q.front();
            q.pop();
            for(int k=0;k<4;++k)
            {
                int x=i+dx[k],y=j+dy[k];
                if(x>=0&&x<n&&y>=0&&y<m&&!check[x][y]&&grid[x][y]=='e')
                {
                    ++ways;
                    check[x][y]=true;
                    continue;
                }
                if(x>=0&&x<n&&y>=0&&y<m&&!check[x][y]&&grid[x][y]=='.')
                {
                    check[x][y]=true;
                    q.push({x,y});
                }
            }
        }
    }
    if(ways)cout<<ways<<" "<<steps;
    else cout<<-1;
    return 0;
}

十二、矩阵最长递增路径（单源bfs / dfs+记忆化）

矩阵最长递增路径_牛客题霸_牛客网

bfs解法

int dx[4]={-1,1,0,0},dy[4]={0,0,-1,1};
int _n,_m;
using PII=pair<int,int>;
class Solution {
public:
    int bfs(vector<vector<int> >& matrix,int i,int j)
    {
        int steps=0;
        queue<PII> q;
        q.push({i,j});
        while(!q.empty())
        {
            int sz=q.size();
            ++steps;
            while(sz--)
            {
                auto [i,j]=q.front();
                q.pop();
                for(int k=0;k<4;++k)
                {
                    int x=i+dx[k],y=j+dy[k];
                    if(x>=0&&x<_n&&y>=0&&y<_m&&matrix[x][y]>matrix[i][j])
                    {
                        q.push({x,y});
                    }
                }
            }
        }
        return steps;
    }
    int solve(vector<vector<int> >& matrix) {
        _n=matrix.size(),_m=matrix[0].size();
        int len=0;
        for(int i=0;i<_n;++i)
        {
            for(int j=0;j<_m;++j)
            {
                len=max(len,bfs(matrix,i,j));
            }
        }
        return len;
    }
};

dfs记忆化

#include <vector>
int memo[1001][1001],dx[4]={-1,1,0,0},dy[4]={0,0,-1,1};
int _m,_n,ret;
class Solution {
public:
    int solve(vector<vector<int> >& matrix) {
        _m=matrix.size(),_n=matrix[0].size();
        for(int i=0;i<_m;++i)
        {
            for(int j=0;j<_n;++j)
            {
                ret=max(ret,dfs(matrix,i,j));
            }
        }
        return ret;
    }
    int dfs(vector<vector<int>>&matrix,int i,int j)
    {
        if(memo[i][j])return memo[i][j];
        int path=1;
        for(int k=0;k<4;++k)
        {
            int x=i+dx[k],y=j+dy[k];
            if(x>=0&&x<_m&&y>=0&&y<_n&&matrix[x][y]>matrix[i][j])
            {
                path=max(path,dfs(matrix,x,y)+1);
            }
        }
        memo[i][j]=path;
        return path;
    }
};

事不过三，今天三题一题都没AC

十三**、奇数位丢弃（找规律）

奇数位丢弃_牛客题霸_牛客网

对于多组数据直接while(cin>>n)即可

#include <iostream>
using namespace std;
 
int main() {
   int n;
   while(cin>>n){
     int ret=1;
     while(ret-1<=n) ret*=2;
     cout<<ret/2-1<<endl;
   }
    return 0;
}

十四**、求和（dfs）

求和__牛客网

dfs每层为选择几个，不过已经忘了代码怎么写的了，或者选和不选也可以做，哎呀，看来是大脑偷懒了

选还是不选为决策

#include <iostream>
using namespace std;
bool vis[11];//标记数组
int n,m;
int sum;//统计已选数字的总和
void dfs(int pos){
    if(sum==m){
       for(int i=1;i<=n;++i)
         if(vis[i]) cout<<i<<" ";
       cout<<endl;
       return;
    }
    if(sum>m||pos>n) return;//没有意义了
    //选
    sum+=pos;
    vis[pos]=true;
    dfs(pos+1);
    sum-=pos;
    vis[pos]=false;
    dfs(pos+1);//不选
}   
int main() {
   cin>>n>>m;
   dfs(1);//dfs枚举位置
}

每层选几个为决策，其实就是求所有子序列

#include <iostream>
using namespace std;
bool vis[11];//标记数组
int n,m;
int sum;//统计已选数字的总和
void dfs(int pos){
    if(sum==m){
       for(int i=1;i<=n;++i)
         if(vis[i]) cout<<i<<" ";
       cout<<endl;
       return;
    }
    if(sum>m) return;//没有意义了
    for(int i=pos;i<=n;++i){
        sum+=i;
        vis[i]=true;
        dfs(i+1);
        vis[i]=false;
        sum-=i;
    }
}   
int main() {
   cin>>n>>m;
   dfs(1);//dfs枚举位置
}

十五**、计算字符串的编辑距离（dp）

计算字符串的编辑距离_牛客题霸_牛客网

dp神力

#include <iostream>
#include <string>
using namespace std;
const int N=1010;
int dp[N][N];
string a,b;
int main() {
   //dp[i][j]表示以0-i的A串 变成0-j的B串所需要的最小操作次数
   cin>>a>>b;
   int m=a.size(),n=b.size();
   a=' '+a,b=' '+b;//为了同步下标
   dp[0][0]=0;//都是空串
   for(int i=1;i<=m;++i) dp[i][0]=i;
   for(int j=1;j<=n;++j) dp[0][j]=j;
   for(int i=1;i<=m;++i)
     for(int j=1;j<=n;++j)
       if(a[i]==b[j]) dp[i][j]=dp[i-1][j-1];
       else dp[i][j]=min(min(dp[i-1][j],dp[i][j-1]),dp[i-1][j-1])+1;
    cout<<dp[m][n]<<endl;
}

十六、提取不重复的整数（模拟）

提取不重复的整数_牛客题霸_牛客网

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

int main() {
    unordered_map<char,int> hash;
    string s;
    cin>>s;
    int cur=s.length()-1;
    string ans;
    while(cur>=0)
    {
        while(cur>=0&&hash.count(s[cur]))--cur;
        if(cur<0)break;

        ++hash[s[cur]];
        ans.push_back(s[cur]);
        --cur;
    }
    cout<<ans;
    return 0;
}

十七、哈夫曼编码（模板）

哈夫曼编码_牛客题霸_牛客网

#include <iostream>
#include <queue>
using ll=long long;
using namespace std;

int main() {
    ll n,x;
    cin>>n;
    priority_queue<ll,vector<ll>,greater<ll>> hp;
    while(n--)
    {
        cin>>x;
        hp.push(x);
    }
    ll sum=0;
    while(hp.size()>=2)
    {
        ll a=hp.top();
        hp.pop();
        ll b=hp.top();
        hp.pop();
        ll num=a+b;
        sum+=num;
        hp.push(num);
    }
    cout<<sum;
    return 0;
}

十八**、abb（dp+哈希）

abb_牛客题霸_牛客网

感觉难度上了一个level

#include <iostream>
using namespace std;
const int N=1e5+10;
typedef long long LL;
char s[N];
LL f[26],g[26];
//f[]表示以i位置为结尾时有多少个_x
//g[]表示以i位置为结尾时有多少个x
int n;
int main() {
    cin>>n>>s;
    LL ret=0;
    for(int i=0;i<n;++i){
        int x=s[i]-'a';
        ret+=f[x];
        f[x]+=i-g[x];
        g[x]+=1;
    }
    cout<<ret<<endl;
}

本周完结撒花*★,°*:.☆(￣▽￣)/$:*.°★* 。

【笔试强训】Week6：活动安排，合唱团，跳台阶的扩展问题，字符串的排列，kotori和迷宫，春游
记录了从0学习Java技术栈的日常
05-30 189
本文包含四个算法题解： 活动安排：使用贪心算法，按左端点排序后遍历，选择不重叠且右端点较小的活动。时间复杂度O(nlogn)。 合唱团：动态规划问题，维护最大/最小乘积表。状态转移考虑前i人中选j人，需满足间隔d的限制。时间复杂度O(nkd)。 跳台阶扩展：动态规划/找规律题。发现规律f(n)=2^(n-1)，可用递推或公式直接求解。 字符串排列：DFS+剪枝。先排序字符串，处理重复字符时通过访问标记避免重复排列。时间复杂度O(n!)。 核心解法包括贪心、动态规划（状态转移）、DFS剪枝等经典算法思想，涉及
笔试强训：Week-3
_dindong的博客
10-31 1484
本文整理了18道编程题目及解题思路，涵盖多种算法题型。主要包括：滑动窗口应用（最长无重复子数组、定长窗口问题）、贪心算法（重排字符串、组队竞赛）、动态规划（删除相邻数字的最大分数、01背包）、二分查找（分组问题）、拓扑排序、模拟题以及数学问题等。每道题都提供了核心解题思路和代码实现要点，涉及字符串处理、数组操作、哈希表应用等常见编程技巧。其中特别强调了数据类型选择（如long long防溢出）、边界条件处理等易错点，展现了从暴力解法到优化解法的思考过程。
笔试强训：Week-1
_dindong的博客
09-27 1109
本文整理了牛客网算法题解，涵盖数字统计、数组交集、点击消除、快递费用计算、最小花费爬楼梯等18道题目。主要内容包括：1.数字统计通过枚举和模运算实现；2.数组交集问题提供哈希和双指针两种解法；3.点击消除使用栈结构处理；4.动态规划应用于斐波那契数列和最小花费问题；5.贪心算法在字符串距离和数字处理中的应用；6.深度优先搜索解决单词搜索和岛屿数量问题；7.滑动窗口处理数组子区间问题；8.循环链表和数学方法解决约瑟夫环问题。每道题都给出了核心思路和关键代码实现。
笔试强训week6
禊月初三的博客
05-28 1069
每一本正式出版的图书都有一个ISBN号码与之对应，ISBN码包括9位数字、1位识别码和3位分隔符，其规定格式如“x-xxx-xxxxx-x”，其中符号“-”是分隔符（键盘上的减号），最后一位是识别码，例如0-670-82162-4就是一个标准的ISBN码。有 n 个学生站成一排，每个学生有一个能力值，牛牛想从这 n 个学生中按照顺序选取 k 名学生，要求相邻两个学生的位置编号的差不超过 d，使得这 k 个学生的能力值的乘积最大，你能返回最大的乘积吗？她想知道有多少出口是她能到达的，最近的出口离她有多远？
笔试强训：Week-4
_dindong的博客
11-07 1330
本文总结了多个算法题解，主要涉及数学、动态规划、双指针等常见算法技巧。包括使用欧几里得算法求最大公约数、路径DP解决礼物价值问题、双指针判断字符串对称性、贪心算法处理非对称字符串、FloodFill解决城市群问题等。还介绍了01背包、滑动窗口、前缀和等经典算法应用，涵盖了字符串处理、数学运算、图论等多个领域，展示了不同场景下的算法优化策略和实现方法。
笔试强训week5
禊月初三的博客
05-17 1189
dd作为体操队队长，在给队员们排队形，体操队形为一个单独的纵列，体操队有n个同学，标号为1∼n，对于i(1≤i≤n)号队员，会有一个诉求(1≤a[i]≤n)，表示他想排在a[i]号队员前面，当a[i]=i时，我们认为他没有位置需求，随便排哪儿都行，dd想知道有多少种队形方案，可以满足所有队员的要求。有 n 个活动即将举办，每个活动都有开始时间与活动的结束时间，第 i 个活动的开始时间是 starti ,第 i 个活动的结束时间是 endi ,举办某个活动就需要为该活动准备一个活动主持人。
笔试强训week7
禊月初三的博客
06-01 939
例如:1，4，9，和16都是完全平方数，但是2，3，5，8，11等等不是数据范围:1≤𝑛≤10^4​。给定一个𝑛×𝑚的矩阵，矩阵中的数字表示滑雪场各个区域的高度，你可以选择从任意一个区域出发，并滑向任意一个周边的高度严格更低的区域（周边的定义是上下左右相邻的区域）。每个值代表一种面值的货币，每种面值的货币可以使用任意张，再给定一个aim，代表要找的钱数，求组成aim的最少货币数。有n个果冻排成一排。有一个长为 n 的数组 A ，求满足 0 ≤ a ≤ b < n 的 A[b] - A[a] 的最大值。
笔试强训：Week -7
_dindong的博客
12-13 812
本文总结了多个算法题解，主要包括： 旋转字符串的暴力解法 合并k个排序链表的归并和优先队列方法 滑雪问题的BFS解法 天使果冻的递推优化 矩阵旋转的模拟实现 小红取数的背包问题解法 字符统计的哈希应用 哈夫曼编码的实现 完全平方数的最优解 字符串转换的枚举优化 拓扑排序的BFS实现 合唱队形的序列DP解法 棋子翻转的模拟实现 区间DP问题 过桥问题的贪心+BFS解法 最大差值的优化解法 零钱兑换的完全背包问题 子串统计的滑动窗口技巧
笔试强训：Week -8
_dindong的博客
12-19 859
本文整理了多个编程题目及解法，涵盖组合数学、排序算法、动态规划、贪心算法等常见题型。包括：1)组合数概率计算；2)排序数组的二分查找/滑动窗口应用；3)循环汉诺塔递推解法；4)最小差值问题；5)DFS求素因子组合；6)贪心+二分求最长子序列；7)双指针处理区间问题；8)BFS最短路径；9)股票交易DP；10)贪心选择AOE/单体；11)N皇后冲突检测；12)区间DP取金币；13)矩阵转置；14)DFS剪枝处理选项组合；15)双指针接雨水；16)贪心求极值；17)栈的贪心排序；18)滑动窗口处理加减操作。所有
C++ 语言编程 创建 class Student类
最新发布
czhaii的专栏
06-29 204
int sno;int age;{sno=s;{age=a;int main()亮出23CM8public:int sno;int age;sno=s;age=a;int main()return 0;
1、C++ 基础知识笔记
qq_54441756的博客
06-25 461
C++基础知识
【程序运行】完整梳理应用程序从加载到 CPU 执行全流程，对比 C/Java/Python、Windows/Linux 底层差异
常无欲以观其妙，常有欲以观其徼
06-29 771
本文作者，资深底层技术爱好者，专注计算机体系结构、操作系统内核与编程语言实现原理。长期在 CSDN 分享硬核技术文章，致力于用通俗语言讲透计算机背后的运行逻辑。本文核心思想基于作者的两篇前置文章，强烈建议配合阅读：《深入CPU与操作系统的底层骗局，彻底吃透程序运行本质》《从CPU权限控制看懂Linux、Windows、鸿蒙的本质区别》你每天双击图标、敲命令、启动服务，少说几十次——为什么有些软件拷过去就能用，有些必须“安装”？为什么C语言指针能随便改内存，Java却死活不让你碰？
ROS2 C++ 运动控制算法保姆级教程
冰冻三尺非一日之寒
06-24 651
本文是ROS2 C++系列第四篇，聚焦于AGV底盘运动控制算法的常见C++实现方式。文章系统性地讲解了底盘控制中关键编程模式： 核心封装结构 class用于封装算法模块（PID控制器、运动学模型） struct管理状态数据（RobotState保存位姿/速度，ChassisParam存储机械参数） enumclass规范控制模式（STOP/MANUAL/AUTO等） 关键标准库工具 std::vector管理动态数据（路径点序列） std::array处理固定尺寸数据（轮速数组） std::clamp实现安
C++ STL 之源码阅读路线
Rick_Theseusr的博客
06-27 330
C++ STL源码阅读指南 本文提供了一份高效的C++ STL源码阅读路线图，基于GCC最新实现。内容摘要： 阅读路线：推荐从序列容器(vector/list/deque)开始，再到关联容器(map/set)和算法，最后学习分配器 源码结构： .h文件包含类定义和内联实现 .tcc文件包含长模板函数实现 关键文件分散在bits/目录下 核心实现： vector使用2倍扩容策略 deque通过中控器实现分段连续空间 关联容器基于红黑树实现 编译过程：STL是纯模板库，代码在实例化时展开 面试要点：包含7个常见
C语言：预处理进阶（宏技巧与GCC优化实战）
x1649545783的博客
06-25 281
本文深入讲解C语言预处理在工程开发中的进阶用法，涵盖标准内置宏、可变参数宏、GCC属性声明、内联函数与编译优化等核心内容。重点介绍了日志调试中常用的__FILE__、__LINE__等内置宏，##__VA_ARGS__解决空参数问题，do{}while(0)规范多行宏编写，以及弱符号、内联函数等性能优化技巧。文章通过实际代码示例演示了工业级日志宏的封装方法，并总结了面试高频考点和常见易错点，帮助开发者提升代码工程化水平和性能表现。这些技巧是区分初级与中高级开发者的重要指标，对嵌入式和高性能开发尤为重要。
【C/C++】select、poll、epoll 实战对比：从 fd_set 到就绪事件列表
wycgi的博客
06-25 133
本文对比了三种I/O多路复用技术：select、poll和epoll。通过实现TCP服务器的三个版本，展示了它们的关键特性和差异。select使用fd_set位图管理连接，需要每轮重建集合并扫描全部fd；poll改用pollfd数组，无需重建集合但仍需扫描；epoll采用事件注册机制，内核维护兴趣集合，只返回就绪事件。性能上，epoll最适合大量长连接场景。文章还提供了编译运行方法和测试指令，帮助读者实践理解这三种技术的演进过程和应用场景。
【端侧AI 与 C++】8. 使用更通用的推理引擎 ONNX Runtime (ORT) 跑通本地模型加载 - 手撕图片预处理 2
同学小张的博客
06-29 227
本文我们来实现双线性插值。
【C++】004、C与C++的最核心的区别
Tim_10的博客
06-26 203
struct结构体，他不是类，内部只有属性，没有方法，要给struct的对象的属性进行赋值，必须在外部的函数中，将该对象指针作为参数传递，在函数中进行对象属性值的赋值。C++支持面向对象（封装、继承、多态），泛型编程，，函数式（lambda）。C语言只能通过函数指针与void*来实现抽象，类型检查较弱，多态需要运行时传参，有一定开销且不直观。数据（struct封装）和操作（函数）是分离的，要操作数据，必须把数据指针传给函数。C++通过模板编程实现多态，在编译期生成代码，无运行时开销，也就是零开销抽象。
C++ NRVO
a353541382的博客
06-24 193
NRVO（Named Return Value Optimization，具名返回值优化）是 C++ 中一种编译器优化技术，旨在消除函数返回对象时产生的临时对象和多余的拷贝操作。它是 RVO（Return Value Optimization，返回值优化）的一种特例，专门处理返回"具名变量"（即有名字的局部变量）的场景。
探索C++的高效与灵活编程世界
zuowei2889的博客
06-28 202
C++是一种高效灵活的通用编程语言，由Bjarne Stroustrup在1980年代基于C语言开发。它通过引入面向对象编程（支持类、封装、继承等）增强了C语言的功能，同时保留了高性能和底层控制能力（如指针操作）。C++支持多种编程范式（面向对象、泛型、过程式），广泛应用于系统编程、游戏开发、高性能计算等领域。作为编译型语言，C++具有严格的静态类型系统，功能强大但学习曲线较陡。其标准化进程持续更新（如C++11/17/20等），不断引入现代化特性，使其在效率敏感和底层控制场景中保持不可替代的地位。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_dindong

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值