约瑟夫环和一元多项式

news2024/9/20 20:44:19

约瑟夫环

一、问题描述    

假设有 n 个人围成一圈，从第一个人开始报数，报数到 m 的人将被淘汰出圈，然后从下一个人开始继续从 1 报数，如此重复，直到最后只剩下一个人。求最后剩下的这个人的编号。

二、问题分析

可以使用循环链表来模拟这个过程。

1.创建一个包含 n 个节点的循环链表，每个节点代表一个人，节点中存储这个人的编号。

2.从第一个节点开始报数，每报到 m，就将对应的节点从链表中删除。

3.重复这个过程，直到链表中只剩下一个节点，这个节点所代表的人的编号就是问题的答案。

数据元素：

数据元素之间的逻辑结构为线性结构

选择的存储结构为链式存储结构，因为有大量的删除操作，链式存储结构便于进行删除操作

三、举例分析    

例如，有 7 个人，从 1 开始报数，报到 3 的人被淘汰。

初始状态：1、2、3、4、5、6、7 围成一圈。

第一次报数：报到 3 的人被淘汰，此时圈子里剩下 1、2、4、5、6、7。

第二次报数：从 4 开始，报到 6 的人被淘汰，圈子里剩下 1、2、4、5、7。

第三次报数：从 7 开始，报到 2 的人被淘汰，圈子里剩下 1、4、5、7。

第四次报数：从 4 开始，报到 7 的人被淘汰，圈子里剩下 1、4、5。

第五次报数：从 1 开始，报到 5 的人被淘汰，圈子里剩下 1、4。

第六次报数：从 4 开始，报到 1 的人被淘汰，最后剩下 4。

所以，在这个例子中，最后剩下的人的编号是 4。

四、具体实现

#include <stdio.h>
#include <stdlib.h>

// 定义链表节点结构
struct Node {
    int data;
    struct Node* next;
};

// 创建循环链表
struct Node* createCircularList(int n) {
    struct Node* head = NULL;
    struct Node* prev = NULL;
    for (int i = 1; i <= n; i++) {
        struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
        newNode->data = i;
        newNode->next = NULL;
        if (!head) {
            head = newNode;
        } else {
            prev->next = newNode;
        }
        prev = newNode;
    }
    prev->next = head;
    return head;
}

// 解决约瑟夫环问题
int josephusProblem(int n, int m) {
    struct Node* current = createCircularList(n);
    struct Node* prev = NULL;
    while (current->next!= current) {
        for (int i = 1; i < m; i++) { //相当于计数
            prev = current;
            current = current->next;
        }
        prev->next = current->next;//这里是删除操作
        struct Node* temp = current;
        current = current->next;
        free(temp);
    }
    int result = current->data;
    free(current);
    return result;
}

int main() {
	int n,m;     //n为总人数，m为报到的数
	scanf("%d %d",&n,&m);
    int lastPerson = josephusProblem(n, m);
    printf("最后剩下的人的编号是：%d\n", lastPerson);
    return 0;
}

以下是运行结果

也可以用数学公式解决这个问题

有N个人围成一圈（编号为1～N），从第1号开始进行1、2、3报数，凡报3者就退出，下一个人又从1开始报数……直到最后只剩下一个人时为止。请问此人原来的编号是多少?

输入格式:

在一行中给出1个不超过100的正整数N。

输出格式:

在一行中输出最后剩下那个人的编号。

输入样例:

10

输出样例:

4
#include<stdio.h>
int main()
{
    int n,m=3,i,s=0;
    scanf("%d",&n);
    for(i=2;i<=n;i++)
    {
        s=(s+m)%i;
    }
    printf("%d",s+1);
}

 一元多项式运算

一、问题分析

1.一元多项式的表示    

一元多项式可以用链表来表示，每个节点表示多项式中的一项，包含系数和指数两个数据域。 例如，多项式     可以表示为三个节点的链表，第一个节点的系数为 3，指数为 2；第二个节点的系数为 2，指数为 1；第三个节点的系数为 1，指数为 0。

2.运算的实现    

加法：将两个多项式对应项的系数相加，如果指数相同则合并为一项，否则分别插入到结果多项式中。    

减法：与加法类似，但是需要将被减多项式的每一项系数取相反数后再进行加法运算

 

二、实现步骤

  1. 定义链表节点结构 
       struct PolyNode {
       int coef; // 系数
       int exp; // 指数
       struct PolyNode* next;
   };
  2. 创建多项式 输入多项式的项数，然后依次输入每一项的系数和指数，创建链表表示的多项式。 
       struct PolyNode* createPolynomial() {
       int n;
       printf("输入多项式的项数：");
       scanf("%d", &n);
       struct PolyNode* head = NULL;
       struct PolyNode* prev = NULL;
       for (int i = 0; i < n; i++) {
           struct PolyNode* newNode = (struct PolyNode*)malloc(sizeof(struct PolyNode));
           printf("输入第 %d 项的系数和指数：", i + 1);
           scanf("%d%d", &newNode->coef, &newNode->exp);
           newNode->next = NULL;
           if (!head) {
               head = newNode;
           } else {
               prev->next = newNode;
           }
           prev = newNode;
       }
       return head;
   }

  3. 打印多项式 遍历链表，按照系数和指数的格式输出多项式。
   void printPolynomial(struct PolyNode* head) {
       if (!head) {
           printf("0\n");
           return;
       }
       struct PolyNode* current = head;
       while (current) {
           if (current->coef!= 0) {
               if (current->coef > 0 && current!= head) {
                   printf("+");
               }
               if (current->exp == 0) {
                   printf("%d", current->coef);
               } else if (current->exp == 1) {
                   printf("%dx", current->coef);
               } else {
                   printf("%dx^%d", current->coef, current->exp);
               }
           }
           current = current->next;
       }
       printf("\n");
   }

 

4.多项式加法与减法 同时遍历两个多项式，比较指数大小，将对应项的系数相加，或者将较小指数的项直接插入到结果多项式中。

例如：

 

 A，B的存储结构示意图：

先比较A,B的第一个结点内的指数大小，显然0比1小，所以直接把A的第一个结点放进新的链表里。 然后用B的第一个结点与A的第二个结点的指数比较，两者都是1，如果是加法，把两个结点内的系数进行相加，如果是减法，把要减去的多项式的结点的系数变为相反数相加即可。 然后将得到的结果与系数组成一个新的结点，放进新的链表里。 以此类推。

加法：

   struct PolyNode* addPolynomial(struct PolyNode* poly1, struct PolyNode* poly2) {
       struct PolyNode* result = NULL;
       struct PolyNode* prev = NULL;
       struct PolyNode* current1 = poly1;
       struct PolyNode* current2 = poly2;
       while (current1 && current2) {
           struct PolyNode* newNode = (struct PolyNode*)malloc(sizeof(struct PolyNode));
           if (current1->exp > current2->exp) {
               newNode->coef = current1->coef;
               newNode->exp = current1->exp;
               current1 = current1->next;
           } else if (current1->exp < current2->exp) {
               newNode->coef = current2->coef;
               newNode->exp = current2->exp;
               current2 = current2->next;
           } else {
               newNode->coef = current1->coef + current2->coef;
               newNode->exp = current1->exp;
               current1 = current1->next;
               current2 = current2->next;
           }
           newNode->next = NULL;
           if (!result) {
               result = newNode;
           } else {
               prev->next = newNode;
           }
           prev = newNode;
       }
       while (current1) {
           struct PolyNode* newNode = (struct PolyNode*)malloc(sizeof(struct PolyNode));
           newNode->coef = current1->coef;
           newNode->exp = current1->exp;
           newNode->next = NULL;
           prev->next = newNode;
           prev = newNode;
           current1 = current1->next;
       }
       while (current2) {
           struct PolyNode* newNode = (struct PolyNode*)malloc(sizeof(struct PolyNode));
           newNode->coef = current2->coef;
           newNode->exp = current2->exp;
           newNode->next = NULL;
           prev->next = newNode;
           prev = newNode;
           current2 = current2->next;
       }
       return result;
   }

减法

   struct PolyNode* subtractPolynomial(struct PolyNode* poly1, struct PolyNode* poly2) {
       struct PolyNode* temp = poly2;
       while (temp) {
           temp->coef = -temp->coef;
           temp = temp->next;
       }
       return addPolynomial(poly1, poly2);
   }

 

多项式乘法 逐项相乘，将结果插入到结果多项式中，然后合并同类项。

   struct PolyNode* multiplyPolynomial(struct PolyNode* poly1, struct PolyNode* poly2) {
       struct PolyNode* result = NULL;
       struct PolyNode* current1 = poly1;
       while (current1) {
           struct PolyNode* current2 = poly2;
           while (current2) {
               struct PolyNode* newNode = (struct PolyNode*)malloc(sizeof(struct PolyNode));
               newNode->coef = current1->coef * current2->coef;
               newNode->exp = current1->exp + current2->exp;
               newNode->next = NULL;
               struct PolyNode* temp = result;
               struct PolyNode* prev = NULL;
               while (temp && temp->exp > newNode->exp) {
                   prev = temp;
                   temp = temp->next;
               }
               if (temp && temp->exp == newNode->exp) {
                   temp->coef += newNode->coef;
                   free(newNode);
               } else {
                   if (!prev) {
                       result = newNode;
                   } else {
                       prev->next = newNode;
                   }
                   newNode->next = temp;
               }
               current2 = current2->next;
           }
           current1 = current1->next;
       }
       return result;
   }

 

5.主函数 调用上述函数，实现多项式的输入、运算和输出

   int main() {
       struct PolyNode* poly1 = createPolynomial();
       struct PolyNode* poly2 = createPolynomial();
       printf("多项式 1：");
       printPolynomial(poly1);
       printf("多项式 2：");
       printPolynomial(poly2);
       struct PolyNode* sum = addPolynomial(poly1, poly2);
       printf("两多项式之和：");
       printPolynomial(sum);
       struct PolyNode* difference = subtractPolynomial(poly1, poly2);
       printf("两多项式之差：");
       printPolynomial(difference);
       struct PolyNode* product = multiplyPolynomial(poly1, poly2);
       printf("两多项式之积：");
       printPolynomial(product);
       return 0;
   }

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2091578.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

最新Vmware17的WIn10虚拟机开箱即用，免安装

最新Vmware17的WIn10虚拟机开箱即用，免安装

这篇文章分享的Vmware安装Win10的教程&#xff0c;如过有些懒得装Win10的同学可以会直接使用我的WIn10镜像压缩包打开即可 Win10镜像压缩包下载 tips&#xff1a;⬆️⬆️包含Vmware17安装包 使用方法&#xff0c;打开Vmware
阅读更多...
Native开发与逆向第五篇 - hook log打印

Native开发与逆向第五篇 - hook log打印

开发demo 新建native项目&#xff0c;实现log打印字符串。 下载地址&#xff1a;https://download.csdn.net/download/u013170888/89698015 #include <android/log.h> #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, "JNI_LOG", __VA_ARGS__)exte…
阅读更多...
TQRFSOC开发板47DR ADC输入采集环境搭建（一）

TQRFSOC开发板47DR ADC输入采集环境搭建（一）

本章内容实现在ubuntu18.04与20.04系统中&#xff0c;搭建RFSOC ADC采样解析应用的环境搭建与测试。 第一步&#xff0c;安装所需要的apt包&#xff0c;需要的软件有&#xff1a;python-tk&#xff0c;virtualenv和python&#xff0c;在ubuntu20.04系统中python需要安装python2…
阅读更多...
Nginx: 高可用和与虚拟路由冗余协议VRRP原理

Nginx: 高可用和与虚拟路由冗余协议VRRP原理

Nginx 服务的高可用 1 &#xff09;服务可用 假定是这样一个最传统的一个CS模式的一个客户服务器模式 这里有用户和一台服务器服务器可能是mysql, 也可能是webserver, 或其他服务器 想实现服务可用的一个三要素 1.1 ) server 需要公网的ip地址以及申请一个域名1.2 ) 需要服务软…
阅读更多...
Vue3 进阶教程：一文详解 el-table 组件的二次封装技巧！

Vue3 进阶教程：一文详解 el-table 组件的二次封装技巧！

开发后台管理系统&#xff0c;在业务上接触的最多就是表单&#xff08;输入&#xff09;和表格&#xff08;输出&#xff09;了。对于使用 Vue 框架进行开发的同学来说&#xff0c;组件库 Element 是肯定会接触的&#xff0c;而其中的 el-table 和 el-form 更是管理系统中的常客…
阅读更多...
华为云征文｜华为云Flexus X实例docker部署srs6并调优，协议使用webrtc与rtmp

华为云征文｜华为云Flexus X实例docker部署srs6并调优，协议使用webrtc与rtmp

华为云征文&#xff5c;华为云Flexus X实例docker部署srs6并调优&#xff0c;协议使用webrtc与rtmp 什么是华为云Flexus X实例 华为云Flexus X实例云服务是新一代开箱即用、体验跃级、面向中小企业和开发者打造的高品价比云服务产品。Flexus云服务器X实例是新一代面向中小企业…
阅读更多...
MES系统如何实现产品追溯功能

MES系统如何实现产品追溯功能

MES系统&#xff08;Manufacturing Execution System&#xff0c;制造执行系统&#xff09;的产品追溯功能是现代制造业中不可或缺的一部分&#xff0c;它通过记录和分析生产过程中产生的数据&#xff0c;实现了对产品、原材料、设备等信息的追踪和溯源。以下是对MES系统产品追…
阅读更多...
网络安全的历史

网络安全的历史

如今&#xff0c;网络安全几乎成为各大公司和利益相关者关注的焦点。但在早期&#xff0c;网络安全的概念非常模糊。 直到多年以后&#xff0c;由于网络攻击和危险实体威胁的频繁发生&#xff0c;网络安全的发展才受到重视。这些措施的发展成为了网络安全的演变。 网络安全起…
阅读更多...
基于django框架下个人着装助理系统/基于python的服装服装搭配系统

基于django框架下个人着装助理系统/基于python的服装服装搭配系统

摘要 随着科学技术的发展和人们生活质量的改善&#xff0c;人们对于着装的要求也会越来越高。为了能够更好的管理着装&#xff0c;个人着装助理系统被开发处理方便人们对着装的管理。 本个人着装助理系统采用编程语言Python&#xff0c;开源框架Django实现系统的架构&#xff…
阅读更多...
分类任务实现模型集成代码模版

分类任务实现模型集成代码模版

分类任务实现模型&#xff08;投票式&#xff09;集成代码模版 简介 本实验使用上一博客的深度学习分类模型训练代码模板-CSDN博客&#xff0c;自定义投票式集成&#xff0c;手动实现模型集成&#xff08;投票法&#xff09;的代码。最后通过tensorboard进行可视化&#xff0…
阅读更多...
Java之初始泛型

Java之初始泛型

1 包装类 在Java中&#xff0c;由于基本类型不是继承自Object&#xff0c;为了在泛型代码中可以支持基本类型&#xff0c;Java给每个基本类型都对应了一个包装类型。 1.1 基本数据类型和对应的包装类 基本数据类型包装类byteByteshortShortintIntegerlongLongfloatFloatdoub…
阅读更多...
RAG最佳实践：用 ElasticSearch 打造AI搜索系统与RAG 应用全流程详解！

RAG最佳实践：用 ElasticSearch 打造AI搜索系统与RAG 应用全流程详解！

前面一篇文章《RAG 向量数据库：掌握 Elasticsearch 作为向量数据库的终极指南》中，介绍了使用ElasticSerach作为向量数据的安装和使用指南。 今天这篇文章将介绍如何使用 Elasticsearch 搭建AI搜索系统和RAG应用系统。 Elasticsearch 搭建 AI 搜索系统 在 Elasticsearch 中…
阅读更多...
游泳耳机哪个牌子的好？四大口碑精品游泳耳机专业推荐！

游泳耳机哪个牌子的好？四大口碑精品游泳耳机专业推荐！

在追求健康生活的同时&#xff0c;游泳成为了许多人选择的锻炼方式。它不仅能够帮助人们塑造身材&#xff0c;还能有效缓解压力。而在游泳过程中&#xff0c;音乐的陪伴无疑能让人更加享受这段时光。因此&#xff0c;一款适合游泳时使用的耳机&#xff0c;成为了游泳爱好者们不…
阅读更多...
java程序CUP持续飙高

java程序CUP持续飙高

1.top 2.定位进程中使用CPU最高的线程 top -Hp 70688 3.将线程ID转为十六进制 printf "0x%x\n" 28760 4.jstack工具跟踪堆栈定位代码 jstack 70688 | grep 0x7058 -A 10
阅读更多...
尺度和位置敏感的红外小目标检测

尺度和位置敏感的红外小目标检测

Infrared Small Target Detection with Scale and Location Sensitivity 在本文中&#xff0c;着重于以更有效的损失和更简单的模型结构来提升检测性能。 问题一 红外小目标检测&#xff08;IRSTD&#xff09;一直由基于深度学习的方法主导。然而&#xff0c;这些方法主要集中…
阅读更多...
python-春游

python-春游

[题目描述] 老师带领同学们春游。已知班上有 N 位同学&#xff0c;每位同学有从 0 到 N−1 的唯一编号。到了集合时间&#xff0c;老师确认是否所有同学都到达了集合地点&#xff0c;就让同学们报出自己的编号。到达的同学都会报出自己的编号&#xff0c;不会报出别人的编号&am…
阅读更多...
单链表应用

单链表应用

基于单链表实现通讯录项目 //Contact.c #define _CRT_SECURE_NO_WARNINGS 1 #include"contact.h" #include"list.h"//初始化通讯录 void InitContact(contact** con) {con NULL;} //添加通讯录数据 void AddContact(contact** con) {PeoInfo info;printf…
阅读更多...
无主灯设计：吊顶之问与光影艺术的探索

无主灯设计：吊顶之问与光影艺术的探索

在现代家居设计中&#xff0c;照明不仅仅是为了满足基本的照明需求&#xff0c;更是一种艺术和情感的表达。随着无主灯设计越来越受到人们的青睐&#xff0c;许多业主开始考虑一个问题&#xff1a;进行无主灯设计时&#xff0c;是否一定需要吊顶呢&#xff1f;本文将深入探讨这…
阅读更多...
2017年系统架构师案例分析试题五

2017年系统架构师案例分析试题五

目录 案例 【题目】 【问题 1】(5 分) 【问题 2】(16 分) 【问题 3】(4 分) 【答案】 【问题 1】解析 【问题 2】解析 【问题 3】答案 相关推荐 案例 阅读以下关于 Web 系统架构设计的叙述&#xff0c;在答题纸上回答问题 1 至问题 3。 【题目】 某电子商务企业因发…
阅读更多...
小波神经网络的时间序列的短时交通流量预测

小波神经网络的时间序列的短时交通流量预测

小波神经网络的时间序列的短时交通流量预测 通过小波分析进行负荷序列分 解, 获得不同频率负荷分量规律 ; 由粒子群算法进行粒子群适应度排序 , 提升算法收敛速度和收敛能力 ; 为避免算法陷入局部 收敛性, 引入混沌理论来增强全局搜索能力 。 预测结果
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023