第三次练习赛解题报告及标程

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

　　渣诚拖了好久的解题报告，于是我还是自行解决吧……

　　A. Arthur的收藏夹
　　B. Chem is A Brand New Try!
　　E. RPS GAMES

　　三道上机原题，没啥讲的，见上机题解。

　　C. 链表的中间节点

　　陈题，题干里Hint的提示足够简洁明了，唯一要注意的是分割字符串的方法，下面的标程给出了两种方式（手动分割，以及strtok函数）；还有，其实没必要把字符转化成数字。

#include<cstdio>
#include<cstdlib>
#include<cstring>
using namespace std;
struct LinkList
{
    char data[5];
    LinkList *next;
};
char str[1005];
void CreateList(LinkList *&L)
{
    LinkList *s,*r;
    L=(LinkList *)malloc(sizeof(LinkList));
    r=L;
    int f=0,l=strlen(str);
    for(int i=0; i<l; ++i)
        if(str[i+1]==' '||i==l-1)
        {
            ++i;
            s=(LinkList *)malloc(sizeof(LinkList));
            for(int j=0; j<i-f; j++)
                s->data[j]=str[j+f];
            s->data[i-f]='\0';
            r->next=s;
            r=s;
            f=i+1;
        }
    r->next=NULL;
}
void MiddleOfList(LinkList *&L)
{
    LinkList *p1=L->next,*p2=L->next;
    while(p2->next!=NULL)
    {
        p2=p2->next->next;
        p1=p1->next;
    }
    printf("%s\n",p1->data);
}
void DestroyList(LinkList *&L)
{
    LinkList *pre=L,*p=L->next;
    while(p)
    {
        free(pre);
        pre=p;
        p=pre->next;
    }
    free(pre);
}
int main()
{
    int t;
    scanf("%d",&t);
    getchar();
    while(t--)
    {
        gets(str);
        LinkList *L;
        CreateList(L);
        MiddleOfList(L);
        DestroyList(L);
    }
}
#include<cstdio>
#include<cstring>
#include<string>
#include<list>
using namespace std;
char str[1005];
list<string> data;
list<string>::iterator it,mid;
int main()
{
    int t;
    scanf("%d",&t);
    getchar();
    while(t--)
    {
        gets(str);
        char *sub=strtok(str," ");
        while(sub)
        {
            data.push_back(sub);
            sub=strtok(NULL," ");
        }
        it=data.begin();
        mid=it++;
        while(it!=data.end())
        {
            advance(it,2);
            ++mid;
        }
        printf("%s\n",(*mid).c_str());
        data.clear();
    }
}

　　D. Who Should I Accompany?(Ⅱ)

　　双向约瑟夫，加点条件罢了，双链表纯模拟。

#include<cstdio>
#include<cstdlib>
using namespace std;
struct DLinkList
{
    int data;
    DLinkList *prior,*next;
};
void CreateList(DLinkList *&L,int n)
{
    DLinkList *s,*r;
    L=(DLinkList *)malloc(sizeof(DLinkList));
    r=L;
    for(int i=1; i<=n; ++i)
    {
        s=(DLinkList *)malloc(sizeof(DLinkList));
        s->data=i;
        r->next=s;
        s->prior=r;
        r=s;
    }
    r->next=L->next;
    L->next->prior=r;
}
void Josephus(DLinkList *&L,int k)
{
    DLinkList *p=L->next->prior,*q;
    int cnt=0;
    while(p->next!=p)
    {
        if(cnt&1)
        {
            for(int i=1; i<k+cnt; ++i)
                p=p->prior;
            q=p->prior;
            p->prior=q->prior;
            q->prior->next=p;
            p=p->prior;
        }
        else
        {
            for(int i=1; i<k+cnt; ++i)
                p=p->next;
            q=p->next;
            p->next=q->next;
            q->next->prior=p;
            p=p->next;
        }
        free(q);
        ++cnt;
    }
    printf("%d\n",p->data);
    free(p);
    free(L);
}
int main()
{
    int n,k;
    while(~scanf("%d%d",&n,&k))
    {
        DLinkList *L;
        CreateList(L,n);
        Josephus(L,k);
    }
}
#include<cstdio>
#include<list>
using namespace std;
list<int> data;
list<int>::iterator p,q;
int main()
{
    int n,k;
    while(~scanf("%d%d",&n,&k))
    {
        for(int i=1; i<=n; ++i)
            data.push_back(i);
        p=data.begin();
        int cnt=0;
        while(cnt!=n-1)
        {
            if(cnt&1)
            {
                for(int i=1; i<k+cnt; ++i)
                {
                    if(p==data.begin())
                        p=data.end();
                    --p;
                }
                q=p++;
                if(p==data.end())
                    p=data.begin();
            }
            else
            {
                for(int i=1; i<k+cnt; ++i)
                {
                    ++p;
                    if(p==data.end())
                        p=data.begin();
                }
                q=p;
                if(p==data.begin())
                    p=data.end();
                --p;
            }
            data.erase(q);
            ++cnt;
        }
        printf("%d\n",*p);
        data.clear();
    }
}

　　F. 大富翁

　　这道题不太好搞，边界处理有点恶心。双链表不用说了，我的做法是先往一边数B+C次，然后再往回数C次，这样可以回避一部分边界情况。

#include<cstdio>
#include<cstdlib>
using namespace std;
struct DLinkList
{
    int data;
    DLinkList *prior,*next;
};
void CreateList(DLinkList *&L,int n)
{
    DLinkList *s,*r;
    L=(DLinkList *)malloc(sizeof(DLinkList));
    r=L;
    for(int i=1; i<=n; i++)
    {
        s=(DLinkList *)malloc(sizeof(DLinkList));
        s->data=i;
        r->next=s;
        s->prior=r;
        r=s;
    }
    r->next=NULL;
}
void DestroyList(DLinkList *&L)
{
    DLinkList *pre=L,*p=L->next;
    while(p!=NULL)
    {
        free(pre);
        pre=p;
        p=pre->next;
    }
    free(pre);
}
int main()
{
    int t,n,m;
    scanf("%d",&t);
    while(t--)
    {
        DLinkList *L,*p,*q;
        scanf("%d%d",&n,&m);
        CreateList(L,n);
        p=L->next;
        while(m--)
        {
            int a,b,c;
            scanf("%d",&a);
            if(a!=0)
            {
                scanf("%d%d",&b,&c);
                if(a==1)
                {
                    for(int i=0; i<b+c; ++i)
                    {
                        if(p->next==NULL)
                            break;
                        p=p->next;
                    }
                    for(int i=0; i<c; ++i)
                    {
                        if(p==L)
                        {
                            p=p->next;
                            break;
                        }
                        p->prior->next=p->next;
                        if(p->next!=NULL)
                            p->next->prior=p->prior;
                        q=p;
                        p=p->prior;
                        free(q);
                    }
                }
                else if(a==-1)
                {
                    for(int i=0; i<b+c; ++i)
                    {
                        if(p->prior==L)
                            break;
                        p=p->prior;
                    }
                    for(int i=0; i<c; ++i)
                    {
                        if(p==NULL)
                        {
                            p=L;
                            while(p->next!=NULL)
                                p=p->next;
                            break;
                        }
                        p->prior->next=p->next;
                        if(p->next!=NULL)
                            p->next->prior=p->prior;
                        q=p;
                        p=p->next;
                        free(q);
                    }
                }
            }
        }
        p=L->next;
        while(p!=NULL)
        {
            printf("%d ",p->data);
            p=p->next;
        }
        putchar('\n');
        DestroyList(L);
    }
}
#include<cstdio>
#include<list>
using namespace std;
list<int> data;
list<int>::iterator p,q;
int main()
{
    int t,n,m;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        for(int i=0; i<=n; ++i)
            data.push_back(i);
        p=data.begin();
        ++p;
        while(m--)
        {
            int a,b,c;
            scanf("%d",&a);
            if(a==0)
                continue;
            scanf("%d%d",&b,&c);
            switch(a)
            {
            case 1:
                for(int i=0; i<b+c; ++i)
                {
                    ++p;
                    if(p==data.end())
                    {
                        --p;
                        break;
                    }
                }
                for(int i=0; i<c; ++i)
                {
                    if(p==data.begin())
                    {
                        ++p;
                        break;
                    }
                    q=p;
                    --p;
                    data.erase(q);
                }
                break;
            case -1:
                for(int i=0; i<b+c; ++i)
                {
                    --p;
                    if(p==data.begin())
                    {
                        ++p;
                        break;
                    }
                }
                for(int i=0; i<c; ++i)
                {
                    if(p==data.end())
                    {
                        --p;
                        break;
                    }
                    q=p;
                    ++p;
                    data.erase(q);
                }
                break;
            }
        }
        for(p=data.begin(),++p; p!=data.end(); ++p)
            printf("%d ",*p);
        putchar('\n');
        data.clear();
    }
}

　　G. Thor's Play

　　栈的纯模拟，无坑点，不说了。

#include<cstdio>
using namespace std;
const int MAXN=10005;
int stack[MAXN],size;
int main()
{
    int n,m,k;
    char str[10];
    while(~scanf("%d%d",&n,&m))
    {
        size=0;
        while(m--)
        {
            scanf("%s",str);
            bool flag=true;
            switch(str[0])
            {
            case 'P':
                scanf("%d",&k);
                if(size==n)
                    flag=false;
                else
                    stack[++size]=k;
                break;
            case 'R':
                if(size==0)
                    flag=false;
                else
                    --size;
                break;
            case 'G':
                scanf("%d",&k);
                while(size>0&&stack[size]!=k)
                    --size;
                if(size==0)
                    flag=false;
                else
                    --size;
                break;
            }
            puts(flag?"SUCCEED":"ERROR");
        }
        for(int i=size; i>=1; --i)
            printf("%d ",stack[i]);
        putchar('\n');
    }
}
#include<cstdio>
#include<stack>
using namespace std;
stack<int> s;
int main()
{
    int n,m,k;
    char str[10];
    while(~scanf("%d%d",&n,&m))
    {
        while(m--)
        {
            scanf("%s",str);
            bool flag=true;
            switch(str[0])
            {
            case 'P':
                scanf("%d",&k);
                if(s.size()==n)
                    flag=false;
                else
                    s.push(k);
                break;
            case 'R':
                if(s.empty())
                    flag=false;
                else
                    s.pop();
                break;
            case 'G':
                scanf("%d",&k);
                while(!s.empty()&&s.top()!=k)
                    s.pop();
                if(s.empty())
                    flag=false;
                else
                    s.pop();
                break;
            }
            puts(flag?"SUCCEED":"ERROR");
        }
        while(!s.empty())
        {
            printf("%d ",s.top());
            s.pop();
        }
        putchar('\n');
    }
}

　　H. 优雅的XML

　　SZM大神出的题，我在13年成都现场赛上做过一道很相似的题（HDU4782），当时没搞出来。主要是要考虑到一切情况，边界条件众多，小心使得万里船。我的代码很难看。

#include<cstdio>
using namespace std;
int main()
{
    int len=0,cnt=0;
    char buf[4096];
    while((buf[len]=getchar())!=EOF)
        ++len;
    for(int i=0; i<len; ++i)
    {
        if(buf[i]==' '||buf[i]=='\n'||buf[i]=='\t')
            continue;
        if(buf[i]=='<')
        {
            int j=i+1;
            while(buf[j]==' '||buf[j]=='\n'||buf[j]=='\t')
                ++j;
            if(buf[j]=='/')
                --cnt;
            for(int k=0; k<cnt; ++k)
                putchar('\t');
            if(buf[j]!='/')
                ++cnt;
            putchar(buf[i++]);
            int quo=0;
            while(buf[i]==' '||buf[i]=='\n'||buf[i]=='\t')
                ++i;
            if(buf[i]=='/')
            {
                putchar(buf[i++]);
                while(buf[i]==' '||buf[i]=='\n'||buf[i]=='\t')
                    ++i;
            }
            while(buf[i]!='>'&&buf[i]!=' '&&buf[i]!='\n'&&buf[i]!='\t')
                putchar(buf[i++]);
            while(buf[i]==' '||buf[i]=='\n'||buf[i]=='\t')
                ++i;
            if(buf[i]!='>')
            {
                putchar(' ');
                for(; buf[i]!='>'; ++i)
                {
                    if(!(quo&1)&&(buf[i]==' '||buf[i]=='\n'||buf[i]=='\t'))
                        continue;
                    putchar(buf[i]);
                    if(buf[i]=='\"'&&buf[i-1]!='\\')
                    {
                        ++quo;
                        if(!(quo&1))
                        {
                            ++i;
                            while(buf[i]==' '||buf[i]=='\n'||buf[i]=='\t')
                                ++i;
                            if(buf[i]=='>')
                                break;
                            --i;
                            putchar(' ');
                        }
                    }
                }
            }
            putchar(buf[i]);
            j=i-1;
            while(buf[j]==' '||buf[j]=='\n'||buf[j]=='\t')
                --j;
            if(buf[j]=='/')
                --cnt;
            putchar('\n');
        }
    }
}

　　送一组数据，能过这一组应该就没问题了。输入为：

< html xmlns="http://www.w3school.com.cn">< head 
>	< link href="/static/css/oj3rd.css"  rel = "stylesheet" type="text/css" / >
< / head > < body > < div id  =  "header  " class="clearfix" >		<a href= "/problem/group/85/create/" >
							</a>
< / div >
</body></ html>

　　输出效果为：

<html xmlns="http://www.w3school.com.cn">
	<head>
		<link href="/static/css/oj3rd.css" rel="stylesheet" type="text/css" />
	</head>
	<body>
		<div id="header  " class="clearfix">
			<a href="/problem/group/85/create/">
			</a>
		</div>
	</body>
</html>

　　解题报告真的不好写也懒得写……看看标程应该也能懂的吧。

wjfwzzc
关注
专栏目录
15级算法第三次上机解题报告
modricwang的博客
10-30 1749
A Nintendo Switch生产车间 解题思路： 一眼看上去以为是流水线问题，其实不然，切换流水线不需要时间，因此对于每个工序，只要找到消耗时间最短的一条流水线去完成即可。使用线性查找或第k大数求最小值的时间复杂度都是线性的，因此总的时间复杂度为O(mn)，空间复杂度为O(mn). 代码： #include #include using namespace std;
第七次练习赛解题报告及标程
the CodeRoom of wjfwzzc
06-11 1293
这次的题目难度不夸张的可以说是历次上机和练习的难度之最
第五次练习赛解题报告及标程
the CodeRoom of wjfwzzc
05-10 1378
因为五一的缘故，也因为进
第一次练习赛解题报告及标程
the CodeRoom of wjfwzzc
03-15 1468
因为实际的课程还没有开始讲，这次的练习赛着重于对上学期C++知识的复习，以及对数据结构课程内容的一些铺垫。主要考查了结构体、指针、预处理等相关知识。以下为简单的题解和标程。 　　A. Page Turn 　　签到题，改编自Pages, Codeforces Round #233 (Div. 2) A，太水了不多讲。看下标程可以写得多简洁就好。 //by wjfwzzc #include #
第六次练习赛解题报告及标程
the CodeRoom of wjfwzzc
05-29 1099
渣诚拖了好久的解题报告，于是我还是自行解决吧…… 　　A. Who Are My Friends?(Ⅰ) 　　B. Chem is A Brand New Try! 　　E. RPS GAMES 　　三道上机原题，没啥讲的，见上机题解。 　　C. 链表的中间节点 　　陈题，题干里Hint的提示足够简洁明了，唯一要注意的是分割字符串的方法，下面的标程给出了两种方式（手动分割，以及strt
第四次练习赛解题报告及标程
the CodeRoom of wjfwzzc
04-19 1380
第四次练习赛本来想有点长
第一次上机赛解题报告及标程
the CodeRoom of wjfwzzc
03-25 1546
目前我和渣诚基本确定了这样的分工，那就是他来写书上代码构造成的标程，我来写用STL或者其他方法实现的标程。说实话，作为一个渣渣ACMer，这种感觉挺好…… 　　言归正传。第一次上机成绩非常惨烈，一方面我和渣诚在题目顺序的安排上出了点问题，把最基础的链表操作题目放在了最后，题干最吓人（注意不是最难的）放在了第一道。经过被关导叫去喝茶以及与老师的沟通之后，以后的上机会尽量精简题干，数据量的要求也会降
HPUACM2014级第三周练习赛解题报告
_阿阿阿阿欢
03-27 3111
1001：HDU1072 ACboy needs your help again! 解题思路：最基本的栈和队列的问题，用数组模拟即可 #include #include int main (){ int t,i; scanf("%d",&t); while(t--){ int n,x; char str[10];
第八次练习赛标程
the CodeRoom of wjfwzzc
06-23 1610
最后一次练习赛，我们竭尽所能地考察
2017acm湖南多校赛第一场标程与数据
03-21
标题“2017acm湖南多校赛第一场标程与数据”指的是2017年ACM（国际大学生程序设计竞赛）湖南地区多所高校联合举行的第一场比赛的官方标准程序（标程）和相关数据集。这些资源通常被参赛者用来理解和练习比赛中的编程...
hdoj 2013 多校训练2标程+解题报告
08-05
“hdoj 2013 多校训练2标程+解题报告”这个标题指的是2013年举行的一场由hdoj（HDU Online Judge，即杭州电子科技大学在线评测系统）组织的多校联合编程训练活动的第二阶段。其中，“标程”是指官方提供的正确解答...
期末上机赛解题报告及标程
the CodeRoom of wjfwzzc
06-15 1255
期末上机的意义毋庸置疑，但最终的
第二次上机赛解题报告及标程
the CodeRoom of wjfwzzc
04-11 1161
此次上机，起码从board上看要比第一次好了许多……虽然距离理想状态还是差了一些……
第五次上机赛解题报告及标程
the CodeRoom of wjfwzzc
06-04 1152
这次上机的题目，难度上稍有增加。
第四次上机赛标程
the CodeRoom of wjfwzzc
05-23 1129
这次渣诚来写解题报告，我只放我的标程；大量。
第二次练习赛标程
the CodeRoom of wjfwzzc
03-23 1076
鉴于渣诚已经发布了第二次练习赛解题报告，所以我只打算留下自己验题时的标程，其中大量应用了STL，某些也没按照题意来做，看下就好。 　　A. SubMatrix×× #include #include const int MAXN=505; long long sum[MAXN][MAXN]; using namespace std; int main() { int m,n,k,c1,
第三次上机赛标程
the CodeRoom of wjfwzzc
04-22 1053
渣诚解题报告在此，我只放标程不说话。
医院后台管理系统-医院后台管理系统-医院后台管理系统-医院后台管理系统-医院后台管理系统-医院后台管理系统-医院后台管理系统-医
最新发布
09-26
医院后台管理系统-医院后台管理系统-医院后台管理系统-医院后台管理系统-医院后台管理系统-医院后台管理系统-医院后台管理系统-医院后台管理系统-医院后台管理系统-医院后台管理系统-医院后台管理系统-医院后台管理系统 1、资源说明：医院后台管理系统源码，本资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 2、适用人群：计算机相关专业(如计算计、信息安全、大数据、人工智能、通信、物联网、自动化、电子信息等)在校学生、专业老师或者企业员工等学习者，作为参考资料，进行参考学习使用。 3、资源用途：本资源具有较高的学习借鉴价值，可以作为“参考资料”，注意不是“定制需求”，代码只能作为学习参考，不能完全复制照搬。需要有一定的基础，能够看懂代码，能够自行调试代码，能够自行添加功能修改代码。 4. 最新计算机软件毕业设计选题大全(文章底部有博主联系方式): https://blog.csdn.net/2301_79206800/article/details/135931154 技术栈、环境、工具、软件： ① 系统环境:Windows ② 开发语言：Java ③ 框架：SpringBo
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值