约瑟夫环和一元多项式

洞洞幺#

于 2024-08-31 13:59:20 发布

阅读量1k

点赞数 28

文章标签：数据结构链表算法 c#

本文链接：https://blog.csdn.net/2302_78946488/article/details/141751514

版权

约瑟夫环

一、问题描述

假设有 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。

输出格式:

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

输入样例:

输出样例:

#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.运算的实现

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

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

二、实现步骤

定义链表节点结构

   struct PolyNode {
       int coef; // 系数
       int exp; // 指数
       struct PolyNode* next;
   };

创建多项式输入多项式的项数，然后依次输入每一项的系数和指数，创建链表表示的多项式。

   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;
   }

打印多项式遍历链表，按照系数和指数的格式输出多项式。

   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;
   }

洞洞幺#

关注

28
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
约瑟夫环和一元多项式

假设有 n 个人围成一圈，从第一个人开始报数，报数到 m 的人将被淘汰出圈，然后从下一个人开始继续从 1 报数，如此重复，直到最后只剩下一个人。求最后剩下的这个人的编号。可以使用循环链表来模拟这个过程。1.创建一个包含 n 个节点的循环链表，每个节点代表一个人，节点中存储这个人的编号。2.从第一个节点开始报数，每报到 m，就将对应的节点从链表中删除。3.重复这个过程，直到链表中只剩下一个节点，这个节点所代表的人的编号就是问题的答案。数据元素：数据元素之间的逻辑结构为线性结构。
复制链接

扫一扫