【PTA-训练day30】L2-001 城市间紧急救援 + L2-002 链表去重 + L2-003 月饼 + L2-004 这是二叉搜索树吗？+ L2-005 集合相似度

Roye_ack

已于 2023-04-21 00:01:45 修改

阅读量1k

点赞数 2

分类专栏： PTA每日刷题计划文章标签：算法 c++ 图论天梯赛 dfs

于 2023-04-20 23:58:18 首次发布

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/weixin_61639349/article/details/130270111

版权

PTA每日刷题计划专栏收录该内容

31 篇文章 7 订阅

订阅专栏

本文介绍了几个编程题目，包括使用Dijkstra算法解决城市间紧急救援问题，链表去重的链表模拟，月饼的结构体排序，判断是否为二叉搜索树的DFS方法，以及计算集合相似度的二维set操作。涉及到的数据结构和算法有邻接矩阵、堆优化、前序遍历等。

摘要由CSDN通过智能技术生成

目录

L2-001 城市间紧急救援 - dijkstra 最短路变形

1、dijkstra朴素版

2、堆优化版dijkstra

L2-002 链表去重 - 链表模拟

L2-003 月饼 - 结构体排序

L2-004 这是二叉搜索树吗？ - dfs + 二叉树

L2-005 集合相似度 - 二维set

L2-001 城市间紧急救援 - dijkstra 最短路变形

思路：

本题不仅要求最短路，还要统计最短路的条数、召集救援队最大数量及最短路经过的节点

先用邻接矩阵建双向图，用dij板子

此时用距离起点s最近的点t更新其他点时，分两种情况

1、出现最短路：dist[j]>dist[t]+g[t][j]
更新最短路距离，最短路条数为sum[t]
2、出现重复路径：dist[j]=dist[t]+g[t][j]
即两条路都能选，因此最短路条数+=sum[t]，更新救援队个数

因为要记录最短路所经过的节点，因此用pre数组记录，pre[j]=i j的前一结点为i

1、dijkstra朴素版

#include <bits/stdc++.h>
using namespace std;

const int N=510;
int g[N][N];
int st[N],dist[N],w[N];
int helper[N],sum[N]; //helper救援队数目 sum最短路径条数
int pre[N]; //pre记录前一节点
int n,m,s,d;

int main()
{
    cin>>n>>m>>s>>d;
    memset(dist,0x3f,sizeof dist);
    memset(g,0x3f,sizeof g);
    for(int i=0;i<n;i++) cin>>w[i];
    for(int i=0;i<m;i++)
    {
        int a,b,v;
        cin>>a>>b>>v;
        g[a][b]=g[b][a]=v;
    }
    
    dist[s]=0;
    sum[s]=1;
    helper[s]=w[s];
    for(int i=0;i<n;i++)
    {
        int t=-1;
        for(int j=0;j<n;j++)
            if(!st[j]&&(t==-1||dist[j]<dist[t])) t=j;
        st[t]=1;
        
        for(int j=0;j<n;j++) //用距离起点最近的点去更新其他点
        {
            if(dist[j]>dist[t]+g[t][j]) //出现最短路
            {
                dist[j]=dist[t]+g[t][j];
                sum[j]=sum[t]; //换成最短路径的条数
                helper[j]=helper[t]+w[j];
                pre[j]=t;
            }
            else if(dist[j]==dist[t]+g[t][j]) //出现重复路径
            {
                sum[j]+=sum[t]; //这两条都可以选择 
                if(helper[j]<helper[t]+w[j]) //更新救援队数目
                {
                    helper[j]=helper[t]+w[j];
                    pre[j]=t;
                }
            }
        }
    }
    
    cout<<sum[d]<<" "<<helper[d]<<endl;
    int x=d;
    vector<int> v;
    while(x!=s)
    {
        v.push_back(x);
        x=pre[x];
    }
    v.push_back(s);
    reverse(v.begin(),v.end());
    for(int i=0;i<v.size();i++)
    {
        if(i!=0) cout<<" ";
        cout<<v[i];
    }
}

2、堆优化版dijkstra

#include <bits/stdc++.h>
#define PII pair<int,int>
#define x first
#define y second
using namespace std;

const int N=510,M=N*N;
int h[N],ne[M],e[M],w[M];
int st[N],dist[N],val[N];
int helper[N],sum[N]; //helper救援队数目 sum最短路径条数
int pre[N]; //pre记录前一节点
int n,m,s,d,idx;

void add(int a,int b,int c)
{
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}

int main()
{
    cin>>n>>m>>s>>d;
    memset(h,-1,sizeof h);
    for(int i=0;i<n;i++) cin>>val[i];
    for(int i=0;i<m;i++)
    {
        int a,b,v;
        cin>>a>>b>>v;
        add(a,b,v); add(b,a,v);
    }
    
    memset(dist,0x3f,sizeof dist);
    dist[s]=0;
    sum[s]=1;
    helper[s]=val[s];
    
    priority_queue<PII,vector<PII>,greater<PII>> q;
    q.push({0,s});
    
    while(!q.empty())
    {
        auto t=q.top();
        q.pop();
        int len=t.x,ver=t.y;
        if(st[ver]) continue;
        st[ver]=1;
        
        for(int i=h[ver];~i;i=ne[i])
        {
            int j=e[i];
            if(dist[j]>len+w[i])
            {
                dist[j]=len+w[i];
                sum[j]=sum[ver];
                helper[j]=helper[ver]+val[j];
                pre[j]=ver;
                q.push({dist[j],j}); //只有找到最短路的点入队
            }
            else if(dist[j]==len+w[i])
            {
                sum[j]+=sum[ver];
                if(helper[j]<helper[ver]+val[j])
                {
                    helper[j]=helper[ver]+val[j];
                    pre[j]=ver;
                }
            }
        }
    }
    
    cout<<sum[d]<<" "<<helper[d]<<endl;
    int x=d;
    vector<int> v;
    while(x!=s)
    {
        v.push_back(x);
        x=pre[x];
    }
    v.push_back(s);
    reverse(v.begin(),v.end());
    for(int i=0;i<v.size();i++)
    {
        if(i!=0) cout<<" ";
        cout<<v[i];
    }
}

L2-002 链表去重 - 链表模拟

思路：

用e[idx]和ne[idx]分别记录节点值和下一节点的地址

用re和unre分别存重复和不重复节点的地址

输出该节点地址+该节点值+下一节点地址

#include <bits/stdc++.h>
using namespace std;

const int N=1e5+10;
int e[N],ne[N],st[N];

int main()
{
    int head,n;
    cin>>head>>n;
    
    vector<int> unre,re;
    for(int i=0;i<n;i++)
    {
        int id,x,next;
        cin>>id>>x>>next;
        e[id]=x,ne[id]=next;
    }
    
    for(int i=head;~i;i=ne[i])
    {
        int j=abs(e[i]);
        if(!st[j])
        {
            st[j]=1;
            unre.push_back(i);
        }else re.push_back(i);
    }
    //输出不重复链表
    for(int i=0;i<unre.size();i++)
    {
        printf("%05d %d ",unre[i],e[unre[i]]);
        if(i==unre.size()-1) cout<<-1<<endl;
        else printf("%05d\n",unre[i+1]);
    }
    //输出重复链表
    for(int i=0;i<re.size();i++)
    {
        printf("%05d %d ",re[i],e[re[i]]);
        if(i==re.size()-1) cout<<-1;
        else printf("%05d\n",re[i+1]);
    }
}

L2-003 月饼 - 结构体排序

#include <bits/stdc++.h>
using namespace std;

const int N=1010;
struct node
{
    double kc,sum,dj;
}a[N];

bool cmp(node &a,node &b) //按单价从大到小排序
{
    return a.dj>b.dj;
}

int main()
{
    int n,d;
    cin>>n>>d;
    double res=0;
    for(int i=0;i<n;i++) cin>>a[i].kc;
    for(int i=0;i<n;i++)
    {
        cin>>a[i].sum;
        a[i].dj=a[i].sum/a[i].kc;
    }
    sort(a,a+n,cmp);
   
    for(int i=0;i<n;i++)
    {
        if(d<=0) break;
        if(d>=a[i].kc) res+=a[i].sum,d-=a[i].kc;
        else
        {
            res+=a[i].sum/a[i].kc*d;
            break;
        }
    }
    printf("%.2f",res);
}

L2-004 这是二叉搜索树吗？ - dfs + 二叉树

思路：

前序遍历第一个点是根节点root

左指针l向右移动找<root值的点，右指针r向左移动找≥root值的点

如果l-r！=1，说明该树不是二叉搜索树，退出dfs

eg：8 6 5 7 10 8 11 ——二叉搜索树

r l

eg：8 6 5 7 10 2 11 —— 不是二叉搜索树

l r

如果原本搜索树不是二叉搜索树，则验证其镜像（左右子树对调就行）

#include <bits/stdc++.h>
using namespace std;

const int N=1010;
int a[N];
int n;
vector<int> res;

void dfs1(int rt,int tr)
{
    if(rt>tr) return;
    int l=rt+1,r=tr;
    while(l<=tr&&a[l]<a[rt]) l++;
    while(r>=rt+1&&a[r]>=a[rt]) r--;
    if(l-r!=1) return; //说明不是二叉搜索树
    dfs1(rt+1,r); //递归左子树
    dfs1(l,tr); //递归右子树
    res.push_back(a[rt]); //子树先放 最后放根 所以是后序遍历
}

void dfs2(int rt,int tr) //判断镜像树
{
    if(rt>tr) return ;
    int l=rt+1,r=tr;
    while(l<=tr&&a[l]>=a[rt]) l++;
    while(r>=rt+1&&a[r]<a[rt]) r--;
    if(l-r!=1) return ;
    dfs2(rt+1,r);
    dfs2(l,tr);
    res.push_back(a[rt]);
}

int main()
{
    cin>>n;
    for(int i=0;i<n;i++) cin>>a[i];
    dfs1(0,n-1);
    if(res.size()!=n)
    {
        res.clear();
        dfs2(0,n-1);
    }
    
    if(res.size()!=n)
    {
        cout<<"NO";
        return 0;
    }
    cout<<"YES"<<endl;
    for(int i=0;i<n;i++)
    {
        if(i!=0) cout<<" ";
        cout<<res[i];
    }
}

L2-005 集合相似度 - 二维set

#include <bits/stdc++.h>
using namespace std;

const int N=51;

int main()
{
    int n;
    cin>>n;
    set<int> s[N];
    for(int i=1;i<=n;i++)
    {
        int k;
        cin>>k;
        for(int j=0;j<k;j++)
        {
            int x;
            cin>>x;
            s[i].insert(x);
        }
    }
    
    int q;
    cin>>q;
    while(q--)
    {
        int a,b;
        cin>>a>>b;
        int fz=0;
        for(int x:s[a]) if(s[b].count(x)) fz++;
        double res=fz*1.0/(s[a].size()+s[b].size()-fz);
        printf("%.2f\%\n",res*100);
    }
}

关注

2
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

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