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

实验A-化学

化学很神奇，以下是烷烃基。

假设如上图，这个烷烃基有6个原子和5个化学键，6个原子分别标号1~6，然后用一对数字 a,b 表示原子a和原子b间有一个化学键。这样通过5行a,b可以描述一个烷烃基
你的任务是甄别烷烃基的类别。
原子没有编号方法，比如
1 2
2 3
3 4
4 5
5 6
和
1 3
2 3
2 4
4 5
5 6
是同一种，本质上就是一条链，编号其实是没有关系的，可以在纸上画画就懂了

Input

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

output

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

Example

Input

2
1 2
2 3
3 4
4 5
5 6
1 4
2 3
3 4
4 5
5 6

Output

n-hexane
3-methylpentane

思路：

在记录输入的图结构时，采用了邻接链表的结构，邻接链表的数组中记录了节点的度，而且又用了一个数组，记录图结构中不同度的个数。
当度数为1的点有2个，度数为2的点有4个时，是n-hexane
当度数为1的点有4个，度数为3的点有2个时，是2,3-dimethylbutane
当度数为1的点有4个，度数为2的点有1个，度数为3的点有1个时，是2,2-dimethylbutane
当度数为1的点有3个，度数为2的点有2个，度数为3的点有1个时，需要再判断一下，计算与度数为3的节点相邻的节点的度数之和，
和为4时，是2-methylpentane
和为5时，是3-methylpentane

更好的思路：

创建一个二维数组，来表示不同度数的点的连接情况，比如:link [ i ][ j ] =k 表示度数为i的节点与度数为j的节点之间有k条边，每个图形都有不同的连接方式，可以区分不同图形。

vector<int> G[7];
int deg[7][7];
for(int i=1;i<=5;i++){
	int u,v;scanf("%d %d",&u,&v);
	G[u].push_back(v);
	G[v].push_back(u);
}
for(int i=0;i<=6;i++)
	for(auto &x:G[i])
		deg[G[i].size()][G[x].size()]++;

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

struct node{
    int number=0;
    node* next=nullptr;
    node():number(0),next(nullptr){};
    node(int _number,node* _next):number(_number),next(_next){};
};

class ting{
public:
    node str[7];
    int degree[5];
    ting(){
        memset(degree,0,5*sizeof(int));
        for(int i=0;i<5;i++){
            int temp1=0,temp2=0;
            scanf("%d %d", &temp1, &temp2);
            node* tempNode1 = new node(temp1, str[temp2].next);
            node* tempNode2 = new node(temp2, str[temp1].next);
            str[temp1].next = tempNode2;
            str[temp1].number++;
            str[temp2].next = tempNode1;
            str[temp2].number++;
        }
    }
    ~ting(){
        for(auto & i : str){
            node* temp=i.next;
            while(temp){
                node* delNode=temp;
                temp=temp->next;
                delete delNode;
            }
        }
    }
    void calDegree(){
        for(int i=1;i<=6;i++){
            degree[str[i].number]++;
        }
    }
    void show() {
        for(int i=0;i<7;i++){
            node* tempNode=str[i].next;
            cout<<i<<"  "<<str[i].number<<ends;
            while(tempNode){
                cout<<tempNode->number<<ends;
                tempNode=tempNode->next;
            }
            cout<<endl;
        }
        cout<<"degree: ";
        for(int i=1;i<5;i++){
            cout<<degree[i]<<ends;
        }
        cout<<endl;
    }
};

int main(){
    int n=0;
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        ting s;
        s.calDegree();
//        s.show();

        if(s.degree[1]==2 && s.degree[2]==4)
            printf("n-hexane\n");
        else if(s.degree[1]==4 && s.degree[3]==2)
            printf("2,3-dimethylbutane\n");
        else if(s.degree[1]==4 && s.degree[2]==1 && s.degree[4]==1)
            printf("2,2-dimethylbutane\n");
        else if(s.degree[1]==3 && s.degree[2]==2 && s.degree[3]==1){
            int pos=0;
            int total=0;
            for(int i=1;i<=6;i++){
                if(s.str[i].number==3){
                    pos=i;
                    break;
                }
            }
            node* nextNode=s.str[pos].next;
            while(nextNode){
                int temp=nextNode->number;
                total+=s.str[temp].number;
//                total+=nextNode->number;
                nextNode=nextNode->next;
            }
//            cout<<"pos:"<<pos<<endl;
//            cout<<"total:"<<total<<endl;
            if(total==4)
                printf("2-methylpentane\n");
            else if(total==5)
                printf("3-methylpentane\n");
        }
    }
    return 0; 
}

实验B-爆零(×)大力出奇迹(√)

程序设计思维作业和实验使用的实时评测系统，具有及时获得成绩排名的特点，那它的功能是怎么实现的呢？
我们千辛万苦怼完了不忍直视的程序并提交以后，评测系统要么返回AC，要么是返回各种其他的错误，不论是怎样的错法，它总会给你记上一笔，表明你曾经在这儿被坑过，而当你历经千辛终将它AC之后，它便会和你算笔总账,表明这题共错误提交了几次。
在岁月的长河中，你通过的题数虽然越来越多，但通过每题时你所共花去的时间（从最开始算起，直至通过题目时的这段时间）都会被记录下来，作为你曾经奋斗的痕迹。特别的，对于你通过的题目，你曾经的关于这题的每次错误提交都会被算上一定的单位时间罚时，这样一来，你在做出的题数上，可能领先别人很多，但是在做出同样题数的人中，你可能会因为罚时过高而处于排名上的劣势。
例如某次考试一共八道题（A,B,C,D,E,F,G,H），每个人做的题都在对应的题号下有个数量标记，负数表示该学生在该题上有过的错误提交次数但到现在还没有AC，正数表示AC所耗的时间，如果正数a跟上了一对括号，里面有个正数b,则表示该学生AC了这道题，耗去了时间a，同时曾经错误提交了b次。例子可见下方的样例输入与输出部分。

Input

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

Output

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

Sample Input

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

Sample Output

思路：
使用结构体存储学生的相关信息，并结构体中重载小于号（sort中用到)，题目的关键在于对字符串的读取和处理上，需要将字符串模拟读入。

更好的思路：

sscanf的作用：从一个字符串中读进于指定格式相符的数据。利用它可以从字符串中取出整数、浮点数和字符串。

scanf("%s",s);
if(sscanf(s,"%d(%d)",&x,&y)==1)
	acNumer += (x>0),time += x>0?x:0;
else
	acNumber++,time += x+y*m;

sscanf更多用法

代码：

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

struct Student{
    char name[10];
    int acNumber=0;
    int time=0;
    Student(){
        memset(name,0,10*sizeof(char));
    }
    bool operator < (const Student &stu) const{
        if(acNumber != stu.acNumber)
            return acNumber > stu.acNumber;
        if(time != stu.time)
            return time < stu.time;
        int cmp = strcmp(name,stu.name);
        return cmp<=0;

    }

    void show(){
        cout<<"name: ";
        for(int i=0;i<strlen(name);i++)
            cout<<name[i];
        cout<<endl;
        cout<<"acNumber: "<<acNumber<<endl;
        cout<<"time: "<<time<<endl;
        cout<<endl;
    }
    void print(){
        printf("%-10s ",name);
        printf("%2d ",acNumber);
        printf("%4d",time);

    }
};

int getTime(char str[],int m){
	//给定成绩字符串，返回用时 
    int number1=0,number2=0;
    int mode=1;
    for(int i=0;i<strlen(str);i++){
//        cout<<str[i]<<endl;
        if(str[i]>='0' && str[i]<='9'){
            if(mode==1){
                number1=number1*10;
                number1+=str[i]-'0';
//                cout<<number1<<endl;
                continue;
            }
            else if(mode==2){
            	number2=number2*10;
				number2+=str[i]-'0'; 
                continue;
            }
        }
        else if(str[i]=='(')
            mode=2;
        else if(str[i]==')')
            break;
    }
    return number1+number2*m;
}

int main(){
//    freopen("ccccccccccc.txt","w",stdout);
    int n,m;
    scanf("%d %d",&n,&m);
    char name[10];
    vector<Student> s;
    while(scanf("%s",name)!=EOF){

        Student stu;
        for(int i=0;i<strlen(name);i++) {
            stu.name[i]=name[i];
        }
        for(int i=0;i<n;i++){
            char str[10];
            scanf("%s",str);
            if(str[0]=='-' || str[0]=='0') {
                continue;
            }
            else{
                stu.acNumber++;
                stu.time+=getTime(str,m);
            }
        }
        s.push_back(stu);
//        stu.show();cout<<endl;
    }
    sort(s.begin(),s.end());
    for(int i=0;i<s.size()-1;i++){
        s[i].print();
        printf("\n") ;
    }
    s[s.size()-1].print();
    printf("\n");
    
	return 0;
}

实验C-瑞神打牌 （不支持C++11；G++和C++编译器都试试！）

瑞神HRZ因为疫情在家闲得无聊，同时他又非常厉害，所有的课对他来说都是水一水就能拿A+，所以他无聊，找来了另外三个人：咕咕东，腾神以及zjm来打牌（天下苦瑞神久矣）。
显然，牌局由四个人构成，围成一圈。我们称四个方向为北 东 南 西。对应的英文是North，East，South，West。游戏一共由一副扑克，也就是52张构成。开始，我们指定一位发牌员（东南西北中的一个，用英文首字母标识）开始发牌，发牌顺序为顺时针，发牌员第一个不发自己，而是发他的下一个人（顺时针的下一个人）。这样，每个人都会拿到13张牌。
现在我们定义牌的顺序，首先，花色是（梅花）<（方片）<（黑桃）<（红桃），（输入时，我们用C,D,S,H分别表示梅花，方片，黑桃，红桃，即其单词首字母）。对于牌面的值，我们规定2 < 3 < 4 < 5 < 6 < 7 < 8 < 9 < T < J < Q < K < A。
现在你作为上帝，你要从小到大排序每个人手中的牌，并按照给定格式输出。（具体格式见输出描述和样例输出）。

Input

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

Output

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

Sample Input

N
CTCAH8CJD4C6D9SQC7S5HAD2HJH9CKD3H6D6D7H3HQH4C5DKHKS9
SJDTS3S7S4C4CQHTSAH2D8DJSTSKS2H5D5DQDAH7C9S8C8S6C2C3

Sample Output

思路：

避免过多的使用if else结构，使用二维数组存储每个人的牌，使用sort函数对二维数组中的每个第一维进行排序（需要在结构体中重载小于号，重定义比较规则）
同时需要注意printf的格式输出

更好的思路：

可以将牌面的值，方向，花色等使用键值对存储，用到了map,注意map列表初始化适用于C++11及以上的版本
map的详细用法

代码：

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

char valOrder[]="23456789TJQKA";
char picOrder[]="CDSH";
char posOrder[]="SWNE";
char player[4][15]={"South player:","West player:","North player:","East player:"};

int getOrder(char cha,char *str){
    for(int i=0;i<strlen(str);i++){
        if(cha == str[i])
            return i;
    }
    return -1;
}

struct card{
    char value;//牌面的值 
    char pic;//花色
    card():value(0),pic(0){};
    void show(){
        printf("%c%c ",pic,value);
    }
    bool operator < (card car) {
        if(pic != car.pic)
            return getOrder(pic,picOrder) < getOrder(car.pic,picOrder);
        if(value != car.value)
            return getOrder(value, valOrder) < getOrder(car.value, valOrder);
    }
};

int main(){
    char pos;
    scanf("%c",&pos);
    while(pos != '#'){
//    	freopen("cccccccc.txt","w",stdout);
        int position = getOrder(pos,posOrder);

        card cards[4][13];
        int indexList[]={0,0,0,0};
        for(int i=0;i<4;i++){
        	for(int j=0;j<13;j++){
				cards[i][j].pic=0; 
				cards[i][j].value=0;
			}	
		}
        for(int i=0;i<26;i++){
            if(i==0) getchar();
            int index=(position+i+1)%4;
            scanf("%c %c", &cards[index][indexList[index]].pic, &cards[index][indexList[index]].value);
            indexList[index]++;
        }
        for(int i=26;i<52;i++){
            if(i==26) getchar();
            int index=(position+i+1)%4;
            scanf("%c %c", &cards[index][indexList[index]].pic, &cards[index][indexList[index]].value);
            indexList[index]++;
        }

        for(int i=0;i<4;i++){
            sort(&cards[i][0],&cards[i][13]);
//            printf("%c: ",posOrder[i]);

            for(int j=0;j<strlen(player[i]);j++)
                printf("%c",player[i][j]);
            printf("\n");
            printf("+---+---+---+---+---+---+---+---+---+---+---+---+---+\n");
            for(int j=0;j<13;j++){
                printf("|");
                printf("%c %c",cards[i][j].value,cards[i][j].value );
            }
            printf("|\n");
            for(int j=0;j<13;j++){
                printf("| ");
                printf("%c ",cards[i][j].pic);
            }
            printf("|\n");
            for(int j=0;j<13;j++){
                printf("|");
                printf("%c %c",cards[i][j].value,cards[i][j].value);
            }
            printf("|\n");
            printf("+---+---+---+---+---+---+---+---+---+---+---+---+---+\n");

        }
        printf("\n");
        getchar();
        scanf("%c",&pos);
    }
//    cout<<"out"<<endl;

    return 0;
}

作业A-Maze

东东有一张地图，想通过地图找到妹纸。地图显示，0表示可以走，1表示不可以走，左上角是入口，右下角是妹纸，这两个位置保证为0。既然已经知道了地图，那么东东找到妹纸就不难了，请你编一个程序，写出东东找到妹纸的最短路线。

Input

输入是一个5 × 5的二维数组，仅由0、1两数字组成，表示法阵地图。

Output

输出若干行，表示从左上角到右下角的最短路径依次经过的坐标，格式如样例所示。数据保证有唯一解。

Sample Input

0 1 0 0 0
0 1 0 1 0
0 1 0 1 0
0 0 0 1 0
0 1 0 1 0

Sample Output

(0, 0)
(1, 0)
(2, 0)
(3, 0)
(3, 1)
(3, 2)
(2, 2)
(1, 2)
(0, 2)
(0, 3)
(0, 4)
(1, 4)
(2, 4)
(3, 4)
(4, 4)

Hint

坐标(x, y)表示第x行第y列，行、列的编号从0开始，且以左上角为原点。
　　另外注意，输出中分隔坐标的逗号后面应当有一个空格。

思路：

基本思路为从原点BFS，使用并查集（或栈）记录路径。
在BFS时，进行上下左右四个方向的拓展，需要判断合法（遇到屏障，已到过，走出迷宫为非法），合法则加入队列，最后再并查集中通过终点找到路径。

代码：

#include <iostream>
#include <stdio.h>
#include <queue>
#include <stack>
using namespace std;

int str[5][5];//0未到，1屏障，-1已到过
int route[25];//并查集
stack<int> t;

int getPos(int m,int n){return 5*m+n;}
int judge(int m,int n){
    return m>=0 && m<5 && n>=0 && n<5 && str[m][n]==0;
}
int getRoute(){
    int x=4,y=4;
    while(x || y){
        int temp=route[getPos(x,y)];
        t.push(temp);
//        cout<<temp<<"  ";
        x=temp/5;
        y=temp%5;
//        printf("(%d %d)\n",x,y);
    }
}

int main(){
    for(int i=0;i<5;i++){
        for(int j=0;j<5;j++)
            str[i][j]=0;
    }
    for(int i=0;i<25;i++){
        route[i]=0;
    }
    for(int i=0;i<5;i++){
        for(int j=0;j<5;j++)
            scanf("%d",&str[i][j]);
    }

    queue<int> s;

    s.push(getPos(0,0));
    str[0][0]=-1;
//    cout<<s.size()<<endl;
    while(s.size()!=0){
        int temp=s.front();
        s.pop();
        int x,y;
        x=temp/5;
        y=temp%5;

        if(judge(x-1,y)){
            s.push(getPos(x-1,y));
            str[x-1][y]=-1;
            route[getPos(x-1,y)]=temp;
            if(getPos(x-1,y)==24)   break;
        }
        if(judge(x+1,y)){
            s.push(getPos(x+1,y));
            str[x+1][y]=-1;
            route[getPos(x+1,y)]=temp;
            if(getPos(x-1,y)==24)   break;
        }
        if(judge(x,y-1)){
            s.push(getPos(x,y-1));
            str[x][y-1]=-1;
            route[getPos(x,y-1)]=temp;
            if(getPos(x-1,y)==24)   break;
        }
        if(judge(x,y+1)){
            s.push(getPos(x,y+1));
            str[x][y+1]=-1;
            route[getPos(x,y+1)]=temp;
            if(getPos(x-1,y)==24)   break;
        }
    }
    getRoute();
//    cout<<t.empty()<<endl;
    while(!t.empty()){
        int temp=t.top();
        t.pop();
        printf("(%d, %d)\n",temp/5,temp%5);
    }
    printf("(4, 4)");
    return 0;
}

B-Pour Water

倒水问题 “fill A” 表示倒满A杯，"empty A"表示倒空A杯，“pour A B” 表示把A的水倒到B杯并且把B杯倒满或A倒空。

Input

输入包含多组数据。每组数据输入 A, B, C 数据范围 0 < A <= B 、C <= B <=1000 、A和B互质。

Output

你的程序的输出将由一系列的指令组成。这些输出行将导致任何一个罐子正好包含C单位的水。每组数据的最后一行输出应该是“success”。输出行从第1列开始，不应该有空行或任何尾随空格。

Sample Input

2 7 5
2 7 4

Sample Output

fill B
pour B A
success
fill A
pour A B
fill A
pour A B
success

Notes

如果你的输出与Sample Output不同，那没关系。对于某个"A B C"本题的答案是多解的，不能通过标准的文本对比来判定你程序的正确与否。 所以本题由 SPJ（Special Judge）程序来判定你写的代码是否正确。

思路：

相互倒水可以看作是一个二元组状态的变化，而二元组的状态又可以转化为二维坐标中的情况，每一个状态转移相当于二维坐标中点的移动，因此，该问题可以看作是从（0，0）到（0，C）或（C，0）的一条路径，随之想到应该从（0，0）开始bfs，到（C，0）或（0，C）为止，这样找到的会是一条最短路径。
为了避免重复访问节点，可以增加一个二维数组，记录节点的到达情况，相当于对BFS进行剪枝，减少了无效的访问。

代码：

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

char state[6][15]={"empty A","fill A","empty B","fill B","pour A B","pour B A"};
const int mmax=1000;
bool reached[mmax][mmax];
struct Pair{
    int x,y;
    Pair():x(0),y(0){};
    Pair(int theX,int theY):x(theX),y(theY){};
};
struct node{
    Pair thePair;//坐标
    int last;//父节点
    int level;//层次
    char str[15];//state
    node(int _x,int _y,int _last,int _level,char *_str){
        thePair.x=_x;
        thePair.y=_y;
        last=_last;
        level=_level;
        strcpy(str,_str);
    }
    node(Pair& _thePair,int _last,int _level,char *_str){
        thePair.x=_thePair.x;
        thePair.y=_thePair.y;
        last=_last;
        level=_level;
        strcpy(str,_str);
    }
    node():thePair(0,0),last(-1),level(0){memset(str,0,15*sizeof(char));};
    void show(){
        cout<<"x:"<<thePair.x<<",y:"<<thePair.y;
        cout<<"  last:"<<last<<"   ";
        cout<<"  level:"<<level<<" ";
        for(int i=0;i<strlen(str);i++)
            cout<<str[i];
        printf("\n");
    }
    void operator = (const node& theNode) {
        thePair.x=theNode.thePair.x;
        thePair.y=theNode.thePair.y;
        last=theNode.last;
        level=theNode.level;
        strcpy(str,theNode.str);
    }
};



int main(){
    int a,b,c;
    while(scanf("%d %d %d",&a,&b,&c)!=EOF){
        for(int i=0;i<mmax;i++){
            memset(reached[i],false,mmax*sizeof(bool));
        }
        int head=0,tail=0;
        vector<node> s;
        node temp;
        s.push_back(temp);
        tail++;
        reached[0][0]=true;

        while(head!=tail){
            node t=s[head];

            if(t.thePair.x==c || t.thePair.y==c){
//                for(int j=0;j<s.size();j++)
//                    s[j].show();

                stack<int> index;
                index.push(head);
                while(t.last!=0){
                    index.push(t.last);
                    t=s[t.last];
                }

                while(index.size()!=0){
//                    printf("%d  ",index.top());
                    printf("%s\n",s[index.top()].str);
                    index.pop();
                }
                printf("success\n");
                break;
            }

            int newx=0,newy=t.thePair.y;
            if(!reached[newx][newy]){

                node newNode(newx,newy,head,t.level+1,state[0]);
                s.push_back(newNode);
                tail++;reached[newx][newy]=true;
            }

            newx=a,newy=t.thePair.y;
            if(!reached[newx][newy]){
                node newNode(newx,newy,head,t.level+1,state[1]);
                s.push_back(newNode);
                tail++;reached[newx][newy]=true;
            }

            newx=t.thePair.x,newy=0;
            if(!reached[newx][newy]){
                node newNode(newx,newy,head,t.level+1,state[2]);
                s.push_back(newNode);
                tail++;reached[newx][newy]=true;
            }

            newx=t.thePair.x,newy=b;
            if(!reached[newx][newy]){
                node newNode(newx,newy,head,t.level+1,state[3]);
                s.push_back(newNode);
                tail++;reached[newx][newy]=true;
            }

            if(t.thePair.x+t.thePair.y <= b){newx=0;newy=t.thePair.x+t.thePair.y;}
            else{newx=t.thePair.x+t.thePair.y-b;newy=b;}
            if(!reached[newx][newy]){
                node newNode(newx,newy,head,t.level+1,state[4]);
                s.push_back(newNode);
                tail++;reached[newx][newy]=true;
            }

            if(t.thePair.x+t.thePair.y <= a){newx=t.thePair.x+t.thePair.y;newy=0;}
            else{newx=a;newy=t.thePair.x+t.thePair.y-a;}
            if(!reached[newx][newy]){
                node newNode(newx,newy,head,t.level+1,state[5]);
                s.push_back(newNode);
                tail++;reached[newx][newy]=true;
            }

            head++;
        }



    }
}