5.18 程序测试 + 二叉树作业哈夫曼树作业

最新推荐文章于 2022-06-11 19:43:24 发布

stduy_ing

最新推荐文章于 2022-06-11 19:43:24 发布

阅读量579

点赞数

本文链接：https://blog.csdn.net/hddddh/article/details/105647946

版权

题面找不到了。。。。。。
题意：
给你一张图，没走过距离为1的路径需要花费一升水，问走遍图中的每一个顶点，水壶的容量至少要有多大，期间你可以在任何一个点把水壶装满水。

思路
因为你至少要能走遍所有的地点，很容易想到生成树，然后他又要求水壶的容量至少是多少，如果我们假设他只能在起点装水，那么最后的答案就很明显的是最小生成树的所有边的和，这样可以保证它花的水是最少的。如果我们考虑他能装水，那么答案就是最小生成树里最长的那条边了。

#include<iostream>
#include<cstdio>
#include<map>
#include<math.h>
#include<queue>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=1e3+7;
int fa[maxn];
struct stu {
      int from,to,val;
};
struct stu s[maxn];
bool cmp (stu x,stu y){      //sort 的排序规则,定义根据路径长度从小到大排序。 
    return x.val<y.val;
}
int find(int x){             //找父亲的操作,递归了一下,找到了就返回.
    if(fa[x]!=x) fa[x]=find(fa[x]);
    return fa[x];
}
int find(int x){
	int a=x,b;
	while(x!=fa[x]) x=fa[x];
	while(a!=fa[a]){
		b=fa[a];
		fa[a]=x;
		a=b;
	}
	return x;
}
void conbine(int x,int y){   //把两个节点连接起来。
     int temp1=find(x);
     int temp2=find(y);
     fa[temp1]=temp2;
}
int main (){
    int n,m,ans=0;
    scanf("%d%d",&n,&m);
    for(int i=0;i<m;i++){
        scanf("%d%d%d",&s[i].from,&s[i].to,&s[i].val);
    }
    for(int i=1;i<=n;i++) fa[i]=i;   //初始化 父亲是本身
    
    sort(s,s+n,cmp);
    for(int i=0;i<m;i++){
        if(find(s[i].from)!=find(s[i].to)){  //判断两个节点是不是连接的,如果不是就连接，并且更新答案。
            conbine(s[i].from,s[i].to);
            ans=max(s[i].val,ans);
        }
    }
    printf ("%d\n",ans);
    return 0;
}

第二题
题意：
给一张无向关系图，要求两个不直接相邻的人之间最多隔着六个人，问是否满足该条件。仔细考虑一下，其实就是如果两个人之间的距离大于5或者不联通，就是不满足的。
思路：
最短路裸题，三种常用的最短路方法（dij,floyd,spfa）都能写，但根据每条边的距离都是1的特点，可以利用 bfs的特点（每次访问最近点），求最短路。其他两种方法就不记录了。

floyd代码

#include<iostream>
#include<cstdio>
#include<map>
#include<math.h>
#include<queue>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn=2e2+7;
int dis[maxn][maxn],n,m;
void floyd(){
     for(int k=0;k<n;k++){
         for(int i=0;i<n;i++){
             for(int j=0;j<n;j++){
                dis[i][j]=min(dis[i][j], dis[i][k]+dis[k][j]);

             }
         }
     }
}
int main (){
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            dis[i][j]=1000;
        }
    }
    for(int i=0;i<n;i++) dis[i][i]=0;
    int u,v,flag=1;
    for(int i=0;i<m;i++){
        cin>>u>>v;
       if(dis[u][v]>1) dis[u][v]=dis[v][u]=1;
    }
    floyd();
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            if(dis[i][j]>5) flag=0;
        }
    }
    if(flag) printf ("Yes\n");
    else printf ("No\n");
    

}

这种方法是我考完后想的，可能写起来没 floyd简单，但思路还是值得记录一下的。

#include<iostream>
#include<cstdio>
#include<map>
#include<math.h>
#include<queue>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn=2e2+7;
int dis[maxn],n,m,mp[maxn][maxn],vis[maxn];
int bfs(int s,int v){
    memset(dis,0x3f3f3f3f,sizeof(dis));
    memset(vis,0,sizeof(vis));
    queue<int >que;
    dis[s]=v;vis[s]=1;       //起点距离赋值为 0 ;
    que.push(s);
    while(que.size()){
        int x=que.front();que.pop();
        for(int i=0;i<n;i++){
            if(mp[x][i]!=0&&vis[i]==0){   //vis=0表示这个点还没有访问过  mp!=0表示两个点可以直接访问.
                dis[i]=dis[x]+1;          //这个点到起点的距离等于上个点的距离 +1
                vis[i]=1;                 //标记访问过的点
                que.push(i);              //该点放入队列
            }
        }
    }
    for(int i=0;i<n;i++){
        if(dis[i]>5) return false;        //距起点距离大于 5 说明不符合
    }
    return true;
}
int main (){
    int u,v,flag=1;
    memset(mp,0,sizeof(mp));
    for(int i=0;i<m;i++){
        cin>>u>>v;
        mp[u][v]=mp[v][u]=1;  //mp存图
    }
    for(int i=0;i<n;i++){
        if(!bfs(i,0)){
          flag=0;
          break;
        }
    }
    if(flag) printf ("Yes\n");
    else printf ("No\n");
   

}

运行样例
//AB#D##C##
//ABD##E##CF###
//层序遍历 ABCDEF
//AB#DE###CF#G###
//层序遍历 ABCDFEG
//ABDH##I##EJ###CF##G####

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

const int maxn=6e3+7;
int n;
char val[maxn<<1],mlval[maxn<<1];         //rt<<1等价于  rt*2  rt<<1|1 等价于 rt*2+1
int sum;
void build(int rt){
     scanf("%c",&val[rt]);         //把节点值存入一维数组
     sum=max(sum,rt);
     if(val[rt]=='#') return ;     //节点为空，退出递归
     build(rt<<1);                 //继续填入 rt节点的左儿子
     build(rt<<1|1);

}
void dis1(int root){
     if(val[root]=='#') return ;
     printf ("%c ",val[root]);
     dis1(root<<1);
     dis1(root<<1|1);

}
void dis2(int root){
     if(val[root]=='#') return ;
     dis2(root<<1);
     printf ("%c ",val[root]);
     dis2(root<<1|1);

}
void dis3(int root){
     if(val[root]=='#') return ;
     dis3(root<<1);
     dis3(root<<1|1);
     printf ("%c ",val[root]);
}
void dis4(int root){             //层序遍历直接 遍历数组就好了，因为数组中的节点顺序本来就是层序的顺序
     while(root<=sum){
        if(val[root]!='#') printf ("%c ",val[root]);
        root++;
     }
}
void ct(char c,int root){        //删除子树
     if(val[root]=='#') return ;
     if(val[root]==c){      //找到了要删除的节点直接置为空，下次遍历到这个节点就不会继续递归了  达到了删除整个树的目的
            val[root]='#';
            return ;
     }
     ct(c,root<<1);
     ct(c,root<<1|1);
}
int getdepth(int root,int depth){        //获取树的深度 ，这里第二个参数是为了维护深度
    if(val[root]=='#') return depth;
    return max(getdepth(root<<1,depth+1),getdepth(root<<1|1,depth+1));
}

int getcount1(int root){         //获取总结点数
    if(val[root<<1]=='#'&&val[root<<1|1]=='#') return 1;    //如果到达了叶子节点返回 1
    if(val[root]=='#') return 0;        //到达空节点 返回 0

    return getcount1(root<<1)+getcount1(root<<1|1)+1;    //这里需要 +1 因为本身也要算进去
}

int getcount2(int root){         //获取叶子节点数
    if(val[root<<1]=='#'&&val[root<<1|1]=='#') return 1;
    if(val[root]=='#') return 0;

    return getcount2(root<<1)+getcount2(root<<1|1);          //这里不需要 +1，只要算叶子节点
}


bool istree(int root){            // 判断是否为完全二叉树
     if(val[root<<1]=='#'&&val[root<<1|1]!='#') return 1;  //出现了左儿子为空右儿子不为空的情况，则不是完全二叉树
     if(val[root]=='#') return 0;
     return istree(root<<1)+istree(root<<1|1);
}

void copytree(){        //复制树，因为是数组存的所以直接遍历复制就好了
     for(int i=1;i<=sum;i++) mlval[i]=val[i];
}

int main(){
   char ch;
   build(1);
   printf("树的深度：%d\n",getdepth(1,0));
   printf ("总节点数: %d\n",getcount1(1));
   printf ("叶子节点数: %d\n",getcount2(1));

   if(istree(1)==1) printf ("不是完全二叉树\n");
   else printf ("是完全二叉树\n");

   printf ("前序："); dis1(1);printf ("\n");
   printf ("中序："); dis2(1);printf ("\n");
   printf ("后序："); dis3(1);printf ("\n");
   printf ("层次："); dis4(1);printf ("\n");

   printf("请输入需要删除的字符的子树: \n");
   getchar();
   scanf("%c",&ch);
   ct(ch,1);
   printf ("删除后前序："); dis1(1);printf ("\n");
   printf ("删除后总节点数: %d\n",getcount1(1));
   printf ("删除后叶子节点数: %d\n",getcount2(1));

   ct(val[1],1);
   printf ("清空后前序遍历：");dis1(1);printf ("\n");

}

哈夫曼编码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e3;
struct node
{
    int w,l,r,fa,vis;
    char c;
    bool operator >(node a) const
    {
        return w > a.w;
    }

} e[maxn],m1,m2;
int sw,n;
string ans[10];
priority_queue<node, vector<node>, greater<node> > q;//优先队列，可以直接达到筛选出最小的两个节点的效果
void init(int n)
{
    for(int i=0; i<2*n-1; i++)
    {
        e[i].l=-1,e[i].r=-1,e[i].fa=-1;
        e[i].c='#';
    }
}
void buildtree(char *s,int *cnt)
{
    for(int i=0; i<n; i++)
    {
        e[i].c=s[i],e[i].w=cnt[i],e[i].vis=i;
        q.push(e[i]);
    }
    while(q.size()>=2)
    {
        m1=q.top();
        q.pop();
        m2=q.top();
        q.pop();
        sw=m1.w+m2.w;
        e[n].w=sw;
        e[n].l=m1.vis;
        e[n].r=m2.vis;
        e[n].vis=n;
        e[m1.vis].fa=n;
        e[m2.vis].fa=n;
        q.push(e[n]);
        n++;
    }
}
void distree(int n)
{
    for(int i=0; i<=12; i++)
    {
        printf ("%d weighe=%d father=%d leftchild=%d rightchild=%d\n",i,e[i].w,e[i].fa,e[i].l,e[i].r);
    }
}
void huffmanCoding(int x,string s)
{
    if(e[x].l==-1)
    {
        ans[e[x].vis]=s;
        return ;
    }
    huffmanCoding(e[x].l,s+'0');
    huffmanCoding(e[x].r,s+'1');
}
int main()
{
    char s[10]= {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
    int cnt[10]= {9, 11, 5, 7, 8, 2, 3};
    n=7;
    init(7);
    buildtree(s,cnt);
    printf ("哈夫曼树:\n");
    distree(7);
    huffmanCoding(n-1,"");
    printf ("哈夫曼编码:\n");
    for(int i=0; i<7; i++)
    {
        cout<<e[i].c<<' '<<':'<<ans[i]<<endl;
    }
}