2022/1/18总结

1二叉树的深度

一开始我用链表开始建树，再求它的深度，但是只过了样例得了40分，但用dfs做完全不用那么麻烦，利用递归看左右枝最长路径就是它的深度

不知道错的链表

#include<iostream>
#include<algorithm>
using namespace std;
struct node
{
    int data;
    node *l ,*r;
};
int n;
int i=1;
  void creat(node *&Node)
  {
      if(i>n)return;
     
      int d1,d2;
      if(i==1)
      {
          Node=new node;
          Node->data=1;
       cin >> d1 >> d2;
      if(d1) {
          Node->l=new node;
          Node->l->data=d1;
      }
      else Node->l=NULL;
      if(d2){
          Node->r=new node;
           Node->r->data=d2;
      }
       else Node->r=NULL;
      }
     else
     {
         cin >> d1 >> d2;
     if(d1) {
          Node->l=new node;
          Node->l->data=d1;
      }
      else Node->l=NULL;
      if(d2){
          Node->r=new node;
           Node->r->data=d2;
      }
       else Node->r=NULL;
     }
     if(d1)i++,creat(Node->l);
     if(d2)i++,creat(Node->r);
  }

   int depthoftree(node * Node)//树的深度
   {
       if(Node)
       {
           return max(depthoftree(Node->l),depthoftree(Node->r))+1;
          
       }
        else return 0;
   }
   int main()
   {
      
       cin>> n;
       node *Node;
       creat(Node);
       for(;i<n;i++)
       {
           int d1,d2;
           cin >>d1>>d2;
       }
       n=depthoftree(Node);
       cout << n;
   } 

深度dfs

#include<iostream>
#include<algorithm>
using namespace std;
const int max_n=1e6+10;
struct node
{
    int l,r;
}tree[max_n];
int n,m1=-99999999;
void dfs(int root,int step)
{
    if(root==0) return;
    m1=max(m1,step);//求最大深度
    dfs(tree[root].l,step+1);//递归
    dfs(tree[root].r,step+1);
    
}
int main()
{
    cin >> n;
    for(int i=1;i<=n;i++)
    cin>>tree[i].l>>tree[i].r;//输入左节点右节点
    dfs(1,1);//根节点，和深度
    cout << m1;
    return 0;
}

今天下午听学长讲题豁然开朗，做了了两个并查集的模板题。这两题我只写了一遍因为只要改下参数就行了，两题可以说完全一样

#include<iostream>
#include<algorithm>
using namespace std;
const int max_n=1e6+10;
int f[max_n];
void init(int n)//对父节点初始化
{
    for(int i=1;i<=n;i++)
    {
        f[i]=i;
      
    }
}
int find(int i)//查找父节点
{
    if(f[i]==i)
    return i;
    else{
        f[i]=find(f[i]);//缩短路径，把所有一棵树的父节点变成相同的
        return f[i];

    }
}
void unio(int i,int j)//并起来
{
   int i_fa=find(i);
   int j_fa=find(j);
   f[i_fa]=j_fa;
}
int main()
{
    int n,m,p;
    cin >> n >>m >> p;
    init(n);
    for(int i=1;i<=m;i++)
    {
        int x,y;
        cin >> x>>y;
        unio(x,y);
    }
    for(int i=1;i<=p;i++)
    {
        int x,y;
        cin >>x >> y;
        {
            if(find(x)==find(y))
            cout <<"Yes"<< endl;
            else cout << "No"<< endl;
        }
    }
}

3.搭配购买

此题要结合01背包去做，我们可以在集合的时候,将这个集合的云朵数和价值累加起来，再利用01背包，01背包只查找和根节点

#include <iostream>
#include <algorithm>
using namespace std;
const int max_n=1e6+10;
int fa[max_n],yd[max_n],v[max_n];//爸爸，云朵，价值
int bag[max_n];//背包
void init(int n)
{
    for(int i=1;i<=n;i++)
    fa[i]=i;
}
int find(int i)
{
    if(fa[i]==i)
    return fa[i];
    else {
        fa[i]=find(fa[i]);
        return fa[i];
    }
}
void unio(int i,int j)
{
    int fi=find(i);
    int fj=find(j);
    if(fi!=fj)
    {
        fa[fi]=fj;
        yd[fj]+=yd[fi];//云朵加起来
        v[fj]+=v[fi];//价值总和
    }
}

int main()
{
    int n,w,m;
    cin>> n >> m >>w;
    init(n);
    for(int i=1;i<=n;i++)
    cin >>yd[i]>>v[i];
    for(int i=1;i<=m;i++)//集合
    {
        int x,y;
        cin >> x >>y;
        unio(x,y);
    }
    for(int i=1;i<=n;i++)//01背包
    if(fa[i]==i)//找到根节点
    for(int j=w;j>=yd[i];j--)
     bag[j]=max(bag[j],bag[j+-yd[i]]+v[i]);
    cout << bag[w];
}