第四次上机赛标程

最新推荐文章于 2021-07-26 11:14:33 发布
最新推荐文章于 2021-07-26 11:14:33 发布
阅读量1k 收藏 2
点赞数
分类专栏： 北航软件学院2013级数据结构解题报告
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjf_wzzc/article/details/26750033
版权

　　这次渣诚来写解题报告，我只放我的标程；大量与书中风格不同的代码请慎入。

　　A. 二叉树的最短路

　　利用二叉树的数学性质。

#include<cstdio>
using namespace std;
int main()
{
    int n,x,y;
    scanf("%d",&n);
    while(n--)
    {
        scanf("%d%d",&x,&y);
        int ans=0;
        while(x!=y)
        {
            x>y?x>>=1:y>>=1;
            ++ans;
        }
        printf("%d\n",ans);
    }
}

　　B. 同构二叉树

　　配套的学习指导上有源代码。

#include<cstdio>
#include<cstdlib>
#include<cstring>
using namespace std;
const int MAXN=1005;
struct BTNode
{
    char data[10];
    BTNode *lchild,*rchild;
};
char str[MAXN];
void CreateBTNode(BTNode *&b)
{
    BTNode *St[MAXN],*p;
    int top=-1,k,l=strlen(str);
    b=NULL;
    for(int i=0; i<l; ++i)
        switch(str[i])
        {
        case '(':
            St[++top]=p;
            k=1;
            break;
        case ')':
            --top;
            break;
        case ',':
            k=2;
            break;
        default:
            p=(BTNode *)malloc(sizeof(BTNode));
            int j=0;
            while(i<l&&str[i]!='('&&str[i]!=')'&&str[i]!=',')
                p->data[j++]=str[i++];
            --i;
            p->data[j]='\0';
            p->lchild=p->rchild=NULL;
            if(!b)
                b=p;
            else
                switch(k)
                {
                case 1:
                    St[top]->lchild=p;
                    break;
                case 2:
                    St[top]->rchild=p;
                    break;
                }
        }
}
bool Symm(BTNode *b1,BTNode *b2)
{
    if(!b1&&!b2)
        return true;
    if(!b1||!b2)
        return false;
    else
        return Symm(b1->lchild,b2->lchild)&&Symm(b1->rchild,b2->rchild);
}
bool Symmtree(BTNode *b)
{
    if(!b)
        return true;
    return Symm(b->lchild,b->rchild);
}
void DestroyBT(BTNode *&b)
{
    if(b->lchild)
        DestroyBT(b->lchild);
    if(b->rchild)
        DestroyBT(b->rchild);
    free(b);
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%s",str);
        BTNode *b;
        CreateBTNode(b);
        puts(Symmtree(b)?"YES":"NO");
        DestroyBT(b);
    }
}

　　C. Papers

　　哈夫曼树，扔板子就行了。其实不需要建一棵树出来，哈夫曼树的本质是贪心，故而可以建一个堆或用一个优先队列来搞。我写了建哈夫曼树和优先队列两个版本。

#include<cstdio>
#include<cstring>
using namespace std;
const int MAXN=5005;
const int INF=0x3f3f3f3f;
struct HuffmanTree
{
    int parent[MAXN<<1];
    int lchild[MAXN<<1];
    int rchild[MAXN<<1];
    int weight[MAXN<<1];
} ht;
int n;
void CreateHT()
{
    int lnode,rnode,min1,min2;
    memset(ht.parent,0xff,sizeof(ht.parent));
    memset(ht.lchild,0xff,sizeof(ht.lchild));
    memset(ht.rchild,0xff,sizeof(ht.rchild));
    for(int i=n; i<(n<<1)-1; ++i)
    {
        min1=min2=INF;
        lnode=rnode=-1;
        for(int j=0; j<i; ++j)
            if(!~ht.parent[j])
            {
                if(ht.weight[j]<min1)
                {
                    min2=min1;
                    rnode=lnode;
                    min1=ht.weight[j];
                    lnode=j;
                }
                else if(ht.weight[j]<min2)
                {
                    min2=ht.weight[j];
                    rnode=j;
                }
            }
        ht.weight[i]=ht.weight[lnode]+ht.weight[rnode];
        ht.lchild[i]=lnode;
        ht.rchild[i]=rnode;
        ht.parent[lnode]=ht.parent[rnode]=i;
    }
}
int main()
{
    while(~scanf("%d",&n))
    {
        for(int i=0; i<n; ++i)
            scanf("%d",&ht.weight[i]);
        CreateHT();
        int ans=0;
        for(int i=n; i<(n<<1)-1; ++i)
            ans+=ht.weight[i];
        printf("%d\n",ans);
    }
}
#include<cstdio>
#include<vector>
#include<queue>
using namespace std;
int main()
{
    int n,x;
    while(~scanf("%d",&n))
    {
        priority_queue<int,vector<int>,greater<int> > pq;
        while(n--)
        {
            scanf("%d",&x);
            pq.push(x);
        }
        int ans=0;
        while(pq.size()>1)
        {
            int x=pq.top();
            pq.pop();
            int y=pq.top();
            pq.pop();
            ans+=x+y;
            pq.push(x+y);
        }
        printf("%d\n",ans);
    }
}

　　D. 电报编码

　　哈夫曼编码，板子题。还是建哈夫曼树和优先队列两个版本。

#include<cstdio>
#include<cstring>
using namespace std;
const int MAXN=30;
const int MAXM=2005;
const int INF=0x3f3f3f3f;
struct HuffmanTree
{
    int parent[MAXN<<1];
    int lchild[MAXN<<1];
    int rchild[MAXN<<1];
    int weight[MAXN<<1];
} ht;
char str[MAXM];
int cnt[MAXN],n;
void CreateHT()
{
    int lnode,rnode,min1,min2;
    memset(ht.parent,0xff,sizeof(ht.parent));
    memset(ht.lchild,0xff,sizeof(ht.lchild));
    memset(ht.rchild,0xff,sizeof(ht.rchild));
    for(int i=n; i<(n<<1)-1; ++i)
    {
        min1=min2=INF;
        lnode=rnode=-1;
        for(int j=0; j<i; ++j)
            if(!~ht.parent[j])
            {
                if(ht.weight[j]<min1)
                {
                    min2=min1;
                    rnode=lnode;
                    min1=ht.weight[j];
                    lnode=j;
                }
                else if(ht.weight[j]<min2)
                {
                    min2=ht.weight[j];
                    rnode=j;
                }
            }
        ht.weight[i]=ht.weight[lnode]+ht.weight[rnode];
        ht.lchild[i]=lnode;
        ht.rchild[i]=rnode;
        ht.parent[lnode]=ht.parent[rnode]=i;
    }
}
int main()
{
    while(~scanf("%d",&n))
    {
        scanf("%s",str);
        int l=strlen(str);
        n=0;
        memset(cnt,0,sizeof(cnt));
        for(int i=0; i<l; ++i)
            ++cnt[str[i]-'a'];
        for(int i=0; i<26; ++i)
            if(cnt[i]>0)
                ht.weight[n++]=cnt[i];
        CreateHT();
        int ans=0;
        for(int i=n; i<(n<<1)-1; ++i)
            ans+=ht.weight[i];
        printf("%d\n",ans);
    }
}
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
using namespace std;
const int MAXN=2005;
char str[MAXN];
int main()
{
    int n,cnt[30];
    while(~scanf("%d",&n))
    {
        scanf("%s",str);
        int l=strlen(str);
        memset(cnt,0,sizeof(cnt));
        for(int i=0; i<l; ++i)
            ++cnt[str[i]-'a'];
        priority_queue<int,vector<int>,greater<int> > pq;
        for(int i=0; i<26; ++i)
            if(cnt[i]>0)
                pq.push(cnt[i]);
        int ans=0;
        while(pq.size()>1)
        {
            int x=pq.top();
            pq.pop();
            int y=pq.top();
            pq.pop();
            ans+=x+y;
            pq.push(x+y);
        }
        printf("%d\n",ans);
    }
}

　　E. Who Are My Friends?(Ⅰ)

　　原意是考查并查集，不断合并朋友，最后看还剩下几组。事实上也可以用图论做，认为朋友之间存在一条边，则连通子图的个数就是答案，遍历一遍即可。

　　这里想说一点是，书上对并查集的优化是根据树的层次合并以维护树高，保持每次查询的复杂度在O(logn)；但最常用的优化方式是路径压缩，可以使查询复杂度接近O(1)；实测时发现数据量小的时候几无差别，数据量大的时候路径压缩会更快一些。我这里放出三种标程，分别是路径压缩的并查集，维护树高的并查集，以及图论dfs。

#include<cstdio>
using namespace std;
const int MAXN=10005;
int u[MAXN];
void init()
{
    for(int i=0; i<MAXN; ++i)
        u[i]=i;
}
int find(int x)
{
    if(u[x]!=x)
        u[x]=find(u[x]);
    return u[x];
}
void merge(int x,int y)
{
    u[find(x)]=find(y);
}
int main()
{
    int n,m,a,b;
    while(~scanf("%d%d",&n,&m))
    {
        init();
        while(m--)
        {
            scanf("%d%d",&a,&b);
            merge(a,b);
        }
        int ans=0;
        for(int i=1; i<=n; ++i)
            if(find(i)==i)
                ++ans;
        printf("%d\n",ans);
    }
}
#include<cstdio>
using namespace std;
const int MAXN=10005;
int u[MAXN],r[MAXN];
void init()
{
    for(int i=0; i<MAXN; ++i)
    {
        u[i]=i;
        r[i]=0;
    }
}
int find(int x)
{
    if(u[x]!=x)
        return find(u[x]);
    return u[x];
}
void merge(int x,int y)
{
    x=find(x);
    y=find(y);
    if(r[x]>r[y])
        u[y]=x;
    else
    {
        u[x]=y;
        if(r[x]==r[y])
            ++r[y];
    }
}
int main()
{
    int n,m,a,b;
    while(~scanf("%d%d",&n,&m))
    {
        init();
        while(m--)
        {
            scanf("%d%d",&a,&b);
            merge(a,b);
        }
        int ans=0;
        for(int i=1; i<=n; ++i)
            if(find(i)==i)
                ++ans;
        printf("%d\n",ans);
    }
}
#include<cstdio>
#include<cstring>
using namespace std;
const int MAXN=10005;
const int MAXM=200005;
struct graph
{
    int head[MAXN];
    int to[MAXM];
    int next[MAXM];
    int tot;
    void init()
    {
        tot=0;
        memset(head,0xff,sizeof(head));
    }
    void add(int x,int y)
    {
        to[tot]=y;
        next[tot]=head[x];
        head[x]=tot++;
    }
} g;
bool vis[MAXN];
void dfs(int x)
{
    vis[x]=true;
    for(int i=g.head[x]; ~i; i=g.next[i])
    {
        int v=g.to[i];
        if(!vis[v])
            dfs(v);
    }
}
int main()
{
    int n,m,a,b;
    while(~scanf("%d%d",&n,&m))
    {
        g.init();
        memset(vis,false,sizeof(vis));
        while(m--)
        {
            scanf("%d%d",&a,&b);
            g.add(a,b);
            g.add(b,a);
        }
        int ans=0;
        for(int i=1; i<=n; ++i)
            if(!vis[i])
            {
                ++ans;
                dfs(i);
            }
        printf("%d\n",ans);
    }
}

　　F. Who Are My Friends?(Ⅱ)

　　跟上一题只有很小的区别。并查集合并，每次判断两个人是否在一个组。也可以用图论做，每次判断两个人是否在一个连通子图，方法是遍历时记录每个点所在连通子图的标号。还是三种姿势的代码。

#include<cstdio>
using namespace std;
const int MAXN=10005;
int u[MAXN];
void init()
{
    for(int i=0; i<MAXN; ++i)
        u[i]=i;
}
int find(int x)
{
    if(u[x]!=x)
        u[x]=find(u[x]);
    return u[x];
}
void merge(int x,int y)
{
    u[find(x)]=find(y);
}
bool query(int x,int y)
{
    return find(x)==find(y);
}
int main()
{
    int n,m,k,a,b;
    while(~scanf("%d%d%d",&n,&m,&k))
    {
        init();
        while(m--)
        {
            scanf("%d%d",&a,&b);
            merge(a,b);
        }
        while(k--)
        {
            scanf("%d%d",&a,&b);
            puts(query(a,b)?"Great!":"Pity...");
        }
    }
}
#include<cstdio>
using namespace std;
const int MAXN=10005;
int u[MAXN],r[MAXN];
void init()
{
    for(int i=0; i<MAXN; ++i)
    {
        u[i]=i;
        r[i]=0;
    }
}
int find(int x)
{
    if(u[x]!=x)
        return find(u[x]);
    return u[x];
}
void merge(int x,int y)
{
    x=find(x);
    y=find(y);
    if(r[x]>r[y])
        u[y]=x;
    else
    {
        u[x]=y;
        if(r[x]==r[y])
            ++r[y];
    }
}
bool query(int x,int y)
{
    return find(x)==find(y);
}
int main()
{
    int n,m,k,a,b;
    while(~scanf("%d%d%d",&n,&m,&k))
    {
        init();
        while(m--)
        {
            scanf("%d%d",&a,&b);
            merge(a,b);
        }
        while(k--)
        {
            scanf("%d%d",&a,&b);
            puts(query(a,b)?"Great!":"Pity...");
        }
    }
}
#include<cstdio>
#include<cstring>
using namespace std;
const int MAXN=10005;
const int MAXM=200005;
struct graph
{
    int head[MAXN];
    int to[MAXM];
    int next[MAXM];
    int tot;
    void init()
    {
        tot=0;
        memset(head,0xff,sizeof(head));
    }
    void add(int x,int y)
    {
        to[tot]=y;
        next[tot]=head[x];
        head[x]=tot++;
    }
} g;
int u[MAXN],cnt;
bool vis[MAXN];
void dfs(int x)
{
    u[x]=cnt;
    vis[x]=true;
    for(int i=g.head[x]; ~i; i=g.next[i])
    {
        int v=g.to[i];
        if(!vis[v])
            dfs(v);
    }
}
int main()
{
    int n,m,k,a,b;
    while(~scanf("%d%d%d",&n,&m,&k))
    {
        g.init();
        memset(vis,false,sizeof(vis));
        while(m--)
        {
            scanf("%d%d",&a,&b);
            g.add(a,b);
            g.add(b,a);
        }
        cnt=0;
        for(int i=1; i<=n; ++i)
            if(!vis[i])
            {
                ++cnt;
                dfs(i);
            }
        while(k--)
        {
            scanf("%d%d",&a,&b);
            puts(u[a]==u[b]?"Great!":"Pity...");
        }
    }
}

　　G. 邻接矩阵转邻接表

　　不能更水，根据两种结构的联系来做，不用建图。

#include<cstdio>
using namespace std;
int main()
{
    int m,n,x;
    while(~scanf("%d%d",&m,&n))
        for(int i=0; i<m; ++i)
        {
            printf("%d:",i);
            for(int j=0; j<m; ++j)
            {
                scanf("%d",&x);
                if(x>0)
                    printf("%d ",j);
            }
            putchar('\n');
        }
}

　　因为题出得很水，所以这次上机结果看起来相当好……

wjfwzzc
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第一次上机赛解题报告及标程
the CodeRoom of wjfwzzc
03-25 1492
目前我和渣诚基本确定了这样的分工，那就是他来写书上代码构造成的标程，我来写用STL或者其他方法实现的标程。说实话，作为一个渣渣ACMer，这种感觉挺好…… 　　言归正传。第一次上机成绩非常惨烈，一方面我和渣诚在题目顺序的安排上出了点问题，把最基础的链表操作题目放在了最后，题干最吓人（注意不是最难的）放在了第一道。经过被关导叫去喝茶以及与老师的沟通之后，以后的上机会尽量精简题干，数据量的要求也会降
航空航天大类C语言程设第二次上机练习
Hakureimu6324的博客
08-11 525
航空航天大类C语言程设第二次上机练习 第二期更新，主要是第二次上机及练习赛的内容。 Q1（上机A题）一个非负的浮点数（小数部分不超过六位），输出它的小数部分（六位小数保留）和整数部分（空格隔开） 这个题只要稍微熟悉一下变量声明就很好做了，注意给的是非负浮点数，所以少了个坑（狗头） 先给出代码 #include <stdio.h> int main() { double x; sca...
多校联合赛标程
07-22
2014 Multi-University Training Contest 1多校联合赛标程和部分数据。
【sscanf】@CQU2014 校赛_A.Algorithm 标程阅读
CD's Coding
05-11 730
ProblemA. Algorithm input:algorithm.in output: algorithm.out   简单来说，所谓算法(algorithm)就是定义良好的计算过程，它取一个或一组值作为输入，并产生出一个或一组值作为输出。亦即，算法就是一系列的计算步骤，用来将输入数据转换成输出结果。 我们还可以将算法看作是一种工具，用来解决一个具有良好规格说明的计算问题。有关该问题
第三次上机赛标程
the CodeRoom of wjfwzzc
04-22 1024
渣诚解题报告在此，我只放标程不说话。
第二次上机赛解题报告及标程
the CodeRoom of wjfwzzc
04-11 1139
此次上机，起码从board上看要比第一次好了许多……虽然距离理想状态还是差了一些……
第七次练习赛解题报告及标程
the CodeRoom of wjfwzzc
06-11 1273
这次的题目难度不夸张的可以说是历次上机和练习的难度之最
航空航天大类C语言程设第三次练习赛
Hakureimu6324的博客
08-23 434
航空航天大类C语言程设第三次练习赛 第四期更新，鸽子博主终于更新第三次练习赛了 （A题）求区间交并集 多行数据，每行有两个数，用空格分开，表示每个区间的下和上界，保证是合法的非空集，而且得到的并集是一个连续的区间。 输入样例： 1 3 1 2 -1 5 输出样例： 1 2 -1 5 样例图示： 思路很简单，最开始的区间作为初始交并区间，每读入一个区间：求并集，左端点的最小值和右端点的最大...
NCPC 2017部分题题解（第一次组队磨合赛）
star_moon0309的博客
06-26 394
题目链接：https://cn.vjudge.net/contest/235654#overview建队以来的第一场组队赛，打的总体来说一般。赛后总结一下，前期打得不错，队友手速A掉两道水题。之后，就。。。这次开的题其实挺多的，但可惜很多都没做出来。想D题，一开始思路跑了。。。E题，莫名其妙写挂了。。。G题，debug了2小时，最后我们仨盯着电脑看了半个小时找出来了。。。I题，窝想出了个O（n^2...
18029100040吴程锴-第四次上机作业1
08-08
18029100040吴程锴-第四次上机作业1
吴程锴18029100040第4次上机作业1
08-08
吴程锴18029100040第4次上机作业1
大连理工大学——编译技术-第四次上机-语法分析
12-01
目的：熟练掌握自上而下的语法分析方法，并能用程序实现。 要求： 1. 使用的文法如下： E TE E + TE | T FT T * FT | F (E) | id 2. 对于任意给定的输入串（词法记号流）进行语法分析，递归下降方法...
计算机表演赛noc竞赛,【转载】NoC大赛教师竞赛项目介绍
weixin_34648437的博客
07-26 992
四、教师竞赛项目教学实践评优评选目标：遵循教育部提出的信息技术要“走进课堂、服务教学、面向学生”的方针，在现代教育观的指导下，提高教师将信息技术应用于课堂教学的能力，把课程改革的理念转化为教师课堂教学的行为，为教师搭建一个展示才华和相互交流的平台，以竞赛推进信息技术在教育教学中的应用。参赛对象：在中小学从事教学工作的教师。参赛范围：教育部规定的小学(幼教)、初中和普通高中学段所有年级的所有学科。参...
第八次练习赛标程
the CodeRoom of wjfwzzc
06-23 1529
最后一次练习赛，我们竭尽所能地考察
第一次练习赛解题报告及标程
the CodeRoom of wjfwzzc
03-15 1421
因为实际的课程还没有开始讲，这次的练习赛着重于对上学期C++知识的复习，以及对数据结构课程内容的一些铺垫。主要考查了结构体、指针、预处理等相关知识。以下为简单的题解和标程。 　　A. Page Turn 　　签到题，改编自Pages, Codeforces Round #233 (Div. 2) A，太水了不多讲。看下标程可以写得多简洁就好。 //by wjfwzzc #include #
第四次练习赛解题报告及标程
the CodeRoom of wjfwzzc
04-19 1359
第四次练习赛本来想有点长
第五次练习赛解题报告及标程
the CodeRoom of wjfwzzc
05-10 1357
因为五一的缘故，也因为进
期末上机赛解题报告及标程
the CodeRoom of wjfwzzc
06-15 1212
期末上机的意义毋庸置疑，但最终的
buaa数据结构第四次上机
最新发布
04-24
很抱歉，我无法提供关于具体学校或课程的第四次上机内容。但是，我可以为您提供一些关于数据结构的基本知识和常见的上机题目类型。 数据结构是计算机科学中非常重要的一门课程，它研究如何组织和存储数据以及如何有效地操作和管理数据。第四次上机可能涉及以下内容之一： 1. 树和图的应用：树和图是常见的数据结构，可以用于解决各种实际问题，比如搜索、排序、最短路径等。在上机中，您可能需要实现树或图的基本操作，如插入、删除、遍历等。 2. 排序算法：排序是数据结构中的一个重要问题，常见的排序算法有冒泡排序、插入排序、选择排序、快速排序、归并排序等。您可能需要实现其中一个排序算法，并对给定的数据进行排序。 3. 查找算法：查找是另一个常见的问题，常见的查找算法有线性查找、二分查找、哈希查找等。您可能需要实现其中一个查找算法，并根据给定的条件查找特定的数据。 4. 动态规划：动态规划是一种解决最优化问题的方法，它将问题分解为子问题，并通过保存子问题的解来避免重复计算。您可能需要使用动态规划来解决给定的问题，并实现相应的算法。 以上只是一些可能的内容，具体的上机要求可能会根据课程教学大纲和教师的要求而有所不同。如果您有具体的问题或需要更详细的帮助，请提供更多信息，我将尽力回答您的问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值