程序设计思维与实践 Week2 实验

yyyyyyyyo

于 2020-03-06 15:06:57 发布

阅读量217

点赞数

本文链接：https://blog.csdn.net/yyyyyyyyo/article/details/104689517

版权

文章目录

A 化学

1.题目大意

化学很神奇，以下是烷烃基。在这里插入图片描述
假设如上图，这个烷烃基有6个原子和5个化学键，6个原子分别标号1~6，然后用一对数字 a,b 表示原子a和原子b间有一个化学键，这样通过5行a,b可以描述一个烷烃基。

你的任务是甄别烷烃基的类别。

输入：
输入第一行为数据的组数T（1≤T≤200000）。每组数据有5行，每行是两个整数a, b(1≤a,b≤6,a≤b)
数据保证，输入的烷烃基是以上5种之一

输出：
每组数据，输出一行，代表烷烃基的英文名

样例：

n-hexane
3-methylpentane

2.解题思路

这道题主要考虑烷羟基的表示方式，并且找到不同烷羟基区别特征。
烷羟基结构可以用图来表示，顶点表示原子，边表示化学键
判断烷羟基类型可以转化为判断点的邻接边数量。
烷羟基中原子编号无序，因此判断时需考虑邻接边条数分别为1～4的点的个数，不能考虑指定编号的点邻接边条数。
观察可得每种烷羟基的区分方法：

n-hexane没有邻接边条数大于2的顶点
2,3-dimethylbutane有2个邻接边条数等于3的顶点
2,2-dimethylbutane有1个邻接边条数等于4的顶点
3-methylpentane有1个邻接边条数等于3的顶点，该顶点的邻接点中只有1个邻接边条数等于2的顶点
2-methylpentane也有1个邻接边条数等于3的顶点，而该顶点的邻接点中有2个邻接边条数等于2的顶点

3.代码

#include <iostream>
using namespace std;

struct chainNode
{
    int element;
    chainNode *next;
    
    chainNode() {}
    chainNode(const int& element) {this->element=element;}
    chainNode(const int& element, chainNode *next) {this->element=element; this->next=next;}
};

class graphChain
{
protected:
    chainNode* firstNode;
    int listSize;
    
public:
    graphChain() {firstNode=NULL; listSize=0;}
    ~graphChain()
    {
        while (firstNode!=NULL)
        {
            chainNode* nextNode=firstNode->next;
            delete firstNode;
            firstNode=nextNode;
        }
    }
    int size() const {return listSize;}
    chainNode* first() const {return firstNode;}
    void insert(const int& theElement)
    {
        chainNode *p=firstNode, *tp=NULL;
        while (p!=NULL)
        {
            tp=p;
            p=p->next;
        }
        chainNode *newNode=new chainNode(theElement,p);
        if (tp==NULL) firstNode=newNode;
        else tp->next=newNode;
        
        listSize++;
    }
};

class linkedGraph
{
private:
    int n;
    int e;
    graphChain *aList;
    
public:
    linkedGraph(int ver=0)
    {
        n=ver;
        e=0;
        aList=new graphChain[n+1];
    }
    ~linkedGraph() {delete [] aList;}
    
    void insertEdge(int u, int v)
    {
        aList[u].insert(v);
        aList[v].insert(u);
        e++;
    }
    
    void judge()
    {
        int *a=new int[n];
        for (int i=1;i<=n;i++)
            a[i]=0;
        for (int i=1;i<=n;i++)
            a[aList[i].size()]++;
        
        if (a[4])
            cout<<"2,2-dimethylbutane"<<endl;
        else if (a[3]==2)
            cout<<"2,3-dimethylbutane"<<endl;
        else if (!a[3])
            cout<<"n-hexane"<<endl;
        else if (a[3]==1)
        {
            int count=0;
            for (int i=1;i<=n;i++)
            {
                if (aList[i].size()==3)
                {
                    for (chainNode *w=aList[i].first();w!=NULL;w=w->next)
                        if (aList[w->element].size()==2)
                            count++;
                    
                    if (count==2) cout<<"3-methylpentane"<<endl;
                    else cout<<"2-methylpentane"<<endl;
                }
            }
        }
        
    }
};

int main()
{
    int n,u,v;
    cin>>n;
    for (int i=0;i<n;i++)
    {
        linkedGraph graph(6);
        for (int j=0;j<5;j++)
        {
            cin>>u>>v;
            graph.insertEdge(u,v);
        }
        graph.judge();
    }
    return 0;
}

4.实现细节

利用了数据结构课程中图类的代码，构造链表描述的图，已存在插入边函数insertEdge用于初始化烷羟基。
judge函数判断烷羟基类别。

用a[k]数组记录每个图中邻接边条数为k的顶点个数为a[k]，遍历图的顶点，每次进行a[aList[i].size()]++实现。
再根据解题思路中烷羟基的区别方法进行区别，分类a[4]>0或a[3]==2或a[3]==0或a[3]==1等。
a[3]==1有两种情况，进一步考虑该顶点的邻接点的情况。

B 爆零

1.题目大意

实时评测系统具有及时获得成绩排名的特点，那它的功能是怎么实现的呢？做题过程中，通过的题数虽然越来越多，但通过每题时所共花去的时间（从最开始算起，直至通过题目时的这段时间）都会被记录下来。特别的，对于通过的题目，曾经的关于这题的每次错误提交都会被算上一定的单位时间罚时，这样一来，在做出的题数上可能领先，但是在做出同样题数的人中，可能会因为罚时过高而处于排名上的劣势。
例如某次考试一共八道题（A,B,C,D,E,F,G,H），每个人做的题都在对应的题号下有个数量标记，负数表示该学生在该题上有过的错误提交次数但到现在还没有AC，正数表示AC所耗的时间，如果正数a跟上了一对括号，里面有个正数b,则表示该学生AC了这道题，耗去了时间a，同时曾经错误提交了b次。例子可见下方的样例输入与输出部分。

输入：
输入数据包含多行，第一行是共有的题数n（1≤n≤12）以及单位罚时m（10≤m≤20），之后的每行数据描述一个学生的信息，首先是学生的用户名（不多于10个字符的字串）其次是所有n道题的得分现状，其描述采用问题描述中的数量标记的格式，见上面的表格。

输出：
根据这些学生的得分现状，输出一个实时排名。实时排名显然先按AC题数的多少排，多的在前，再按时间分的多少排，少的在前，如果凑巧前两者都相等，则按名字的字典序排，小的在前。每个学生占一行，输出名字（10个字符宽），做出的题数（2个字符宽，右对齐）和时间分（4个字符宽，右对齐）。名字、题数和时间分相互之间有一个空格。数据保证可按要求的输出格式进行输出。

样例：

8 20
GuGuDong  96     -3    40(3) 0    0    1      -8    0
hrz       107    67    -3    0    0    82     0     0
TT        120(3) 30    10(1) -3   0    47     21(2) -2
OMRailgun 0      -99   -8    0    -666 -10086 0     -9999996
yjq       -2     37(2) 13    -1   0    113(2) 79(1) -1
Zjm       0      0     57(5) 0    0    99(3)  -7    0

TT          5  348
yjq         4  342
GuGuDong    3  197
hrz         3  256
Zjm         2  316
OMRailgun   0    0

2.解题思路

这道题主要考虑准确地进行格式化输入和输出。
先根据输入内容判断学生答题信息：

得分为0，表示该题未提交未通过
得分为-a (a > 0)，表示该题已提交a次都未通过
得分为a (a > 0)，表示该题在a时刻提交一次性通过
得分为a(b) (a > 0 && b > 0)表示该题在a时刻提交通过前错误提交b次未通过

需要操作符重载或定义比较函数，用于根据升降序要求进行多条件排序。

3.代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int MAXN=10000;

struct Competitor
{
    char name[11];
    int score=0;
    int penalty=0;
    
    bool operator < (const Competitor &com) const
    {
        if (score!=com.score) return score>com.score;
        if (penalty!=com.penalty) return penalty<com.penalty;
        return strcmp(name,com.name)<0;
    }
}cpts[MAXN];

int main()
{
    int n,m,res,t,f,i;
    char record[10];
    cin>>n>>m;
    for (i=0;cin>>cpts[i].name;i++)
    {
        for (int j=0;j<n;j++)
        {
            scanf("%s",record);
            res=sscanf(record,"%d(%d)",&t,&f);
            if (res==2)
            {
                cpts[i].score++;
                cpts[i].penalty+=t+f*m;
            }
            else if (res==1 && t>0)
            {
                cpts[i].score++;
                cpts[i].penalty+=t;
            }
        }
    }
    sort(cpts,cpts+i);
    for (int j=0;j<i;j++)
        printf("%-10s %2d %4d\n",cpts[j].name,cpts[j].score,cpts[j].penalty);
    
    return 0;
}

4.实现细节

创建Competitor类用于记录每个学生的答题情况，其中重载操作符 < 用于后续多条件排序。
（此处得知若升序排序则return xxx<a.xxx，符号与重载的符号相同，降序排序则符号相反，终于不再这种小逻辑上纠结了！）
这道题的重点在于如何正确读入并判断每个学生的得分现状，这里用sscanf函数用于格式化读入最合适。

sscanf函数返回值为读入数据的个数，可以判断得分现状是否有()的数据
返回值为2表示通过但非一次性，得分增加，罚时增加时间和错误次数
返回值为1且a<=0表示未通过，不做处理；返回值为1且a>0表示一次性通过，得分增加，罚时仅增加时间

输出时也要注意格式。这里记录一些不熟悉的printf输出格式：

“%-xxx”：以特定宽度左对齐
“%+xxx”：以特定宽度右对齐
“% xxx”：输出值为正显示空格，为负时显示负号
“%#xxx”：对c、s、d、u类无影响；对o类，在输出时加前缀o；对x类，在输出时加前缀0x；对e、g、f 类当结果有小数时才给出小数点

C 瑞神打牌

1.题目大意

牌局由四个人构成，围成一圈。我们称四个方向为北、东、南、西。对应的英文是North，East，South，West。游戏一共由一副扑克，也就是52张构成。开始，我们指定一位发牌员（东南西北中的一个，用英文首字母标识）开始发牌，发牌顺序为顺时针，发牌员第一个不发自己，而是发他的下一个人（顺时针的下一个人）。这样，每个人都会拿到13张牌。
现在我们定义牌的顺序，首先，花色是（梅花）<（方片）<（黑桃）<（红桃），（输入时，我们用C, D, S, H分别表示梅花，方片，黑桃，红桃，即其单词首字母）。对于牌面的值，我们规定2 < 3 < 4 < 5 < 6 < 7 < 8 < 9 < T < J < Q < K < A。
现在你作为上帝，你要从小到大排序每个人手中的牌，并按照给定格式输出。（具体格式见输出描述和样例输出）。

输入：
输入包含多组数据
每组数据的第一行包含一个大写字符，表示发牌员是谁。如果该字符为‘#’则表示输入结束。
接下来有两行，每行有52个字符，表示了26张牌，两行加起来一共52张牌。每张牌都由两个字符组成，第一个字符表示花色，第二个字符表示数值。

输出：
输出多组数据发牌的结果，每组数据之后需要额外多输出一个空行
每组数据应该由24行的组成，输出按照顺时针方向，始终先输出South Player的结果，每位玩家先输出一行即玩家名称（东南西北），接下来五行，第一行和第五行输出固定格式（见样例），第二行和第四行按顺序和格式输出数值（见样例），第三行按顺序和格式输出花色（见样例）。

样例：

N
CTCAH8CJD4C6D9SQC7S5HAD2HJH9CKD3H6D6D7H3HQH4C5DKHKS9
SJDTS3S7S4C4CQHTSAH2D8DJSTSKS2H5D5DQDAH7C9S8C8S6C2C3
#

South player:
+---+---+---+---+---+---+---+---+---+---+---+---+---+
|6 6|A A|6 6|J J|5 5|6 6|7 7|9 9|4 4|5 5|7 7|9 9|T T|
| C | C | D | D | S | S | S | S | H | H | H | H | H |
|6 6|A A|6 6|J J|5 5|6 6|7 7|9 9|4 4|5 5|7 7|9 9|T T|
+---+---+---+---+---+---+---+---+---+---+---+---+---+
West player:
+---+---+---+---+---+---+---+---+---+---+---+---+---+
|2 2|5 5|9 9|K K|5 5|7 7|9 9|4 4|T T|J J|A A|8 8|A A|
| C | C | C | C | D | D | D | S | S | S | S | H | H |
|2 2|5 5|9 9|K K|5 5|7 7|9 9|4 4|T T|J J|A A|8 8|A A|
+---+---+---+---+---+---+---+---+---+---+---+---+---+
North player:
+---+---+---+---+---+---+---+---+---+---+---+---+---+
|3 3|4 4|J J|2 2|3 3|T T|Q Q|K K|8 8|Q Q|K K|2 2|3 3|
| C | C | C | D | D | D | D | D | S | S | S | H | H |
|3 3|4 4|J J|2 2|3 3|T T|Q Q|K K|8 8|Q Q|K K|2 2|3 3|
+---+---+---+---+---+---+---+---+---+---+---+---+---+
East player:
+---+---+---+---+---+---+---+---+---+---+---+---+---+
|7 7|8 8|T T|Q Q|4 4|8 8|A A|2 2|3 3|6 6|J J|Q Q|K K|
| C | C | C | C | D | D | D | S | S | H | H | H | H |
|7 7|8 8|T T|Q Q|4 4|8 8|A A|2 2|3 3|6 6|J J|Q Q|K K|
+---+---+---+---+---+---+---+---+---+---+---+---+---+

2.解题思路

这道题主要考虑把输入的牌发给每位玩家，并且比较牌的大小。
先根据发牌员的位置和发牌顺序（顺时针）确定每个玩家手中的牌：

将四个位置S, W, N, E以顺时针为升序表示为数字，则可以通过下标取模运算，每隔4张牌将牌发到相同的玩家
由于发牌员先给自己的下一个玩家发牌，因此表示四个位置的数字从1开始升序而非从0开始（这样从i=0开始遍历发牌时下标不用+1）

需要操作符重载或定义比较函数，用于根据规定进行牌的排序。
这里的排序涉及到数字和字母的混合排序，因此把字母转化为对应大小的数字会更加方便

3.代码

#include <iostream>
#include <string.h>
#include <algorithm>
#include <vector>
using namespace std;

char input[10000];
int banker;

struct Card
{
    char col,num;
    Card();
    Card(int theCol,int theNum)
    {
        col=theCol;
        num=theNum;
    }
};

vector<Card> player[4];

int getCol(char col)
{
    switch (col)
    {
        case 'C': return 0;
        case 'D': return 1;
        case 'S': return 2;
        case 'H': return 3;
    }
    return -1;
}

int getNum(char num)
{
    switch (num)
    {
        case 'T': return 10;
        case 'J': return 11;
        case 'Q': return 12;
        case 'K': return 13;
        case 'A': return 14;
    }
    return num-'0';
}

bool cmp(const Card &card1,const Card& card2)
{
    if (card1.col==card2.col)
        return getNum(card1.num)<getNum(card2.num);
    return getCol(card1.col)<getCol(card2.col);
}

int main()
{
    while (scanf("%s",input) && input[0]!='#')
    {
        switch (input[0])
        {
            case 'S': banker=1; break;
            case 'W': banker=2; break;
            case 'N': banker=3; break;
            case 'E': banker=0; break;
        }
        for (int i=0;i<4;i++)
            player[i].clear();
        scanf("%s%s",input,input+52);
        for (int i=0;i<104;i+=2,banker=(banker+1)%4)
            player[banker].push_back(Card(input[i],input[i+1]));
        
        for (int i=0;i<4;i++)
            sort(player[i].begin(),player[i].end(),cmp);
        
        for (int i=0;i<4;i++)
        {
            switch (i)
            {
                case 0: cout<<"South player:"<<endl; break;
                case 1: cout<<"West player:"<<endl; break;
                case 2: cout<<"North player:"<<endl; break;
                case 3: cout<<"East player:"<<endl; break;
            }
            cout<<"+---+---+---+---+---+---+---+---+---+---+---+---+---+"<<endl;
            int j;
            for (j=0;j<13;j++)
            {
                cout<<"|"<<player[i][j].num<<" "<<player[i][j].num;
                if (j==12) cout<<"|"<<endl;
            }
            for (j=0;j<13;j++)
            {
                cout<<"| "<<player[i][j].col<<" ";
                if (j==12) cout<<"|"<<endl;
            }
            for (j=0;j<13;j++)
            {
                cout<<"|"<<player[i][j].num<<" "<<player[i][j].num;
                if (j==12) cout<<"|"<<endl;
            }
            cout<<"+---+---+---+---+---+---+---+---+---+---+---+---+---+"<<endl;
        }
        cout<<endl;
    }
    return 0;
}

4.实现细节

创建Card类用于记录每张牌的花色和大小，4个Card型向量分别表示四个玩家的牌。
先读入所有牌的信息，读入时注意scanf需要分为两部分input/input+52，防止读入中间的换行。
遍历上一步读入的数据进行发牌：

由于花色和大小占用两个字符，以及根据解题思路中的下标取模运算，因此每个循环 i += 2 且 banker = (banker+1) % 4 为步长
player[banker].push_back(Card(input[i],input[i+1]))发牌

getCol和getNum函数分别为花色的字符和数字转换以及大小的字符和数字转换函数，在比较函数cmp里调用，用于排序输出。
（原来的思路是将字符串转化成数字后再输入Card，用结构体里操作符重载进行排序，就不需要cmp函数了，但是实现后发现这样在输出的时候还要重新转化成字符串，比较不方便）
按照格式输出时注意行首和行末的空格与中间位置不同。

yyyyyyyyo

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
程序设计思维与实践 Week2 实验

一、实验A 化学1.题目大意化学很神奇，以下是烷烃基。假设如上图，这个烷烃基有6个原子和5个化学键，6个原子分别标号1~6，然后用一对数字 a,b 表示原子a和原子b间有一个化学键，这样通过5行a,b可以描述一个烷烃基。你的任务是甄别烷烃基的类别。输入：输入第一行为数据的组数T（1≤T≤200000）。每组数据有5行，每行是两个整数a, b(1≤a,b≤6,a≤b)数据保证，输入的...
复制链接

扫一扫