考研失败…准备再战复旦。{光草真的很漂亮}{难忘逸夫楼前紧张的心情…}
{今年要更加努力了qaq}
先从机试回顾一下吧..（回忆版题目）
需要自己处理输入输出..把代码思路和输入输出都传上去，qaq后面我才知道朋友的思路什么的是用wps交的，
1.a,b两棵树，判断a树与b树的一颗子树是否完全相同
2.给一个序列a1到an，和一个d。an数组排序后，后一个数减去前一个数的最大值不小于d，请问最多能从an中选出多少满足条件的数字（贪心）
3.力扣原题，高尔夫比赛的森林砍树

第一题

#include<iostream>
using namespace std;
typedef struct node
{
    struct node *left;
    struct node *right；
    char  data;
}BiTreeNode,*BiTree;
public:
    bool check(BiTree *o,BiTree *t){
        if(!o&&!t){
            return true;
        }
        if((!o&&t)||(o&&!t)||(o->val!=t->val)){
            return false;
        }
        //继续检查左右子树
        return check(o->left,t-left)&&check(o->right,t->right);
    }
    bool dfs(BiTree *o,BiTree *t){//先找到相同的那个节点，dfs大的树
        if(!o){
            return false;
        }
        return check(o,t)||dfs(o->left,t)||dfs(o->right,t);
    }
    bool isSubtree(BiTree *s,BiTree *t)
    {
        return dfs(s,t);
    }
    //其实考试的时候我在还有纠结处理输入输出的问题，希望上岸的朋友给点建议...k考虑了之后，以下是根据输入序列按照顺序建立二叉树的代码，
    void createBiTree(BiTree &T){
        //输入需要将二叉树补成满二叉树,如ABD###E###C## 
        char c;
        cin>>c;
        if('#'==c)//遇到#，结束该分支的递归
        T=NULL;
        else{
            T=new BiTreeNode;
            T->data=c;
            createBiTree(T->left);
            createBiTree(T->right);
        }
    }
    int main()
    {
        BiTree root;
        createBiTree(root);
        return 0;
    }

第二题(贪心)

#include<bits/stdc++.h>
int n;
int pre=-d;//初值设置保证有一个数字时肯定可以
int sum=0;
cin>>n;
vector<int>num(n);
 for(int i=0;i<n;i++){
     cin>>num[i];
 }
 sort(num.begin(),num.end());
 for(int i=0;i<num.size();i++)
 {
     if(num[i]-pre>=d){
         sum++;       
         pre=num[i];
     }
 }

第三题（力扣上是hard，我问了一些朋友好像做了半道这样子，不过感觉有很多厉害的大佬呢，不知道整体大家做的怎么样）

class Solution{
    public:
    int dirs[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
    int bfs(vector<vector><int>>&forest,int sx,int sy,int tx,int ty){
        if(sx==tx&&sy==ty){
        return 0;
        }
        int row =forest.size();
        int col =forest[0].size();
        int step = 0;
        queue<pair<int,int>>qu;
        vector<vector<bool>>visited(row,vector<bool>(col,false));
        qu.emplace(sx,sy);
        visited[sx][sy]=true;
        while(!qu.empty()){
            step++;
            int sz=qu.size();
            for(int i=0;i<sz;++i){
                auto[cx,cy]=qu.front();
                qu.pop();
                for(int j=0;j<4;++j){
                    int nx=cx+dirs[j][0];
                    int ny=cy+dirs[j][1];
                    if(nx>=0&&nx<row&&ny>=0&&ny<col){
                        if(!visited[nx][ny]&&forest[nx][ny]>0)
                        {
                            if(nx==tx&&ny==ty)
                            {
                              return step;
                            }
                        qu.emplace(nx,ny);
                        visited[nx][ny]=ture;
                        }
                    }
                }
            }
        }
         return -1;
    }
    int cutOffTree(vector<vector><int>>&forest){
        vector<pair<int,int>>trees;
        int row= forest.size();
        int col= forest[0].size();
        for(int i=0;i<row;++i){
            for(int j=0;j<col;++j){
                if(forest[i][j]>1){
                    trees.emplace_back(i,j);
                }
            }
        }
        sort(tree.begin(),tree.end(),[&](const pair<int,int>&a,const pair<int,int>&b){
        return forest[a.first][a.second]<forest[b.first][b.second];
        });
        int cx =0;
        int cy=0;
        int ans=0;
        for(int i=0;i<tree.size();++i){
            int step =bfs(forest,cx,cy,tree[i].first,tree[i].second);
            if(steps==-1){
                return -1;
            }
            ans+=steps;
            cx=tree[i].first;
            cy=tree[i].second;
        }

        return ans;
    }
}