山东科技大学2020年5月21日实验题解

最新推荐文章于 2021-08-06 09:11:05 发布
最新推荐文章于 2021-08-06 09:11:05 发布
阅读量1k 收藏 1
点赞数
分类专栏： 大学实验题解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1351937368/article/details/106267717
版权

山东科技大学2020年5月21日实验题解

第一题： 新奇的加法运算

Description

定义类newInt，包括：

  1. int类型的数据成员。

  2. 重载运算符“+”。计算规则为：将A、B对应位置上的数字相加，只保留个位数作为结果的对应位置上的数字。比如：876 + 543 = 319。注意：该运算不改变两个操作数的值。

  3. 重载输入和输出运算符，用于输入和输出对象的属性值。

  4. 无参构造函数和带参构造函数。

Input

第1行N>0，表示测试用例数量。

每个测试用例包括2个非负整数，用空格隔开。

Output

见样例。

Sample Input

4
876 543
999 9999
9 1999
199 88

Sample Output

876 + 543 = 319
999 + 9999 = 9888
9 + 1999 = 1998
199 + 88 = 177

题目给定代码

int main()
{
    int cases;
    newInt a, b, c;
    cin>>cases;
    for (int i = 0; i < cases; i++)
    {
        cin>>a>>b;
        c = a + b;
        cout<<a<<" + "<<b<<" = "<<c<<endl;
    }
    return 0;
}

标程

#include<map>
#include<list>
#include<cmath>
#include<queue>
#include<stack>
#include<cstdio>
#include<vector>
#include<iomanip>
#include<iterator>
#include<iostream>
#include<algorithm>
#define R register
#define LL long long
#define pi 3.141
#define INF 1400000000
using namespace std;

class newInt {
private:
    int i;
public:
    newInt operator + (newInt& n) {
        int x = i;
        int y = n.i;
        int s = 0;
        if (x >= y) {
            int a = x, l = 1, mode = 1;
            a /= 10;
            while (a) {
                a /= 10, ++ l;
            }
            for (R int j = 0; j < l; ++j) {
                s += ((x % 10 + y % 10) % 10) * mode, mode *= 10, x /= 10, y /= 10;
            }
        }
        else {
            int a = y, l = 1, mode = 1;
            a /= 10;
            while (a) {
                a /= 10, ++l;
            }
            for (R int j = 0; j < l; ++j) {
                s += ((x % 10 + y % 10) % 10) * mode, mode *= 10, x /= 10, y /= 10;
            }
        }
        return newInt(s);
    }
    friend istream& operator >> (istream& is, newInt& n) {
        is >> n.i;
        return is;
    }
    friend ostream& operator << (ostream & os, const newInt & n) {
        os << n.i;
        return os;
    }
    newInt(int a = 0) {
        i = a;
    }
};

int main()
{
    int cases;
    newInt a, b, c;
    cin >> cases;
    for (int i = 0; i < cases; i++)
    {
        cin >> a >> b;
        c = a + b;
        cout << a << " + " << b << " = " << c << endl;
    }
    return 0;
}

题目二： 重载字符的加减法

Description

定义一个字符类Character，只有一个char类型的数据成员。

重载它的+、-、<<和>>运算符，其中+、-的第二个操作数是int类型的整数n。“+”用于返回以当前字符之后的第n个字符为属性值的对象，“-”用于返回当前字符之前的第n个字符为属性值的对象。如样例所示。

Input

第1行N>0表示测试用例个数。

每个测试用包括1个字符（小写英文字母）和1个int类型的整数。

Output

输出有N行，每行输入对应一行输出，每行输出包括对应输入字符之后的第n个字符，以及该字符之前的第n个字符。如样例中第2个用例输入字符是“a”，整数是“1”，那么“a”之后的第1个字符是”b“，"a"之前的第1个字符是”z“；注意：输入的整数可能是负数。

Sample Input

3
a 0
a 1
a -1

Sample Output

a a
b z
z b

题目给定代码

int main()
{
    int cases, data;
    Character ch;
    cin>>cases;
    for (int i = 0; i < cases; i++)
    {
        cin>>ch;
        cin>>data;
        cout<<(ch + data)<<" "<<(ch - data)<<endl;
    }
}

标程

#include<map>
#include<list>
#include<cmath>
#include<queue>
#include<stack>
#include<cstdio>
#include<vector>
#include<iomanip>
#include<cstring>
#include<iterator>
#include<iostream>
#include<algorithm>
#define R register
#define LL long long
#define pi 3.141
#define INF 1400000000
using namespace std;

class Character {
private:
    char c;
public:
    Character(char ch = '\0') {
        c = ch;
    }
    friend char operator + (Character ch, int n) {
        n %= 26, ch.c += n;
        if (ch.c > 'z') {
            ch.c -= 26;
        }
        else if (ch.c < 'a') {
            ch.c += 26;
        }
        return ch.c;
    }
    friend char operator - (Character ch, int n) {
        n %= 26, ch.c -= n;
        if (ch.c < 'a') {
            ch.c += 26;
        }
        else if (ch.c > 'z') {
            ch.c -= 26;
        }
        return ch.c;
    }
    friend istream& operator >> (istream& is, Character& ch) {
        is >> ch.c;
        return is;
    }
    friend ostream& operator << (ostream& os, Character& ch) {
        os << ch.c;
        return os;
    }
};

int main()
{
    int cases, data;
    Character ch;
    cin >> cases;
    for (int i = 0; i < cases; i++)
    {
        cin >> ch;
        cin >> data;
        cout << (ch + data) << " " << (ch - data) << endl;
    }
}

题目三： 成绩排序

Description

定义Student类：

  1. 数据成员string name和int score表示一个学生的姓名、成绩。

  2. 无参构造函数。

  3. void setStudent(string,int)方法，用于设置一个学生的属性值。

  4. 重载>（大于运算符）。Student类的对象A和B的大小关系，A>B定义为A.score>B.score，或者A.score=B.score但A.name<B.name。

5.重载运算符<<用于输出学生信息：先输出成绩再输出姓名，中间用一个空格隔开。

Input

分多行。第一个M>0表示有M个学生信息。

之后有M行，每一行是一个学生信息。第一部分是学生姓名，第二部分是学生成绩。

Output

输出为M行，按照从大到小的顺序依次输出每个学生的成绩、姓名。假定不存在重名的学生。

Sample Input

5
Tom 98
Jack 97
Mary 98
Sherry 99
Dock 97

Sample Output

99 Sherry
98 Mary
98 Tom
97 Dock
97 Jack

题目给定代码

int main()
{
    int cases;
    string name;
    int score;
    cin>>cases;
    Student students[cases], temp;
    for (int i = 0; i < cases; i++)
    {
       cin>>name>>score;
       students[i].setStudent(name, score);
    }
    for (int i = 0; i < cases; i++)
    {
        for (int j = 0; j < cases - i - 1; j++)
        {
            if (!(students[j] > students[j + 1]))
            {
                temp = students[j];
                students[j] = students[j + 1];
                students[j + 1] = temp;
            }
        }
    }
    for (int i = 0; i < cases; i++)
        cout<<students[i]<<endl;
    return 0;
}

标程

#include<map>
#include<list>
#include<cmath>
#include<queue>
#include<stack>
#include<cstdio>
#include<vector>
#include<iomanip>
#include<cstring>
#include<iterator>
#include<iostream>
#include<algorithm>
#define R register
#define LL long long
#define pi 3.141
#define INF 1400000000
using namespace std;

class Student {
private:
    string name;
    int score;
public:
    Student() {
        name = "", score = 0;
    }
    void setStudent(string s, int number) {
        name = s, score = number;
    }
    int operator > (Student& a) {
        if (score > a.score) {
            return 1;
        }
        else if (score == a.score) {
            if (name < a.name) {
                return 1;
            }
        }
        return 0;
    }
    friend ostream& operator << (ostream& os, const Student& S) {
        os << S.score << " " << S.name;
        return os;
    }
};

int main()
{
    int cases;
    string name;
    int score;
    cin >> cases;
    Student students[cases], temp;
    for (int i = 0; i < cases; i++)
    {
        cin >> name >> score;
        students[i].setStudent(name, score);
    }
    for (int i = 0; i < cases; i++)
    {
        for (int j = 0; j < cases - i - 1; j++)
        {
            if (!(students[j] > students[j + 1]))
            {
                temp = students[j];
                students[j] = students[j + 1];
                students[j + 1] = temp;
            }
        }
    }
    for (int i = 0; i < cases; i++)
        cout << students[i] << endl;
    return 0;
}

题目四： 整型数组运算符重载

Description

定义Array类：

1.拥有数据成员int length和int *mems，分别是数组中元素的个数和元素列表。

  1. 无参构造函数，将mems设置为NULL，length为0。

  2. 重载==运算符，用于判断两个Array对象是否相等。相等包括两种情况：（1）两个对象是同一个对象，即它们拥有相同的地址（记住： this指针指向当前对象，是当前对象的地址）；（2）两个对象的length相同，且mems中对应元素的值相同。其他情况均为不相等。

  3. 利用友元函数重载<<和>>运算符。输入、输出格式见下。

Input

输入分多行。

第一行是一个正整数M，表示有M个数组。

每个数组是一行，其中第一个非负整数N表示该数组的元素个数，之后有N个整数。

Output

输出有M行。

第一行输出即为第一个数组。

自第二行开始，首先输出对应的数组元素（两两之间用空格隔开，首尾不能有空格），如果数组为空，则不输出元素。之后根据这个数组与上个数组是否相同，输出“unequal to above.”（不相等）和“equal to above”（相等）。

Sample Input

5
3 1 2 3
3 1 2 3
0
7 1 2 3 4 5 6 7
7 1 2 3 4 5 6 8

Sample Output

1 2 3
1 2 3 equal to above.
unequal to above.
1 2 3 4 5 6 7 unequal to above.
1 2 3 4 5 6 8 unequal to above.

题目给定代码

int main()
{
    int cases;
    cin>>cases;
    Array arraies[cases];
    for (int i = 0; i < cases; i++)
    {
        cin>>arraies[i];
    }
    cout<<arraies[0]<<endl;
    for (int i = 1; i < cases; i++)
    {
        if (arraies[i] == arraies[i - 1])
        {
            cout<<arraies[i]<<" "<<"equal to above."<<endl;
        }
        else
        {
            cout<<arraies[i]<<" "<<"unequal to above."<<endl;
        }
    }
    return 0;
}

标程

#include<map>
#include<list>
#include<cmath>
#include<queue>
#include<stack>
#include<cstdio>
#include<vector>
#include<iomanip>
#include<cstring>
#include<iterator>
#include<iostream>
#include<algorithm>
#define R register
#define LL long long
#define pi 3.141
#define INF 1400000000
using namespace std;

class Array {
private:
    int length, * mems;
public:
    Array() {
        length = 0, mems = NULL;
    }
    bool operator == (Array& a) {
    	R int i;
        for (i = 0; i < length; ++i) {
            if (mems[i] != a.mems[i]) {
				break;
            }
        }
        if (this == &a) {
            return 1;
        }
        else if (a.length == length && length == i) {
            return 1;
        }
        else {
            return 0;
        }
    }
    friend ostream& operator << (ostream& os, Array& a) {
        for (R int i = 0; i < a.length; ++i) {
            if (i != a.length - 1) {
                os << a.mems[i] << " ";
            }
            else {
                os << a.mems[i];
            }
        }
        return os;
    }
    friend istream& operator >> (istream& is, Array& a) {
        is >> a.length;
        a.mems = new int[a.length];
        for (R int i = 0; i < a.length; ++i) {
            is >> a.mems[i];
        }
        return is;
    }
    ~Array() {
        if (mems != NULL) {
            delete[]mems;
        }
    }
};

int main()
{
    int cases;
    cin >> cases;
    Array arraies[cases];
    for (int i = 0; i < cases; i++)
    {
        cin >> arraies[i];
    }
    cout << arraies[0] << endl;
    for (int i = 1; i < cases; i++)
    {
        if (arraies[i] == arraies[i - 1])
        {
            cout << arraies[i] << " " << "equal to above." << endl;
        }
        else
        {
            cout << arraies[i] << " " << "unequal to above." << endl;
        }
    }
    return 0;
}

题目五： 时间类的流插入、提取和递增、递减运算

Description

封装一个时间类Time，在类上重载以下运算符，使得main()函数能够正确运行。
流插入操作符“>>”，按照输入格式从标准输入读取三个整数：hh,mm,ss，分别表示时、分、秒，其值在int范围内。
流提取操作符“<<”；按照“hh:mm:ss”输出Time类的对象，不合法的时间输出“error!!!”。
前置自增运算符“++”：把时间对象的秒数加1并返回。
前置自减运算符“–”：把时间对象的秒数减1并返回。
后置自增运算符“++”：把时间对象的秒数加1，返回原值。
后置自减运算符“–”：把时间对象的秒数减1，返回原值。
以上4个自增、自减仅对合法的时间操作，并且不会产生不合法的时间。比如：
若原时间对象为“00:00:00”，自减运算后的对象为“23:59:59”;
若原时间对象为“23:59:59”，自增运算后的对象为“00:00:00”;
若原时间对象为“24:60:60”，自增或自减运算后对象仍为“24:60:60”。
函数调用格式见append.cc。
append.cc中已给出main()函数

Input

输入的第一个整数n，表示有n组测试数据，每组3个整数：hh,mm,ss，分别表示时、分、秒，其值都在int范围内。

Output

输出一张表：每列8个字符宽，两列之间有一个空格。
首先，输出一个表头：“++t --t t t-- t++ t ”，
其次，对应每组测试数据在一行内依次以下内容：
前置++、前置–、原值、后置–、后置++、原值。
若输入的日期合法，输出格式为“hh:mm:ss”，不足两位的输出需要前面补0。如果输入的时间不合法，则输出“error!!!”。格式见sample。

Sample Input

6
0 0 1
0 59 59
1 1 60
23 0 0
23 59 59
24 1 0

Sample Output

++t --t t t-- t++ t
00:00:02 00:00:01 00:00:01 00:00:01 00:00:00 00:00:01
01:00:00 00:59:59 00:59:59 00:59:59 00:59:58 00:59:59
error!!! error!!! error!!! error!!! error!!! error!!!
23:00:01 23:00:00 23:00:00 23:00:00 22:59:59 23:00:00
00:00:00 23:59:59 23:59:59 23:59:59 23:59:58 23:59:59
error!!! error!!! error!!! error!!! error!!! error!!!

题目给定代码

int main()
{
    Time t;
    int cases;
    cin>>cases;
    cout<<setw(8)<<left<<"++t"<<" ";
    cout<<setw(8)<<left<<"--t"<<" ";
    cout<<setw(8)<<left<<"t"<<" ";
    cout<<setw(8)<<left<<"t--"<<" ";
    cout<<setw(8)<<left<<"t++"<<" ";
    cout<<setw(8)<<left<<"t"<<right<<endl;
    for(int i = 1; i <= cases; ++i)
    {
        cin>>t;
        cout<<(++t)<<" ";
        cout<<(--t)<<" ";
        cout<<t<<" ";
        cout<<t--<<" ";
        cout<<t++<<" ";
        cout<<t<<endl;
    }
}

标程

#include<map>
#include<list>
#include<cmath>
#include<queue>
#include<stack>
#include<cstdio>
#include<vector>
#include<iomanip>
#include<cstring>
#include<iterator>
#include<iostream>
#include<algorithm>
#define R register
#define LL long long
#define pi 3.141
#define INF 1400000000
using namespace std;

class Time {
private:
    int hour, minute, second;
public:
    Time() {
        hour = 0, minute = 0, second = 0;
    }
    friend ostream& operator << (ostream& os, const Time& T) {
        if ((T.hour >= 0 && T.hour < 24) && (T.minute >= 0 && T.minute < 60) && (T.second >= 0 && T.second < 60)) {
            os << setw(2) << setfill('0') << T.hour << ":" << setw(2) << setfill('0') << T.minute << ":" << setw(2) << setfill('0') << T.second;
        }
        else {
            os << "error!!!";
        }
        return os;
    }
    friend istream& operator >> (istream& is, Time& T) {
        is >> T.hour >> T.minute >> T.second;
        return is;
    }
    Time& operator ++() {
        if ((hour >= 0 && hour < 24) && (minute >= 0 && minute < 60) && (second >= 0 && second < 60)) {
            ++second;
            if (second >= 60) {
                second -= 60, ++minute;
            }
            if (minute >= 60) {
                minute -= 60, ++hour;
            }
            if (hour >= 24) {
                hour -= 24;
            }
        }
        return *this;
    }
    Time operator ++(int) {
        Time q = (*this);
        if ((hour >= 0 && hour < 24) && (minute >= 0 && minute < 60) && (second >= 0 && second < 60)) {
            ++second;
            if (second >= 60) {
                second -= 60, ++minute;
            }
            if (minute >= 60) {
                minute -= 60, ++hour;
            }
            if (hour >= 24) {
                hour -= 24;
            }
        }
        return q;
    }
    Time& operator --() {
        if ((hour >= 0 && hour < 24) && (minute >= 0 && minute < 60) && (second >= 0 && second < 60)) {
            --second;
            if (second < 0) {
                second += 60, --minute;
            }
            if (minute < 0) {
                minute += 60, --hour;
            }
            if (hour < 0) {
                hour += 24;
            }
        }
        return *this;
    }
    Time operator --(int) {
        Time q = (*this);
        if ((hour >= 0 && hour < 24) && (minute >= 0 && minute < 60) && (second >= 0 && second < 60)) {
            --second;
            if (second < 0) {
                second += 60, --minute;
            }
            if (minute < 0) {
                minute += 60, --hour;
            }
            if (hour < 0) {
                hour += 24;
            }
        }
        return q;
    }
};

int main()
{
    Time t;
    int cases;
    cin >> cases;
    cout << setw(8) << left << "++t" << " ";
    cout << setw(8) << left << "--t" << " ";
    cout << setw(8) << left << "t" << " ";
    cout << setw(8) << left << "t--" << " ";
    cout << setw(8) << left << "t++" << " ";
    cout << setw(8) << left << "t" << right << endl;
    for (int i = 1; i <= cases; ++i)
    {
        cin >> t;
        cout << (++t) << " ";
        cout << (--t) << " ";
        cout << t << " ";
        cout << t-- << " ";
        cout << t++ << " ";
        cout << t << endl;
    }
}
Lpy_Now
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
西南科技大学SWUST OJ 数据结构 图相关题题解 图.zip
01-01
SWUST OJ ： 1055、1056、1057、1058、1059、1060、1061、1062、1063、1064、1065、1066、1067、1068、1069、1070、1071、1072、1075、1086题答案
Problem B: 字符类的封装
Rookie_Wang
03-08 315
Problem B: 字符类的封装 Time Limit: 1 Sec  Memory Limit: 128 MB Submit: 866  Solved: 647 [Submit][Status][Web Board] Description 先来个简单习题，练练手吧！现在需要你来编写一个Character类，将char这一基本数据类型进行封装。该类中需要有如下成员函数：
Character类
Gksjn的博客
08-06 521
Character类 开发工具与关键技术：eclipse java 作者：梁峻豪 Character 类是字符数据类型插入的包装类。 Character 类的对象包含类型为char的单个字段，这样能把基本数据类型当对象来处理，其常用方法如。 构造方法:Character (char value) 构造一个新分配的Character 对象,用以表示指定的cahr值。 方法 描述 1、Void Character (char value) 构造一个新分配的Characte 对象，用以表示指定的char值
NYOJ-128前缀式计算
weixin_33743661的博客
08-04 227
  前缀式计算 时间限制：1000 ms  |  内存限制：65535 KB 难度：3   描述 先说明一下什么是中缀式： 如2+(3+4)*5这种我们最常见的式子就是中缀式。 而把中缀式按运算顺序加上括号就是：(2+((3+4)*5)) 然后把运算符写到括号前面就是+(2 *( +(3 4) 5) ) 把括号去掉就是：+ 2 * + 3 4 5 最后这个式子就是该表...
SDUSTOJ Problem D: 时间类的构造和输出
qq_31715489的博客
03-11 1192
仅供交流学习！！！
山东科技大学2020年4月13日题解
a1351937368的博客
04-14 1506
山东科技大学2020年4月13日题解 **题目一：**类的初体验 Description 定义一个类Data，只有一个double类型的属性和如下3个方法： void init(double d);——初始化属性值。 double getValue()——获得属性值。 void showValue()——显示属性值。 Input 一个double类型的数值。 Output 输出输入...
西南科技大学SWUST OJ 线性结构，链表题解答案 线性结构.zip
12-31
SWUST OJ：941、942、943、952、953、954、955、956、957、960、1035、1037、1038、1039、1040、1045、1101、1102、1103题答案
2020中兴捧月算法大赛迪杰斯特拉赛道初赛题解源码
06-27
2020中兴捧月算法大赛迪杰斯特拉赛道初赛题解源码，50个字的限制真的好傻啊
2020年ccpc网络赛的题解群友分享的故免费下载
09-21
提取码：8390 复制这段内容后打开百度网盘手机App，操作更方便哦 群内某大佬分享的，免费下载，如果失效了可以私信我 群内某大佬分享的，免费下载，如果失效了可以私信我 群内某大佬分享的，免费下载，如果失效了...
第十八届西南科技大学ACM程序设计竞赛题解
05-14
西南科技大学第十八届校赛简要题解
求最长字符串与最短字符串
qq_40834200的博客
05-09 1769
/*Description 有n个字符串，找到最长的字符串并输出。 Input 测试数据有多组，第一行的正整数T表示测试数据的组数。每组的第一行给一个正整数n（n≤10），表示该组测试数据中字符串的个数，后跟n行，每行一个字符串（不超过100个字符,中间有可能包含空格）。 Output 对于每组测试数据，输出最长的字符串，每组单独占一行。若有多个字符串都最长，则输出第一个最长的 。 Sample Input 2 3 abc xyz123,.;p m1i2o3 2 abc 1234 Sample Output
简单排序
weixin_30410999的博客
10-01 843
描述 你知道吗，在ACM程序设计竞赛中经常会遇到排序问题，如果你每次都花费大量的时间去编写排序函数，那可不好，因此要好好去练习啦！下面好好练练吧：给定N个整数，请你对这些整数进行升序排列并输出。 输入 输入数据有多组，第一行是测试数据的组数T，接下的T行中，每行表示一组测试数据，每组测试数据的第一个数字为N（1<=N<=1000），接下来是N个整...
浙大复试上机题目解答（1）
liyanguestc的专栏
07-27 3436
今天闲着没事，就把浙大的上机题目整理做了下。。第一题：A + BTime Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 462    Accepted Submission(s): 290Problem Description读入两
浙大复试上机题目解答（3）
liyanguestc的专栏
07-28 1389
题目要求：给定一系列2维平面点的坐标(x, y)，其中x和y均为整数，要求用一个最小的长方形框将所有点框在内。长方形框的边分别平行于x和y坐标轴，点落在边上也算是被框在内。  具体的输入输出格式规定如下： 输入格式：测试输入包含若干测试用例，每个测试用例由一系列坐标组成，每对坐标占一行，其中|x|和|y|小于 231；一对0 坐标标志着一个测试用例的结束。注意(0, 0)不
HDOJ--1263--水果
猩猩是个好程序员的博客
03-12 165
题目描述： 夏天来了，好开心啊,呵呵,好多好多水果~~ Joe经营着一个不大的水果店.他认为生存之道就是经营最受顾客欢迎的水果.现在他想要一份水果销售情况的明细表,这样Joe就可以很容易掌握所有水果的销售情况了. 输入描述: 第一行正整数N(0<N<=10)表示有N组测试数据. 每组测试数据的第一行是一个整数M(0<M<=100),表示工有M次成功的交易.其后有M行数据,每...
NYOJ128 前缀式计算(栈的运用)
机器笨猫
12-21 787
题目信息： http://acm.nyist.net/JudgeOnline/problem.php?pid=128 + 2 * + 3 4 5的值就是 37，详见输入输出。 输入有多组测试数据，每组测试数据占一行，任意两个操作符之间，任意两个操作数之间，操作数与操作符之间都有一个空格。输入的两个操作数可能是小数，数据保证输入的数都是正数，并且都小于10，操作数数目不超过500。 以E
1154: 校门外的树
清风徐来的博客
07-29 1224
Description 某校大门外长度为L 的马路上有一排树，每两棵相邻的树之间的间隔都是1 米。我们可以把马路看成一个数轴，马路的一端在数轴0 的位置，另一端在L 的位置；数轴上的每个整数点，即0，1，2，……，L，都种有一棵树。  由于马路上有一些区域要用来建地铁。这些区域用它们在数轴上的起始点和终止点表示。已知任一区域的起始点和终止点的坐标都是整数，区域之间可能有重合的部分。现在要把
贪心算法小结
女神的博客
08-18 689
局部最优-------> 全局最优 只顾眼前利益 排序，贪心的前提 1.活动安排问题 题目 “今年暑假不AC？” “是的。” “那你干什么呢？” “看世界杯呀，笨蛋！” “@#$%^&*%…” 确实如此，世界杯来了，球迷的节日也来了，估计很多ACMer也会抛开电脑，奔向电视了。 作为球迷，一定想看尽量多的完整的比赛，当然，作为新时代的好青年，你一定还会看一些其它的节目，比如新闻联播...
PAT乙级真题（Python3）
qq_19303727的博客
07-28 1213
A+B和C (15) 题目描述 给定区间[-2的31次方, 2的31次方]内的3个整数A、B和C，请判断A+B是否大于C。 输入描述: 输入第1行给出正整数T(<=10)，是测试用例的个数。随后给出T组测试用例，每组占一行，顺序给出A、B和C。整数间以空格分隔。 输出描述: 对每组测试用例，在一行中输出“Case #X: true”如果A+B>C，否则输出“Cas...
2018年高教社杯全国大学生数学建模竞赛D题解题思路
最新发布
06-06
针对2018年高教社杯全国大学生数学建模竞赛D题，我们可以采取以下步骤进行解题： 1. 确定问题：该题的问题是要求我们设计一种算法，能够在给定的网络拓扑结构下，计算出任意两个节点之间的最短路径长度。 2. 分析问题：该题的难点在于如何处理网络中存在的环路和负权边，这些都会影响到最短路径的计算。因此，我们需要选择一种合适的算法来解决这些问题。常用的算法包括Dijkstra算法、Bellman-Ford算法、Floyd算法等。 3. 确定算法：鉴于本题的网络规模较小，我们可以考虑使用Floyd算法来解决。Floyd算法适用于任意两点之间的最短路径计算，可以同时处理有向图和无向图、带权图和不带权图等多种情况，同时也能够处理负权边和环路。 4. 实现算法：实现Floyd算法的关键是构造一个邻接矩阵，表示网络中各个节点之间的距离。具体实现过程可以参考以下步骤： a. 初始化邻接矩阵：将所有节点之间的距离初始化为正无穷大，将每个节点到自己的距离初始化为0。 b. 利用邻接矩阵进行计算：对于每一对节点i和j，遍历所有节点k，比较节点i到k再到节点j的距离和节点i到节点j的距离，取最小值更新邻接矩阵中的距离值。 c. 输出结果：遍历邻接矩阵，输出任意两个节点之间的最短路径长度。 5. 检验算法：为了验证算法的正确性，可以选择一些节点进行测试，比较计算结果与实际情况是否一致。 综上所述，通过采用Floyd算法，我们可以有效地解决2018年高教社杯全国大学生数学建模竞赛D题中的最短路径问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值