18-03 两数之间最短步骤

最新推荐文章于 2024-11-12 12:29:51 发布

耀Strive

最新推荐文章于 2024-11-12 12:29:51 发布

阅读量74

点赞数

分类专栏：真题代码文章标签：算法 c++ 数据结构 c语言

本文链接：https://blog.csdn.net/Arieamni/article/details/129343778

版权

真题代码专栏收录该内容

14 篇文章 1 订阅

订阅专栏

该文介绍了一种通过链表和队列实现的广度优先搜索(BFS)算法，用于找到从整数n到m的最少操作次数，操作包括乘2、减1和加1。通过不断模拟这三种操作并保存所有可能的状态，直至找到目标值m，从而得出最短步骤。

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

18-03 两数之间最短步骤

题目问题描述：

输入两个整数n，m，( 0 < n,m<100000)每一次，第一个整数可以执行乘2,、减1、加1三种操作的任意一种，求n到m至少要多少次这样的操作。

思路分析：

解决：

结构体定义节点；利用链表来实现队列的入队和出队；
将三种可能全部入队，依次更具计算结构，在进行三种可能循环入队操作；
直到找到与输入最大值相同时跳出循环；
分析见文末

结果截图：

实现代码：

#include<stdio.h>
#include<stdlib.h>
struct list//用结构体表示节点
{
    long n; //节点数值
    int step;//表示步数
    struct list *next;
};
int main(){
	int n, m;
	int k; //用于判断是否到达m值
	struct list *p, *pm; //当前节点和最前节点
	struct list *p1, *p2, *p3;//三种操作节点；

	scanf("%d %d",&n ,&m);

	p=(struct list *)malloc(sizeof(struct list )); //初始化p
	p->n = n;
	p->step = 0;
	p->next = NULL;
	pm = p;

	while(p != NULL){
		k = p->n;
		if(k == m)	//当前节点为m则跳出循环；
			break;
		//将p,p1(-),p2(+),p3(*)即三种步骤全部保存，计算每种可能直到找到m；					
		p1=(struct list *)malloc(sizeof(struct list )); //初始化p1
		p1->n = k-1;
		p1->step = p->step+1;
		p1->next = NULL;

		pm->next = p1; //连接新的节点操作p1；

		p2=(struct list *)malloc(sizeof(struct list )); //初始化p2
		p2->n = k+1;
		p2->step = p->step+1;
		p2->next = NULL;

		p1->next = p2; //连接新的节点操作p2；

		p3=(struct list *)malloc(sizeof(struct list )); //初始化p3
		p3->n = k*2;
		p3->step = p->step+1;
		p3->next = NULL;

		p2->next = p3; //连接新的节点操作p3；

		pm = p3;//更新最前节点
		p1 = p;//设置删除节点
		p = p->next;//依次遍历

		free(p1);

	}

	printf("至少需%d步\n",p->step);

}

实现代码答：

#include<stdlib.h>
#include<stdio.h>
struct list//用结构体表示每一个节点，用队列来实施bfs
{
    long n;
    int step;//表示步数
    struct list *next;
};
int main()
{
    long n,m,k;
    struct list *p,*p1,*p2,*p3,*pm;
    scanf("%ld %ld",&n,&m);
    p=(struct list *)malloc(sizeof(struct list ));
    p->n=n;
    p->step=1;
    p->next=NULL;
    pm=p;
    while(p!=NULL)//每一步-1，+1，*2都保存在链表维护的队列中
    {
        k=p->n;//每一次去队列的队头
        if(k==m)
            break;
        p1=(struct list *)malloc(sizeof(struct list ));
        p1->n=k-1;
        p1->step=p->step+1;
        p1->next=NULL;
        pm->next=p1;
        p2=(struct list *)malloc(sizeof(struct list ));
        p2->n=k+1;
        p2->step=p->step+1;
        p2->next=NULL;
        p1->next=p2;
        p3=(struct list *)malloc(sizeof(struct list ));
        p3->n=k*2;
        p3->step=p->step+1;
        p3->next=NULL;
        p2->next=p3;
        pm=p3;
        p1=p;
        p=p->next;

        free(p1);

    }
printf("%d\n",p->step-1);
return 0;
}

步骤分析：

分析代码：

#include<stdlib.h>
#include<stdio.h>
struct list//用结构体表示每一个节点，用队列来实施bfs
{
    long n;
    int step;//表示步数
    struct list *next;
};
int main()
{
    long n,m,k;
    struct list *p,*p1,*p2,*p3,*pm;
    scanf("%ld %ld",&n,&m);
    p=(struct list *)malloc(sizeof(struct list ));
    p->n=n;
    p->step=1;
    p->next=NULL;
    pm=p;
    while(p!=NULL)//每一步-1，+1，*2都保存在链表维护的队列中
    {
        k=p->n;//每一次去队列的队头
        if(k==m)
            break;

        p1=(struct list *)malloc(sizeof(struct list ));
        p1->n=k-1;
        p1->step=p->step+1;
        p1->next=NULL;
		printf("p :%d ",p ->n);
		printf("p1:%d ",p1->n);
        
		pm->next=p1;
		
        p2=(struct list *)malloc(sizeof(struct list ));
        p2->n=k+1;
        p2->step=p->step+1;
        p2->next=NULL;

		printf("p2:%d ",p2->n);
        p1->next=p2;

        p3=(struct list *)malloc(sizeof(struct list ));
        p3->n=k*2;
        p3->step=p->step+1;
        p3->next=NULL;

		printf("p3:%d ",p3->n);
        p2->next=p3;

printf("|||");
	
        pm=p3;
        p1=p;
        p=p->next;
		printf("P:%d, P1:%d, P2:%d, P3:%d, PM:%d",p->n,p1->n,p2->n,p3->n,pm->n);
		printf("(p->next:%d)  \n",p->next->n);
        free(p1);
		

    }
printf("\n%d\n",p->step-1);
return 0;
}