字符串系列....
猫娘 题目链接

这道题运用substr和find以及getline可以做到替换字符的作用，但是有一个小坑，就是需要暂时将替换的字符串替换成临时字符串，防止违禁词中有替换字符串的字符…

#include <bits/stdc++.h>
using namespace std;

vector<string> ban;
int n,k;
string s,tmp = "*****";

int main(){
    cin >> n;
    ban.resize(n);
    for(int i = 0;i < n;i++) cin >> ban[i];

    cin >> k;
    cin.ignore();
    getline(cin,s);

    int cnt = 0;
    for(auto &t : ban){
        int sz = t.size(),pos = s.find(t);
        while(pos!=-1){
            cnt++;
            s = s.substr(0,pos) + tmp + s.substr(pos+sz);
            pos = s.find(t);
        }
    }

    if(cnt >= k) cout << cnt << endl << "He Xie Ni Quan Jia!" << endl;
    else{
        int sz = tmp.size(),pos = s.find(tmp);
        while(pos != -1){
            s = s.substr(0,pos) + "<censored>" + s.substr(pos + sz);
            pos = s.find(tmp);
        }
        cout << s << endl;
    }
    return 0;
} 

剪切粘贴..题目
和猫娘几乎一模一样，不过比猫娘少个坑…依旧是substr和find函数配合..话说substr只写一个参数的话就是直接到结尾，这个挺好用的..

#include <bits/stdc++.h>
using namespace std;

int main(){
    string s,s1,s2;
    cin >> s;
    int n,a,b;
    cin >> n;
    while(n--){
        cin >> a >> b >> s1 >> s2;
        a--;b--;
        string cp = s.substr(a,b-a+1),ss=s1+s2;
        s.erase(a,b-a+1);
        int ii = s.find(ss);
        if(ii == -1){
            s += cp;
        }else{
            string tmp = s.substr(0,ii);
            tmp += s1;
            tmp += cp;
            tmp += s.substr(ii+s1.length(),s.length()-ii-s1.length());
            s = tmp;
        }
    }
    cout << s << endl;
    return 0;
}

树系列....
满树的遍历…不放了搜吧。
创建一个数组用来存子节点，每次遍历数组，找到最大值作为树的k，在便利一遍，看看非叶节点的度是否相同....最后通过递归求得前序遍历的结果。。

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5+10;
vector<vector<int>> tree(N); int root;
vector<int> ans; vector<int> vir(N,0);

void dfs(int root){
    ans.push_back(root);
    for(auto i : tree[root]){
        dfs(i);
    }
}

int main(){
    int n; cin >> n;
    for(int i = 1;i <= n;i++){
        int father;cin >> father;
        if(!father) root = i;

        tree[father].push_back(i);
    }

    int maxv = 0;

    for(int i = 1;i <= n;i++){
        maxv = max(maxv,(int)tree[i].size());
    }

    cout << maxv << " ";

    bool flag = true;

    for(int i = 1;i <= n;i++){
        if((int)tree[i].size() && (int)tree[i].size() < maxv) flag = false; 
    }
    if(flag) cout << "yes" << endl;
    else cout << "no" << endl;

    dfs(root);

    cout << ans[0];
    for(int i = 1;i < (int)ans.size();i++){
        cout << " " << ans[i];
    }

}

剩下的没写了..听天由命吧.....

还有些杂七杂八的题，我觉得有收获的.....
首当其冲的是一个dfs
吉利矩阵
一开始读题给我吓到了。后来仔细看了看dfs就能解决，但是要剪枝，还是挺有意思的

//好题 
#include <bits/stdc++.h>
using namespace std;
int cnt;
int l,n;
int col_total[7],row_total[7];//记录行列的总和
void dfs(int x,int y){
    if(x == n+1 && y == 1){//如果遍历到了n+1说明都弄完了，检测一下是否符合要求
        for(int i = 1;i <= n;i++){
            if(col_total[i] != l || row_total[i] != l){
                return;
            }
        }
        cnt++;
        return;
    }

    for(int i = 0;i <= 9;i++){
        if(col_total[x]+i <= l && row_total[y] <= l){
            col_total[x] += i;
            row_total[y] += i;
            if(y == n && col_total[x] != l){//如果行到头了，但是没达标就跳过这一个
                col_total[x] -= i;
                row_total[y] -= i;
                continue;
            }
            if(x == n && row_total[y] != l){//和上面同理
                col_total[x] -= i;
                row_total[y] -= i;
                continue;
            }
            if(y < n) dfs(x,y+1);//如果行没到头，继续行
            else dfs(x+1,1);//否则开下一行
            col_total[x] -= i;
            row_total[y] -= i;
        }
    }
}

int main(){
    cin >> l >> n;
    dfs(1,1);
    cout << cnt;
} 

还有个bfs的题
夺宝大赛
这道题如果从每个选手出发就会超时，只能拿12分
但是如果从终点出发，开一个数组记录每一个点距离终点的距离..在这个数组里，每一次向下一个走的时候都是dist[i+1][j] = dist[i][j] + 1......举个栗子而已，大概就是这样。更新完以后再读入选手时，将选手压入哈希表中，在从小到大遍历哈希表看看哪一个先等于1哪一个就是冠军

#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int p[N][N],dist[N][N];

const int INF = 1e9;
bool st[N][N];
int m,n;
vector<pair<int,int>> team;
int ans = -1,cnt = -1;
int dx[4] = {-1, 1, 0, 0};  // 新增：方向数组
int dy[4] = {0, 0, -1, 1};  // 新增：方向数组


void bfs(int x,int y){
    queue<pair<int,int>> q;
    q.push({x,y});
    st[x][y] = true;
    while(!q.empty()){
        auto t = q.front();
        q.pop();
        int l = t.first,r = t.second;
        for(int i = 0;i < 4;i++){
            int nex = l + dx[i],ney = r + dy[i];
            if(nex < 1 || nex > m || ney < 1 || ney > n) continue;
            if(p[nex][ney] == 0) continue;
            if(st[nex][ney]) continue;
            q.push({nex,ney});
            st[nex][ney] = true;
            dist[nex][ney] = dist[l][r] + 1;
        }
    }
}

int main(){
    cin >> m >> n;
    int rx,ry;
    for(int i = 1;i <= m;i++){
        for(int j = 1;j <= n;j++){
            cin >> p[i][j];
            if(p[i][j] == 2){
                rx = i,ry = j;
            }
            dist[i][j] = INF;//每一个默认更新到无穷大，这样后面如果碰到无穷大的选手可以忽略
        }
    }
    int k; cin >> k;
    dist[rx][ry] = 0;
    bfs(rx,ry);

    vector<int> cnt(100000,0);//建立一个表
    unordered_map<int,vector<int>> time_teams;//数据量大时用unordered_map可以优化性能
    for(int i = 1;i <= k;i++){
        int x,y;
        cin >> x >> y;
        int row = y;
        int ran = x;
        if(row < 1 || row > m || ran < 1 || ran > n){
            continue;
        }
        if(dist[row][ran] == INF){
            continue;
        }

        int time = dist[row][ran];
        cnt[time]++;
        time_teams[time].push_back(i);
    } 
    int min_time = INF;

    for(int time = 0;time < 100000;time++){
        if(cnt[time] == 1){
            min_time = time;
            break;
        }
    }

    if(min_time != INF){
        cout << time_teams[min_time][0] << " " <<min_time;
    }else{
        cout << "No winner.";
    }
}