浙大MOOC《数据结构》PTA代码

最新推荐文章于 2022-05-25 21:22:07 发布
最新推荐文章于 2022-05-25 21:22:07 发布
阅读量357 收藏
点赞数 1
分类专栏： 算法 # 浙大MOOC 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51691526/article/details/120130270
版权

第1题-01-复杂度1 最大子列和问题
第2题-01-复杂度2 Maximum Subsequence Sum
第3题-02-线性结构2 一元多项式的乘法与加法运算
第4题-浙大MOOC《数据结构》PTA第4题 Reversing Linked List
第8题-03-树3 Tree Traversals Again
第14题-05-树9 Huffman Codes
3、12、16依然有点小BUG

18、07-图4 哈利·波特的考试（floyd算法）

#include <iostream>
#include <vector>
#include <stack>
#include <math.h>
#include <queue>
#include <algorithm>
#define Infinity 100001
using namespace std;
int N,M;
int main()
{
    cin>>N>>M;
    int D[N+1][N+1];
    int v1,v2,len;
    for(int i=1;i<=N;i++)
    {
        for(int j=1;j<=N;j++)
        {
            D[i][j]=Infinity;
        }
    }
    for(int i=0;i<M;i++)
    {
        cin>>v1>>v2>>len;
        D[v1][v2]=len;
        D[v2][v1]=len;
    }
    int H[N+1][N+1];
    for(int i=1;i<=N;i++)
    {
        for(int j=1;j<=N;j++)
        {
            H[i][j]=D[i][j];
        }
    }
    for(int i=1;i<=N;i++)
    {
        for(int j=1;j<=N;j++)
        {
            if(j==i)continue;
            if(H[i][j]<Infinity)
            {
                for(int k=1;k<=N;k++)
                {
                    if(k==i)continue;
                    if(D[j][k]<Infinity)
                    {
                        H[i][k]=min(H[i][k],H[i][j]+D[j][k]);
                    }
                }
            }
        }
    }
    int m_idx=0;
    int m_num=Infinity;
    for(int i=1;i<=N;i++)
    {
        int tmp_num=0;
        for(int j=1;j<=N;j++)
        {
            if(j==i)continue;
            tmp_num=max(tmp_num,H[i][j]);
        }
        if(m_num>tmp_num)
        {
            m_num=tmp_num;
            m_idx=i;
        }
    }
    cout<<m_idx<<" "<<m_num;
    system("pause");
}

19、07-图5 Saving James Bond - Hard Version（单源无权最短路）

#include <iostream>
#include <vector>
#include <stack>
#include <math.h>
#include <queue>
#include <algorithm>
#define R 15
#define BOUND 50
using namespace std;
struct VNode
{
    int x;
    int y;
    int parent;
    int idx;
    bool visited;
};
bool CanJump(struct VNode v1,struct VNode v2,int d)
{
    return sqrt(pow((v1.x-v2.x),2)+pow((v1.y-v2.y),2))<=d?true:false;
}

int main()
{
    int n,jd;
    cin>>n>>jd;
    vector<struct VNode> vertexs(n,{0,0,-1,false});
    queue<int > q;
    struct VNode start{0,0,-1,0};
    for(int i=0;i<n;i++)
    {
        cin>>vertexs[i].x>>vertexs[i].y;
        vertexs[i].idx=i;
        if(CanJump(start,vertexs[i],jd+15))
        {
            q.push(i);
            vertexs[i].visited=1;
        }
    }
    bool flag=0;
    
    while(!q.empty()&&flag==0)
    {
        start=vertexs[q.front()];
        q.pop();
        for(int i=0;i<n;i++)
        {
            if(vertexs[i].visited)
            {
                continue;
            }
            if(CanJump(start,vertexs[i],jd))
            {
                q.push(i);
                vertexs[i].parent=start.idx;
                vertexs[i].visited=1;
                if(50-abs(vertexs[i].x)<=jd||50-abs(vertexs[i].y)<=jd)
                {
                    flag=1;
                    break;
                }
            }
            
        }
    }
    if(!flag)
    {
        cout<<0;
        system("pause");
        return 0;
    }
    stack<struct VNode> s;
    int idx=q.back();
    while (idx!=-1)
    {
        s.push(vertexs[idx]);
        idx=vertexs[idx].parent;
    }
    if(!s.empty())printf("Yes");
    else printf("No");
    // cout<<s.size()+1<<endl;
    // while(!s.empty())
    // {
    //     cout<<s.top().x<<" "<<s.top().y<<endl;
    //     s.pop();
    // }
    // system("pause");
    return 0;
}

20、07-图6 旅游规划

#include <iostream>
#include <cstdio>
using namespace std;
const INF =0x3f3f3f3f;
int ways[505][505][2];//秒啊，三维数组既存储了任意两城市的长度，又存储了花费
int dist[505],cost[505];//由于程序只接收一次始末点输入，故dist[i]、
//cost[i]表示起点到第i个城市的长度和花销
bool visit[505]={false};//由算法性质知，它只要访问过，即为最短路径
int n,m ,st,ov;
void init_graph() {
	for(int i = 0; i < n; i++) 
		for(int j = 0; j < n; j++)
			ways[i][j][0] = ways[i][j][1] = INF;
}
void init_d_c()
{
    for(int i=0;i<n;i++)
    {
        dist[i]=ways[st][i][0];
        cost[i]=ways[st][i][1];
    }
}

void dijkstra()
{
    visit[st]=true;
    int minpoint=n;
    for(int i1=0;i1<n;i1++)
    {
        if((!visit[i])&&(dist[i]<dist[minpoint]))
        minpoint=i;
    }
    if(minpoint==n)break;
    visit[minpoint]=true;
    for(int i=0;i<n;++i)
    {
        if(!visit[i]&&(dist[i]>dist[minpoint]+ways[minpoint][i][0]))
        {
            dist[i]=dist[minpoint]+ways[minpoint][i][0];
            cost[i]=ways[minpoint][i][1]+cost[minpoint];
        }
        else if(!visit[i]&&(dist[i]==dist[minpoint]+ways[minpoint][i][0])
        &&(cost[i]>cost[minpoint]+ways[minpoint][i][1]))
        cost[i]=(cost[minpoint]+ways[minpoint][i][1]);
    }
}

int main()
{
    cin>>n>>m>>st>>ov;
    int a,b,c,d;
    init_graph();
    for(int i=0;i<m;i++){
        cin>>a>>b>>c>>d;
        ways[a][b][0]=ways[b][a][0]=c;
        ways[a][b][1]=ways[b][a][1]=d;
    }
    init_d_c();
    dist[n]=INF;
    dist[st]=cost[st]=0;
    dijkstra();
    cout<<dist[ov]<<' '<<cost[ov];
    return 0;
}
/*我稀罕赵嘉丽*/

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn = 505;
const int inf  = 0x3f3f3f;
int N,M,S,D,u,v,len,p;
struct Edge {
    int len, pay;
}e[maxn][maxn];
int dist[maxn];
int cost[maxn];
bool vis[maxn];
void init() {
    for(int i = 0; i <= N; ++i) {
        for(int j = 0; j <= N; ++j) {
            e[i][j].pay = e[i][j].len = inf;
        }
        e[i][i].pay = e[i][i].len = 0;
    }
    memset(vis, 0, sizeof(vis));
}
void Dijstra(int u) {
    for(int i = 0; i < N; ++i) {
        dist[i] = e[u][i].len;
        cost[i] = e[u][i].pay;
    }
    for(int i = 1; i <= N; ++i) {
        int t, mindis = inf;
        for(int j = 0; j < N; ++j) {
            if(!vis[j] && dist[j] <= mindis) {
                mindis = dist[j];
                t = j;
            }
        }
        vis[t] = true;
        for(int j = 0; j < N; ++j) {
            if(vis[j] || e[t][j].len == inf) continue;
            if(dist[j] > e[t][j].len + dist[t]) {
                dist[j] = e[t][j].len + dist[t];
                cost[j] = e[t][j].pay + cost[t];
            } else if(dist[j] == e[t][j].len + dist[t]) {
                if(cost[j] > e[t][j].pay + cost[t]) {
                    cost[j] = e[t][j].pay + cost[t];
                }
            }
        }
    }
}
int main(){
    scanf("%d %d %d %d", &N, &M, &S, &D);
    init();
    while(M--) {
        scanf("%d %d %d %d", &u, &v, &len, &p);
        e[u][v].len = e[v][u].len = len;
        e[u][v].pay = e[v][u].pay = p;
    }
    Dijstra(S);
    printf("%d %d\n", dist[D], cost[D]);
    return 0;
}

以上两个版本的代码分别来自大神 来老铁干了这碗代码 和 余cos，刚开始听不懂课（指代码实现困难，但听了至少三遍），按照main函数、main函数中子函数的逻辑顺序敲了一遍，突然明白了。

21、08-图7 公路村村通（邻接矩阵版本）

#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;
const int INF =0x3f3f3f3f;
int ways[1001][1001];
bool visit[1001]={false};
vector<int> m_tree;//存储已经连接的最小树节点
int n,m ,st=2;
void init_graph() {
	for(int i = 0; i <= n; i++) 
		for(int j = 0; j <= n; j++)
        {
            if(i==j)ways[i][j]  = 0;
            else ways[i][j]  = INF;
        }
}

int prim()
{
    m_tree.push_back(st);
    int sum=0;
    bool f=0;
    while(m_tree.size()<n)
    {
        f=0;
        int next=0;
        int min_c=INF;
        for(int i=0;i<m_tree.size();i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(visit[j]==0&& ways[m_tree[i]][j]<min_c)
                {
                    min_c=ways[m_tree[i]][j];
                    next=j;
                    f=1;//当前最小树与其他节点之间有至少一条路
                }
            }
        }
        visit[next]=1;
        m_tree.push_back(next);
        if(f)
            sum+=min_c;
        else
            break;
    }
    if(!f||m_tree.size()<n)
    {
        return -1;
    }
    else
    {
        return sum;
    }
}

int main()
{
    cin>>n>>m;
    int a,b,c;
    init_graph();
    visit[st]=1;
    for(int i=0;i<m;i++){
        cin>>a>>b>>c;
        ways[a][b]=ways[b][a]=c;
    }
    cout<<prim();
    //system("pause");
    //用于测试结果
    return 0;
}

22、08-图8 How Long Does It Take

#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
#define MAX 100
using namespace std;
const int INF =0x3f3f3f3f;
int N,M;
queue<int> q;
bool visited[MAX]={false};
struct PNode
{
    int time;
    vector<vector<int> > prt_time;
    int parents;
}Points[MAX];
int Top_Sort()
{
    int cnt=0;
    struct PNode tmp;
    while(cnt<N)
    {
        
        for(int i=0;i<N;i++)
        {
            if(!visited[i]&&Points[i].parents==0)
            {
                q.push(i);
                visited[i]=1;
            }
        }
        if(q.empty())
        {
            break;
        }
        while(q.size())
        {
            tmp=Points[q.front()];
            q.pop(); 
            cnt++;
            while(tmp.prt_time.size())
            {
                int s=tmp.prt_time.size()-1;
                int a=tmp.prt_time[s][0];
                int b=tmp.prt_time[s][1];
                tmp.prt_time.pop_back();
                Points[a].time=max(tmp.time+b,Points[a].time);
                Points[a].parents--;
            }
        }
    }
    if(cnt==N)
    {
        return tmp.time;
    }
    else
    {
        return -1;
    }
}
int main()
{
    cin>>N>>M;
    int a,b,c;
    int cnt=0;
    int rear=-1;
    
    for(int i=0;i<N;i++)
    {
        Points[i].time=0;
        Points[i].parents=0;
    }
    for(int i=0;i<M;i++)
    {
        cin>>a>>b>>c;
        Points[a].prt_time.push_back({b,c});
        Points[b].parents++;
    }
    
    int ans=Top_Sort();
    if(ans==-1)
    {
        cout<<"Impossible";
    }
    else
    {
        cout<<ans;
    }
    //system("pause");
    return 0;
}

持续更新ing~
如果有小伙伴看完代码后觉得有不明白或不好的地方，可以私信或评论，一起学习。

ㄨㄛˇㄞˋㄋㄧˇ
关注
专栏目录
浙大版数据结构第2版代码.zip
10-28
这里仅提供书里的代码，想学习的建议直接买一本书。这本书还不错的。
数据结构与算法代码（浙大版本陈越、何钦铭老师mooc课程）
qq_46929270的博客
09-09 803
数据结构与算法（浙大版本陈越、何钦铭）
浙大数据结构代码
06-22
浙江大学数据结构课本Weiss DS 代码
浙江大学数据结构和算法课件和源程序
09-05
内容如下: ├─程序例子 │ │ Gauss.cpp │ │ MOVE.C │ │ RUIYUE_3.C │ │ RUIYUE_4.C │ │ │ ├─1概述 │ │ bb_sort.cpp │ │ ex1-9.cpp │ │ ex1-91.cpp │ │ │ ├─2线性表 │ │ ex2-11.cpp │ │ ex2-11new.cpp │ │ linklist.cpp │ │ linklist.h │ │ LINKQUEU.C │ │ linkqueue.cpp │ │ linkqueue.h │ │ list.c │ │ LIST2.C │ │ LIST_S15.C │ │ LIST_SL.C │ │ LIST_SQ.C │ │ LIST_SQ5.C │ │ new2-11.cpp │ │ old2-11.cpp │ │ SQLIST.C │ │ Sqlist.cpp │ │ UNION.CPP │ │ │ ├─3堆栈与队列 │ │ bank_simulation.cpp │ │ conversion.cpp │ │ DMXSTACK.C │ │ hanoi.cpp │ │ MAZE.CPP │ │ QUEUE09.C │ │ SQQUEUE.C │ │ Sqqueue.cpp │ │ sqstack.cpp │ │ stack.c │ │ STK_9.C │ │ 表达式求值.cpp │ │ │ ├─5数组 │ │ array.c │ │ array_ex.cpp │ │ array_test.cpp │ │ DK1.c │ │ DK2.c │ │ SANYANZU.C │ │ │ └─6树 │ bitree.cpp │ BITREE11.C │ bitree2.cpp │ BITREE23.C │ BITREE9.C │ Create_bitree.c │ inorder_thr_tree.cpp │ intreading.cpp │ TING6.C │ TRAVERSE.C │ └─课件 sjjg答疑.txt 数据结构1概述.ppt 数据结构2线性表1.ppt 数据结构3线性表2.ppt 数据结构4堆栈与队列1.ppt 数据结构5堆栈与队列2.ppt 数据结构6串.ppt 数据结构7数组1.ppt 数据结构8数组2.ppt 数据结构9树1.ppt 数据结构A树2.ppt 数据结构B树3.ppt 数据结构C图1.ppt 数据结构D图2.ppt 数据结构E查找.ppt 数据结构F排序.ppt 数据结构文稿14.ppt
浙江大学数据结构
07-22
即使解决一个非常简单的问题，往往也有多种方法，且不同方法之间的效率可能相差甚远 解决问题方法的效率 跟数据的组织方式有关（如例1.1） 跟空间的利用效率有关（如例1.2） 跟算法的巧妙程度有关（如例1.3）
PTA-mooc：PTA（拼题A）-浙江大学中国大学mooc数据结构全AC代码与翻译解析（C语言）
02-05
本资源主要针对浙江大学在中国大学MOOC平台上开设的数据结构课程，提供了完整的PTA（Programming Task Assistant）平台上的题解代码，全部使用C语言编写，并附带了详细的翻译与解析，对于学习数据结构和算法的C语言...
PTA（拼题A）-浙江大学中国大学mooc数据结构全AC代码与题目解析（C语言）.zip
最新发布
06-17
《浙江大学中国大学MOOC数据结构全AC代码与题目解析（C语言）》是针对学习数据结构的同学们的一份宝贵资源，特别适合正在参加PTA（Programming Training Arena，拼题A）平台上的相关课程或者准备相关考试的学生。...
浙江大学数据结构pta
09-15
浙江大学的数据结构PTA涉及了许多不同的题目，这里无法给出具体的题目内容。但是，我可以给你一些建议来准备数据结构PTA考试： 1. 理解基本数据结构：掌握线性表（如数组、链表）、栈、队列、树、图等基本数据结构...
基于PTA平台的“数据结构”课程SPOC翻转课堂教学模式研究.pdf
08-07
PTA（Programming Teaching Assistant，程序设计教学辅助系统）是由浙江大学计算机学院研发的在线教学平台，提供了丰富的编程类练习题库，学生可以在平台上进行编程练习，并通过系统自动批改，同时得到错误原因的...
数据结构之线性表——浙大数据结构公开课代码整理
probie的博客
08-04 262
浙江大学数据结构陈越老师视频课程 线性表代码整理 线性结构头文件 //structList.h #include <iostream> //define maxsize of list #define MAXSIZE 100 //define structure of list typedef struct LNode *List; struct LNode{ doub...
浙江大学数据结构慕课代码Week2
weixin_41617214的博客
03-22 182
多项式的加法和乘法实现 运用链表 1、需要建立空头节点，这样容易建立链表。 typedef struct PolyNode *Polynomial; struct PolyNode { int coef; //系数 int expon; //指数 Polynomial link; //名为link的类型为polyNode的指针 }; int main(){ //定义四个指针变量来...
浙大数据结构
Bei_yue的博客
08-20 263
8.20 1，怎么判断一个算法的时间复杂度 百度： 1，先找出算法中的基本语句（通常是执行次数最多的那条语句） 2，然后计算基本语句的执行次数的数量级。 课上的： 我实在不咋会，看了它有三重循环，那不如就选pow(n,3） 2，最大子列和问题 你首先得会最笨的方法。 ...
数据结构之链表——浙大数据结构公开课代码整理
probie的博客
08-04 384
浙江大学数据结构陈越老师视频课程 链表代码整理 链表结构头文件 //structLinkList.h #include <iostream> typedef struct LNode *List; struct LNode{ double Data; List Next; }; //list length int Length(List PtrL) { ...
浙江大学数据结构（小白专场：程序框架及建树）
weixin_42681308的博客
05-09 179
程序框架搭建 int main() { 对每组数据 读入N和L 根据第一行序列建树T 依据树T分别判别后面的L个序列 是否能与T形成同一搜索树并输出结果 return 0; } 需要设计的主要函数： 读数据建搜索树T 判别一序列是否与T构成一样的搜索树 int main() { int N,L,i; Tree T; sc...
（浙大-19-夏-数据结构学习笔记+代码)图的遍历+深度优先+广度优先（Graph)
计算机科学与技术专业学生的成长之路
08-04 376
深度优先搜索（DFS) void DFS(Vertex v) { visited[ v ] = 1;//先做改变，确认已做 for( v 的每一个邻接点 ） if( !visited [ w ] )//递归他的每一个邻接点，若未做 DFS( w );//递归邻接点 } 若有 N 个顶点，E 条边，时间复杂度是 用邻接表存图，O ( N + E ); 用邻接矩阵存图，O ( N^2...
PTA浙江大学数据结构习题——第一周
ManiacLook的博客
03-11 1534
今年就要找工作了，实习之余开始学习一下数据结构，顺便记录一下，题目是PTA上的浙江大学数据结构题集。 第一周 1.最大子列和问题 res 是要求的最大子列和，cur 是当前子列和。 在序列中从头枚举每个元素： （1）当前子列和大于最大子列和，更新res = cur。 （2）当前子列和为负数，则当前子列和加上后面的数必定不是最大的，直接舍弃掉前面的子列和，新的子列和从序列当前下标i开始，更新cur = 0。 #include <iostream> using namespace std; co
PTA浙江大学数据结构习题——第九周
ManiacLook的博客
05-25 186
(排序4 统计工龄)[https://pintia.cn/problem-sets/1497448825169559552/problems/1521131202348670976] 排好序后，统计每一个连续的相同数字的个数。 #include <iostream> using namespace std; const int N = 100010; int n; int a[N]; void quick_sort(int l, int r) { if (l >= r) r
浙江大学数据结构与算法徐镜春
测试
09-01 1006
数据结构与算法是计算机学科中的核心基础课程。课程的主要目标培养学生较全面地理解基本数据结构的概念和经典算法的思想及各种实现方法，掌握数据结构和算法的设计分析技术。根据所求解问题的性质选择合理的数据结构并对时间空间复杂性进行必要的控制，提高程序设计的质量。使得学生在将来的学习、研究和工作中，具备设计和实现高效的数据结构和算法的能力。数据结构视频教程：浙江大学数据结构与算法徐镜春 整包下载（9...
浙大数据结构PTA 习题3.9堆栈操作合法性
weixin_43676126的博客
04-25 2357
浙大数据结构PTA 习题3.9堆栈操作合法性 假设以S和X分别表示入栈和出栈操作。如果根据一个仅由S和X构成的序列，对一个空堆栈进行操作，相应操作均可行（如没有出现删除时栈空）且最后状态也是栈空，则称该序列是合法的堆栈操作序列。请编写程序，输入S和X序列，判断该序列是否合法。 输入格式: 输入第一行给出两个正整数N和M，其中N是待测序列的个数，M（≤50）是堆栈的最大容量。随后N行，每行中给出一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ㄨㄛˇㄞˋㄋㄧˇ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值