2021-05-29

最新推荐文章于 2024-10-07 17:39:40 发布
最新推荐文章于 2024-10-07 17:39:40 发布
阅读量113 收藏
点赞数
文章标签： 数据结构 dfs 算法 队列 bfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wsebr/article/details/117383941
版权

数据结构第四次上机实验

一、连通分量：

题意：求连通分量的个数

思路：我们已知一次DFS或BFS只能遍历一遍连通分支，我们可以利用这一点，通过统计DFS或BFS调用的次数来确定连通分量的个数。

代码：

1）、关键代码：

void graphl::DFS()
{
    int *visited=new int[graphsize];
    for(int k=1;k<=graphsize;k++)

           visited[k]=0;
    for(int k=1;k<=graphsize;k++)
       {if(visited[k]==0)
       {
           DFS(k,visited);
           sum++;
        }
       }
    delete[]visited;
}

2）、完整代码

#include<iostream>
#include<queue>
#define max0 200000
const int INF=99999999;
int sum=0;
using namespace std;
struct edge{
    friend class graphl;
    int vadj;//节点编号
    int cost;//权值
    edge *link;
};
struct vertex
{
    friend class graphl;
    int vername;
    edge *adj;
};
class graphl{
 vertex* head;//顶点链表头指针

 public:
    int graphsize;//图中当前结点的个数
    int dis[10000];//单源最短路的权值问题
    int torder[10000];//
    //graphl();
    ~graphl();
    void BFS(const int s);
    void DFS();
    void DFS( const int v,int*visited);
    int ctgraphl();
};
 int graphl::ctgraphl()
{
    int e,from,to,weight;
    head=new vertex[max0];
    cin>>graphsize;
    for(int i=1;i<=graphsize;i++)
    {
        head[i].vername=i;
        head[i].adj=NULL;
    }
    cin>>e;
    if(e==0) {int x;cin>>x;return 0 ;}
    else{

    for(int i=1;i<=e;i++)
    {
        cin>>from>>to;
        edge*p=new edge;
        p->vadj=to;
        p->cost=weight;
        p->link=NULL;
        edge*q=head[from].adj;
        if(q==NULL)
            head[from].adj=p;
        else
        {
            while(q->link!=NULL)
            q=q->link;
            q->link=p;
        }
         p=new edge;
        p->vadj=from;
        p->link=NULL;
        q=head[to].adj;
        if(q==NULL)
            head[to].adj=p;
        else
        {
            while(q->link!=NULL)
            q=q->link;
            q->link=p;
        }


    }
    }
    return 1; 
}
graphl::~graphl()
{
    for(int i=1;i<=graphsize;i++)
    {
        edge*p=head[i].adj;
        while(p!=NULL)
        {
            head[i].adj=p->link;
            delete p;
            p=head[i].adj;
        }


    }
    delete []head;
}
void graphl::DFS()
{
    int *visited=new int[graphsize];
    for(int k=1;k<=graphsize;k++)

           visited[k]=0;
    for(int k=1;k<=graphsize;k++)
       {if(visited[k]==0)
       {
           DFS(k,visited);
           sum++;
        }
       }
    delete[]visited;
}
void graphl::DFS( const int v,int*visited)
{
//    cout<<v<<" ";
    visited[v]=1;
    edge*p=head[v].adj;
    while(p!=NULL)
    {
        if(visited[p->vadj]!=1)
            DFS(p->vadj,visited);
            p=p->link;
    }
}
void graphl::BFS(const int s)//从起始顶点开始广度优先遍历图
{
    int *visited=new int [graphsize];
    for(int k=1;k<=graphsize;k++)
    {
            visited[k]=0;
    }
    cout<<s<<" ";
    visited[s]=1;
    queue<int>q;
    q.push(s);
    while(!q.empty())
    {
        int v=q.front();
        q.pop();
        edge*p=head[v].adj;
        while(p!=NULL)
        {
            if(visited[p->vadj]==0)
                {
                    cout<<p->vadj<<" ";
                    visited[p->vadj]=1;
                    q.push(p->vadj);
                }
            p=p->link;

        }
    }
    delete [] visited;
}
int main()
{    
 
    graphl A;
    if(A.ctgraphl())
    {A.DFS();
    cout<<sum;
    }
    else 
    {
        cout<<A.graphsize;
        
    }
    return 0;
}
 

二、整数拆分：

题意：求出不同的拆分方案，以及拆分方案的总数。

思路：这个题无论是方案求解还是去重都让我摸不着头脑，在学习了其他高手的代码后，了解到此类题应用DFS方法求解，并在生成节点以及时保持递增序列就可以去重。（字典序这一类的题都可以用此方法去重）。多次递归调用DFS是为了生成从以（1一直到k）为初始节点的拆分方案。

代码：

#include<iostream>
using namespace std;

#define max0 100000

int sum=0;//记录拆分的数
int n,k;//n为待拆分数，k为拆分的个数
int sur[100];//临时节点存储深搜时的拆分值

void dfs_interger_part(int su,int count);


int main()
{      
     ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    //给输入输出流解绑，使其达到scanf和printf的速度
   cin>>n>>k;
    for(int j=1;j<=n;j++)
    {
        sur[1]=j;
       dfs_interger_part(n-j,2);
    }
    cout<<sum<<endl;
}
void dfs_interger_part(int su,int count)
{   
    
    if(su<0|| count>k+1) return ;//count值超过k+1后不再深搜
    if(su==0&&count==k+1)
    {
        
       cout<<sur[1];
        for(int i=2;i<=k;i++)
        {
            cout<<" "<<sur[i];
            //printf(" %d",sur[i]);
        }
        cout<<endl;
        sum++;
        return ;
    }
    for(int i=sur[count-1];i<=su;i++)
    {
        sur[count]=i;
       dfs_interger_part(su-i, count+1);
    }

}

三、数字变换：

题意：根据规则（1）、（2）、（3）求出由x变为y的最少步数，以及每步的变换结果

思路：一般涉及求最优解的问题大部分可用BFS来做，因为BFS相当于层次遍历，逐层（逐步）逼近最优解。保存路径时我们保存的是该节点前一个节点的地址，我们利用栈将其正序输出。

代码：

1）、关键代码（广搜边搜索边形式生成结点入队）：

void bfs_generate_node()
{
    queue<node>q;
    q.push(node(x,0));
    dis[x]=1;
    while(!q.empty())
    {
        node currentx=q.front();
        q.pop();
        if(currentx.varx==y)
        {
            cstep=currentx.step;
            return ;
        }
        for(int i=1;i<=3;i++)
        {   int v=pri(currentx.varx,i);
            if(v<max0&&!dis[v])
            {
                dis[v]=1;
                path[v]=currentx.varx;
                q.push(node(v,currentx.step+1));
            }
        }
    }
}

2）、输出路径：

int k=path[y];
    stack<int >st；
    while(path[k]!=-1)
        {
        st.push(k);
        k=path[k];
        }
    cout<<cstep<<endl;
    while(!st.empty())
        {
        printf("%d ",st.top());
        st.pop();
        }
    printf("%d",y);

3）、完整代码

#include<iostream>
#include<queue>
#include<stack>


using namespace std;
#define max0 200000

class node{
public:
int varx;
int step;
node(int x0,int y0):varx(x0),step(y0){}
};


int x,y;
int cstep;
int dis[200000];
int path[200000];



int pri(int x,int i);
void bfs_generate_node();


int main()
{
   scanf("%d%d",&x,&y);
   if(x==y) {cout<<0<<endl;return 0;}
   else
   {
    for(int i=0;i<max0;i++)
       path[i]=-1;
    bfs_generate_node();
    int k=path[y];
    stack<int >st；
    while(path[k]!=-1)
        {
        st.push(k);
        k=path[k];
        }
    cout<<cstep<<endl;
    while(!st.empty())
        {
        printf("%d ",st.top());
        st.pop();
        }
    printf("%d",y);
    return 0;
  }
}



void bfs_generate_node()
{
    queue<node>q;
    q.push(node(x,0));
    dis[x]=1;
    while(!q.empty())
    {
        node currentx=q.front();
        q.pop();
        if(currentx.varx==y)
        {
            cstep=currentx.step;
            return ;
        }
        for(int i=1;i<=3;i++)
        {   int v=pri(currentx.varx,i);
            if(v<max0&&!dis[v])
            {
                dis[v]=1;
                path[v]=currentx.varx;
                q.push(node(v,currentx.step+1));
            }
        }
    }
}
int pri(int x,int i)
{
    if(i==3)
       return x-1;
    else if(i==1)
         return x+1;
    else if(i==2)
         return x*2;
}

四、旅行 1：

题意：求出给定城市到其他各城市的最小费用，并求出在最小费用下，到某城市经过最多城市数。

思路：总体为单源最短路问题，但题目中又加了一个条件，就是在最小费用下，尽可能多的多经过其他城市。此时我们只需要修改path[ ]数组即保存路径数组的更新条件即可。本题我采用了迪杰特斯拉的堆优化形式求解，该做法适用于边稀疏的图。

代码：

1）、关键代码（length函数是求该点到源点的路径长）---path[ ]数组更新代码

 for(int i = 0;i<g[v].size();i++) {
            //遍历所有后续边
            edge e = g[v][i];
            int to = e.to;
            int cost = e.cost;
            if(D[to] > D[v] + cost){
                D[to] = D[v] + cost;
                path[to]=v;
                que.push(P(D[to],to));
            }
            else if(D[to]==D[v]+cost)
            {
                if(length(to)<length(v)+1){
                    path[to]=v;
                    que.push(P(D[to],to));
                    }
            }
        }
    }

2）、完整代码

#include<bits/stdc++.h>//该算法适用于稀疏图
#define INF 100000005
#define MAX 100006
using namespace std;
typedef pair<int,int> P;
struct edge{
    int to;
    int cost;
    edge(int t,int c):to(t),cost(c){
    }
};
int length(int s0);
const int N = 100006;
vector<edge> g[N];
int dis[100][100],cd[100000]; //距离
int n,m; //n个点 m条边
//int path[100][100];//最小生成路的长度
int path[100000];
int D[100000];
void Dijkstra(int s){

    static int countdij=0;
    priority_queue<P,vector<P>,greater<P> > que; //小端优先队列
    fill(D,D+100000,INF);//注意必须初始化为最大
    D[s] = 0;
    if(s==0)
    for(int i=0;i<n;i++)
        path[i]=-1;
    que.push(P(0,s));
    while(!que.empty()){
        P p = que.top();
        que.pop();
        int v = p.second;
        if(D[v] < p.first) continue; //说明该点无需重复
        for(int i = 0;i<g[v].size();i++) {
            //遍历所有后续边
            edge e = g[v][i];
            int to = e.to;
            int cost = e.cost;
            if(D[to] > D[v] + cost){
                D[to] = D[v] + cost;
                path[to]=v;
                que.push(P(D[to],to));
            }
            else if(D[to]==D[v]+cost)
            {
                if(length(to)<length(v)+1){
                    path[to]=v;
                    que.push(P(D[to],to));
                    }
            }
        }
    }
}


int main(){
//    int trans;
    int s=0;
    cin>>n>>m;//m为边数,n为点数
     cin>>s;
    int a,b,d;
    //Vector<edge> g[MAX]的初始化
    for(int i = 0;i<MAX;i++) {
        g[i].clear();
    }
    for(int i = 0;i<m;i++){
        cin>>a>>b>>d;
        g[a].push_back(edge(b,d));
        g[b].push_back(edge(a,d));
    }


    Dijkstra(s);
    int k;
//     printf("\n%d -> %d 的最小路径长为：%d\n", s, t,D[t] );
//     for(int i=0;i<n;i++)
//        {for(int j=0;j<n;j++)
//          cout<<dis[0][j]<<" ";
//          cout<<"\n";
cout<<D[1];
for(int i=2;i<=n;i++)
 cout<<" "<<D[i];
 cout<<endl;
// for(int i=1;i<=n;i++)
//    cout<<path[i]<<" "<<endl;
 for(int i=1;i<=n;i++)
    for(int k=i;path[k]!=0;k=path[k],cd[i]++);

    cout<<cd[1];
    for(int i=2;i<=n;i++)
    cout<<" "<<cd[i];
    return 0;
}
int length(int s0)
{
    int s=0;
    for(;path[s0]!=0;s0=path[s0])
    {
        s++;
    }
    return s;
}

 

wsebr
关注
JLU数据结构荣誉课——第五次上机实验
qq_56208478的博客
06-02 364
数据结构荣誉课第五次上机测试 7-1 图的深度优先搜索I (100 分) 无向图 G 有 n 个顶点和 m 条边。求图G的深度优先搜索树(森林)以及每个顶点的发现时间和完成时间。每个连通分量从编号最小的结点开始搜索，邻接顶点选择顺序遵循边的输入顺序。 在搜索过程中，第一次遇到一个结点，称该结点被发现；一个结点的所有邻接结点都搜索完，该结点的搜索被完成。深度优先搜索维护一个时钟，时钟从0开始计数，结点被搜索发现或完成时，时钟计数增1，然后为当前结点盖上时间戳。一个结点被搜索发现和完成的时间戳分别称为该结点的发
2021-05-29 正则表达式思维导图
weixin_44629215的博客
05-29 157
2021-05-29周赛小记
qq_44459787的博客
05-30 1万+
因为种种原因，实际比赛时间大概只有半个多小时，不过前两题都秒了，最后一题有一定的思路但是又被异或给整跑偏了，菱形那题确实没做出来。 - 长度为三且各字符不同的子字符串 class Solution { public: int countGoodSubstrings(string s) { int n = s.size(); if(n <= 2) return 0; int beg = 0, end = 2; .
树莓派没有任务栏2021-05-29
weixin_46032860的博客
05-29 5503
树莓派没有任务栏2021-05-29遇到问题无法解决最终解决 遇到问题 无法解决 百度：两行代码不行 #(后面-pi为用户名 如果没有改过用户名就不管他) 删除配置文件 $ rm -rf ~/.config/lxpanel/LXDE-pi #重启 $ sudo reboot 简书：两行代码不行，加文本文件不行 最终解决 cd ~/.config/lxpanel/LXDE-pi/panels curl -O https://gist.githubusercontent.com/ColinNg/9ed31
2021-01-18
weixin_54641072的博客
01-18 1861
找程序猿哥哥！！！！编制App或者小程序
不同标准下的ESD HBM模型 2021-05-29
耀程工的博客
05-29 3712
不同标准下的ESD HBM模型 HBM的ESD测试规格有AEC-Q200-002和IEC61000-4-2等，不同标准下的HBM模型如下： 规格名 充电用电容器 Cd（pF） 放电用电阻 Rd （Ω） AEC-Q200-002 150 2000 IEC61000-4-2 150 330 AEC-Q200-002HBM的ESD测试电路及放电电流波形如图1、图2所示。 （i） 开关2为断开状态，开关1闭合，施加高压电源，充电用电容器（Cd）存储电量。
2021-05-29-PCB学习重点笔记之二，画原理图
weixin_42656213的博客
06-03 8846
一、原理图绘制 1. 走线与画线 区别：绘线和走线 绘线：用于标识，可以修改线的大小颜色等属性，但是不具备电气特性，比如两个电阻用绘线连接在一起，并不代表两个电气的连接，而是为了将不同电路图分成几个区域。也可以在工具栏的 放置 -> 绘图工具 -> 线 中找到该功能。画线的时候按快捷键SHIFT+空格，将走线模式切换为Any Angle 走线：用于电气上的连接。 2. 批量修改 在原理图中 右键->查找相似对象->点击一个元件，然后弹起一个对话框，按照下图选择： 然后应
2021-01-04
wubaoyu123的博客
01-04 2274
博客园Logo 首页 新闻 博问 专区 闪存 班级 代码改变世界 搜索 注册 登录 返回主页 知了一笑 博客园 首页 新随笔 联系 订阅 管理 数据仓库组件：Hive环境搭建和基础用法 本文源码：GitHub || GitEE 一、Hive基础简介 1、基础描述 Hive是基于Hadoop的一个数据仓库工具，用来进行数据提取、转化、加载，是一个可以对Hadoop中的大规模存储的数据进行查询和分析存储的组件，Hive数据仓库工具能将结构化的数据文件映射为一张数据库表，并提供SQL查询功能，能将SQL语句转变成
2021-05-30
热门推荐
qq_39027095的博客
05-30 5万+
2003 梅兰芳（藏）戏曲史料图画集（上下） 中国最美的书、2004年度“世界最美的书”金奖 书籍设计：张志伟（封面设计） 作　　者：刘曾得、朱家溍 出版单位：河北教育出版社 印刷单位：深圳雅昌彩色印刷有限公司 书籍分类：艺术与摄影 ISBN：7543444364 定　　价：298 元 评委点评： 本书的图谱为梅兰芳纪念馆现存的全部“缀玉轩”珍藏戏画、脸谱原作复制而成。为四眼线装，上下两册，函盒装。这是一套令人爱不释手的书，无论内容还是形式。全书整体工细流利，墨彩相映，蕴静...
2021-05-06
weixin_45779984的博客
05-06 196
计算机工程投稿过程 阶段名称 处理人 提交时间 估计完成时间 初审 编辑部 2021-02-25 2021-02-25 待交审稿费 编辑部 2021-02-25 2021-03-11 待送审 编辑部 2021-02-25 2021-03-04 外审 外审专家 2021-02-26 2021-04-07 待送修 编辑部 2021-04-14 2021-04-28 退修 责任编辑 2021-0
Screenshot_2021-05-29-03-49-53-32_ca6ee20236ea15ad01663c6ea4ca0bdb.jpg
05-29
Screenshot_2021-05-29-03-49-53-32_ca6ee20236ea15ad01663c6ea4ca0bdb.jpg
基于嵌入式AI模组的3D视觉应用开发实践[2021-05-18]（29页）.pdf
05-21
基于嵌入式AI模组的3D视觉应用开发实践[2021-05-18]（29页）.pdf
maven plugin 简单介绍和实战 (2021-05-29)
master-dragon的专栏
05-29 1330
maven plugin 开发： https://maven.apache.org/plugin-developers/index.html 什么是plugin? “Maven” is really just a core framework for a collection of Maven Plugins. In other words, plugins are where much of the real action is performed, plugins are used to: create
2021-05-29 钓鱼（贪心）
m0_51530106的博客
05-29 693
问题 E: 钓鱼 提交:50|解决:14|时间限制:1.00s|内存限制:128M 题目描述 小明准备去钓鱼，他准备在一个有nn个湖的地方钓hh小时，小明只能按顺序从第 1 个湖 开始，依次在各个湖钓鱼，但是在每个湖的钓鱼时间是由小明自己决定的。从第ii个湖走到第i+1i+1个湖的时间是titi个55分钟。例如t3=4,t3=4,表明从第33个湖走到第44个湖需要2020分钟。 对于每个湖ii，在初始的55分钟，小明可以钓到fif...
【数据结构强化】应用题打卡
Father_Of_Soft的博客
10-03 810
王道应用题打卡
《数据结构》学习系列——树（上）
Kenjuan的博客
10-01 920
一个树（或树形）就是一个有限非空的结点集合T，其中：有一个特别标出的被称为该树（或树形）之根root(T)的结点其余结点 （根除外）被分成m≥0个不相交的集合T1，T2，...，Tm，且T1，T2，...，Tm又都是树（或树形）。树（或树形）T1，T2，...，Tm被称作root(T)的子树（或子树形（非递归定义）定义：树是包含n（n≥1）个结点且满足如下条件的有限集合存在一个唯一的结点v0，它没有前驱结点，称为树的根（或根结点）任何非根结点都有且仅有前驱节点，称为该节点的父结点。
Java.数据结构.TreeSet
TJKFYY的博客
10-03 305
TreeSet是Java集合框架中的一部分，是基于TreeMap实现的。TreeSet保证了集合中的元素按照自然顺序或者通过提供的Comparator进行排序。：TreeSet会根据元素的自然顺序进行排序，确保集合中的元素总是处于有序状态，和TreeMap一样，我们同样可以通过重写Comparator方法来进行排序。：TreeSet中的元素是唯一的，不能重复。如果有两个元素相等，则后插入的元素不会出现在集合中。：TreeSet基于TreeMap实现，其时间复杂度为O(log n)。
Java：数据结构-初始结合框架 时间复杂度和空间复杂度 初识泛型
最新发布
blamep的博客
10-07 911
Java 的集合框架（Java Collection Framework，JCF）是 Java 标准库中的一部分，用于存储和操作一组数据。它提供了一些常用的数据结构和接口，用来高效管理和操作数据。Java 的集合框架位于java.util包中。
【C++算法】8.双指针_四数之和
hlyd520的博客
10-04 600
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
java生成租金计划 需求：根据下面的条件生成每个月的月租金计划列表 递增周期：1年 租金递增率：6% 租赁开始时间 2021-03-01 租赁结束时间 2022-03-01 免租开始时间：2021-03-01 免租结束时间：2021-03-31 开始月租金：600 递增周期的时间是从租赁开始时间计算。
05-26
2021-05-01 31 636.00 2021-06-01 30 674.16 2021-07-01 31 713.57 2021-08-01 31 754.29 2021-09-01 30 796.39 2021-10-01 31 840.94 2021-11-01 30 887.02 2021-12-01 31 934.72 2022-01-01 31 984.12 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值