精华内容
下载资源
问答
  • 队列求素数环问题

    2017-07-29 19:48:00
    素数环:n个自然数排成环形,使得每相邻两个数之和为素数,构成素数环。 为了巩固队列,做了一下,书上的算法不全,没有判断首元素与最后一个元素之和是否为素数,不能生成多种素数环。 看了博客,粘贴代码,发现...

    素数环:n个自然数排成环形,使得每相邻两个数之和为素数,构成素数环。

    为了巩固队列,做了一下,书上的算法不全,没有判断首元素与最后一个元素之和是否为素数,不能生成多种素数环。

    看了博客,粘贴代码,发现如果要完全解决,用到队列的知识(不用回溯解决),其中有递归算法,可能要遍历时用到“二叉树深度遍历”,先放上代码,学好二叉树的知识之后,再来理解。

     1 public interface Queue<T> { // 队列接口
     2     public abstract boolean isEmpty();
     3 
     4     public abstract boolean add(T x);
     5 
     6     public abstract T peek();
     7 
     8     public abstract T poll();
     9 
    10 }

     

      1 public class LinkedQueue<T> implements Queue<T> {
      2     private Node<T> front, rear;
      3 
      4     public LinkedQueue() {
      5         this.front = this.rear = null;// 构造空队列
      6     }
      7 
      8     public boolean isEmpty() {
      9         return this.front == null && this.rear == null;
     10     }
     11 
     12     public boolean add(T x) {
     13         if (x == null)
     14             return false;
     15         Node<T> q = new Node<T>(x, null);
     16         if (this.front == null)
     17             this.front = q;
     18         else
     19             this.rear.next = q;
     20         this.rear = q;
     21         return true;
     22     }
     23 
     24     public T peek() {
     25         return this.isEmpty() ? null : this.front.data;
     26     }
     27 
     28     public T poll() {
     29         if (isEmpty())
     30             return null;
     31         T x = this.front.data;
     32         this.front = this.front.next;
     33         if (this.front == null)
     34             this.rear = null;
     35         return x;
     36     }
     37 
     38 }
     39 // 素数环类
     40 public class PrimeRing {
     41     public boolean isPrime(int number) { // 判断一个数是否为素数
     42         if (number == 2)
     43             return true;
     44         for (int i = 2; i < Math.sqrt(number) + 1; i++) {
     45             if (number % i == 0)
     46                 return false;
     47         }
     48         return true;
     49     }
     50 
     51     public SeqList<Integer> insertRing(SeqList<Integer> L,
     52             LinkedQueue<Integer> Q, int index, int total) {
     53         // 从第index个数开始进行遍历
     54         int count = 0; // 记录遍历队列中数据元素的个数
     55         while (!Q.isEmpty() && count <= total - index) {// 每个元素都遍历一遍
     56 
     57             int p = (Integer) Q.poll();// 队列出队
     58             int q = (Integer) L.get(L.size() - 1);
     59 
     60             if (index == total) { // 队尾元素
     61                 if (isPrime(p + q) && isPrime(p + 1)) {
     62                     L.insert(p); // 插入到顺序表表尾
     63                     return L;
     64                 } else {
     65                     Q.add(p);
     66                 }
     67             } else if (isPrime(p + q)) {// 如果未遍历到最后一个元素
     68                 L.insert(p);
     69                 if (insertRing(L, Q, index + 1, total) != null) {// 递归
     70                     return L;
     71                 }
     72                 L.remove(L.size() - 1);// 移除顺序表表尾数据元素
     73                 Q.add(p);
     74             } else {
     75                 Q.add(p);
     76             }
     77             ++count;
     78         }
     79         return null;
     80     }
     81 
     82     public SeqList<Integer> makePrimeRing(int n) {
     83         SeqList<Integer> L = new SeqList<Integer>(n);
     84         L.insert(1); // 初始化顺序表的首结点为1
     85         LinkedQueue<Integer> Q = new LinkedQueue<Integer>();
     86         for (int i = 2; i <= n; i++) {
     87             Q.add(i);// 初始化队列
     88         }
     89         return insertRing(L, Q, 2, n);
     90 
     91     }
     92 
     93     public static void main(String[] args) {
     94         PrimeRing pr = new PrimeRing();
     95         SeqList<Integer> L = pr.makePrimeRing(10);
     96         for (int i = 0; i < L.size(); i++) {
     97             System.out.print(L.get(i) + " ");
     98         }
     99 
    100     }
    101 
    102 }

     

    转载于:https://www.cnblogs.com/wang118/p/7257271.html

    展开全文
  • 题意:给定一个整数,其满足起点为1的素数环,,并把所有的素数环输出来。 #include <iostream> #include<cstdio> using namespace std; int ans[22];//保存环中每一个被放入的数 bool hash1...

    题意:给定一个整数,求其满足起点为1的素数环,,并把所有的素数环输出来。

    #include <iostream>
    #include<cstdio>
    
    using namespace std;
    int ans[22];//保存环中每一个被放入的数
    bool hash1[22];//标记之前已经被放入环中的数
    int n;
    int prime[]={2,3,5,7,11,13,17,19,23,29,31,37,41};//素数
    
    bool judge(int x){//判断一个数是否是素数
        for(int i=0;i<13;i++){
            if(prime[i]==x)
                return true;
        }
        return false;
    }
    
    void check(){//检查输出由回溯法枚举得到的解
        if(judge(ans[n]+ans[1])==false)
            return;
        for(int i=1;i<=n;i++){
            if(i!=1)
                printf(" ");
            printf("%d",ans[i]);
        }
        printf("\n");
    }
    
    void DFS(int num){
        if(num>1)
            if(judge(ans[num]+ans[num-1])==false)//最后两个数字和是否为素数
            return;
        if(num==n){//若已经放入了n个数
            check();//检查输出
            return;//返回,继续枚举下一组解
        }
        for(int i=2;i<=n;i++){//放入一个数
            if(hash1[i]==false){//若i还没放入环中
                hash1[i]=true;//标记为已经使用
                ans[num+1]=i;//将这个数字放入ans数组中
                DFS(num+1);//继续尝试放入下一个数
                hash1[i]=false;//重新标记为未使用
            }
        }
    }
    int main()
    {
        int cas=0;
        while(scanf("%d",&n)!=EOF){
            cas++;
            for(int i=0;i<22;i++)
                hash1[i]=false;//初始化标记所有数字为未被使用
            ans[1]=1;//第一个数恒定为1
            printf("Case %d:\n",cas);
            hash1[1]=true;//标记1为被使用
            DFS(1);//继续尝试放入下一个数字
            printf("\n");
        }
        return 0;
    }

        尝试放入第num+1个数字时,我们依次尝试放入所有在之前位置上未被使用的数字,假设当前x未被使用,将x放入第num+1个位置,标记x为已用,此时环中前num+1个数字全部确认,依次保存在ans[1]到ans[num+1]中,再进行下一个位置的枚举,即递归调用DFS。

        当调用返回时,意味着当前num+1个数字确定为ans[1]到ans[num+1]中的值时对应的所有可行的答案已经全部处理完毕,此时需要改变ans[num+1]的值,从而进行新答案的搜索。

        所以,此时ans[num+1]的值将不再为已经被枚举过的x,而是一个相异于x,同时又未在之前被使用过的新数字。那么对后续数字而言,x是未被使用过的,是可以被放入后序任何一个位置的,所以重新标记x为未使用,供后续数位选择。

     

    转载于:https://www.cnblogs.com/xym4869/p/8623917.html

    展开全文
  • 哈利不仅魔法差,数学也差,只听赫敏说过素数是只能被1和自身整除的数,但赫敏现在不在,他请你帮忙计算有多少种必胜的方法。 Input 第一行是测试数据的组数T(T),接下来是各组测试数据,每组测试数据...

    Problem Description

    魁地奇是巫师世界中最重要的体育运动。每个人都关注着魁地奇。魁地奇是一种高速进行的,危险而又激动人心的运动,比赛中的两支球队骑着飞天扫帚竞争,每场比赛将鬼飞球投入巨大的草地球场两端圆环次数多的一队获胜。
    哈利波特想到了一种必胜的方法,格兰芬多学院里共有N支队(N<=20),每个队已知人数,哈利波特从中挑选K(K<=N)支分队去参加比赛。邓布利多分析后告诉哈利,队伍总人数为素数时,才能必胜!哈利不仅魔法差,数学也差,只听赫敏说过素数是只能被1和自身整除的数,但赫敏现在不在,他请你帮忙计算有多少种必胜的方法。

    Input

    第一行是测试数据的组数T(T<=10),接下来是各组测试数据,每组测试数据先给出N,K,然后是另起一行N个数字,表示N支部队的人数。

    Output

    每组测试数据请输出一个整数,表示方案数。

    Sample Input

    1
    5 2
    2 3 8 9 999
    

    Sample Output

    4
    
    
    
    
    #include <iostream>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <algorithm>
    using namespace std;
    
    
    int count1, k;
    int n;
    const int maxn1 = 100+10, maxn2 = 1000000+100;
    int ans[maxn2], tot;
    int a[maxn1];
    bool Isprime[maxn2];
    void getPrime()
    {
        tot = 0;
        memset(Isprime,true,sizeof(Isprime));
        for(int i = 2 ;i <= maxn2; i++)
        {
            if(Isprime[i])
            {
                tot++;
                ans[tot] = i;
            }
            for(int j = 1; ((j <= tot) && (i*ans[j] <= maxn2)); j++)
            {
                Isprime[i*ans[j]] = false;
                if(i%ans[j] == 0)break;
            }
        }
    }
    void dfs(int pos,int kk, int sum)
    {
        if(kk > k)
        {
            //printf("%d\n",sum);
            if(Isprime[sum])
                count1++;
            /*for(int i = 1; i <= k; i++)
            {
                printf("%d ",a[i]);
            }
            printf("\n");*/
            return;
        }
        for(int i = pos+1; i <= n; i++)
        {
            dfs(i,kk+1,sum+a[i]); //这意味着第k个数的位置是i;
        }
    }
    int main()
    {
        int T = 0;
        scanf("%d",&T);
        getPrime();
        while(T--)
        {
            scanf("%d%d",&n,&k);
            for(int i = 1; i <= n; i++)
            {
                scanf("%d",&a[i]);
            }
            count1 = 0;
            dfs(0,1,0);
            printf("%d\n",count1);
        }
        return 0;
    }
    
    展开全文
  • 思路: 要求每两个相邻数之和都为素数,那么只要每次递归调用DFS时判断之前两个数之和是否为素数,另外...)求素数。 素数筛法概览: 把从1开始的、某一范围内的正整数从小到大顺序排列, 1不是素数,首先把它筛掉

    Prime Ring Problem


    A ring is compose of n circles as shown in diagram. Put natural number 1, 2, …, n into each circle separately, and the sum of numbers in two adjacent circles should be a prime.

    Note: the number of first circle should always be 1.
    这里写图片描述


    Input
    n (0 < n < 20).

    Output
    The output format is shown as sample below. Each row represents a series of circle numbers in the ring beginning from 1 clockwisely and anticlockwisely. The order of numbers must satisfy the above requirements. Print solutions in lexicographical order.

    You are to write a program that completes above process.

    Print a blank line after each case.


    Sample Input
    6
    8

    Sample Output
    Case 1:
    1 4 3 2 5 6
    1 6 5 2 3 4

    Case 2:
    1 2 3 8 5 6 7 4
    1 2 5 8 3 4 7 6
    1 4 7 6 5 8 3 2
    1 6 7 4 3 8 5 2


    题意

    已知一个数n,将数字1~n围成一个圆环,要求: 相邻两个数之和为素数。
    输出:

    • 数字的方向一致(同顺时针或同逆时针),并保证排列不重复
    • 只有一个数(n==1)时,输出1
    • 输出Case k:(k为数据组数),每一组输出(第一个除外)之前都有一个空行

    思路:


    • 要求每两个相邻数之和都为素数,那么只要每次递归调用DFS时判断之前两个数之和是否为素数,另外注意因为是一个,最后还要判断一下最后一个数和第一个数之和是否为素数。
    • 程序开始时求出一个素数数组,只需求出50以内的素数即可,因为数据<20,最大的素数和为17+19=36。此处用的是素数筛法什么是素数筛法?)求素数。

    素数筛法概览

    • 把从1开始的、某一范围内的正整数从小到大顺序排列, 1不是素数,首先把它筛掉。剩下的数中选择最小的数是素数,然后去掉它的倍数。依次类推,直到筛子为空时结束
    • 例如: 先把n个自然数按次序排列起来。1不是质数,也不是合数,要划去。第二个数2是质数留下来,而把2后面所有能被2整除的数都划去。2后面第一个没划去的数是3,把3留下,再把3后面所有能被3整除的数都划去。3后面第一个没划去的数是5,把5留下,再把5后面所有能被5整除的数都划去。这样一直做下去,就会把不超过N的全部合数都筛掉,留下的就是不超过N的全部质数

    代码示例:

    #include<iostream>
    #include<cstring>
    #include<algorithm>
    #include<cmath>
    #define MAX 51
    using namespace std;
    int prime[MAX];//素数数组 
    bool vis[21]; //访问数组 
    int n;// 个数 
    int ans[21];//解答输出数组 
    void Prime_set()  //筛法求素数 
    {
        //Isprime 0、 IsNotprime 1  
        for(int i = 2; i<=sqrt(MAX) ;++ i)
            if(prime[i] == 0){
                for(int j = 2;i*j<=MAX;++j)
                    prime[i*j] = 1;
            }
        prime[1] = 0,vis[1]=true;//1虽然不是素数,但在此假设为0,将vis[1]设为true即不会遍历到1 
    }
    
    void DFS(int depth)
    {
        if(prime[ans[depth-1]+ans[depth-2]]!=0) return ;  //前两个数之和不是素数退出 
        if(depth==n+1&&prime[ans[depth-1]+ans[1]]!=0) return ; //当选到最后一个数时,第一个数和最后一个数之和不是素数时退出 
    
        if(depth==n+1)  //选到最后一个数,输出 
        {
            for(int i=1;i<=n;i++) 
            {
                if(i==1) cout<<ans[i]; 
                else cout<<" "<<ans[i]; 
            }
                cout<<endl;
        }
    
        for(int i=2;i<=n;i++)   //把1~n按照一定顺序(DFS求得)填入数组ans 
        {
            if(!vis[i]) 
            {
                vis[i]=true;
                ans[depth]=i;
                DFS(depth+1);
                vis[i]=false;
            }
        }
    }
    
    int main(){
        int t=1; 
        Prime_set();
        while(cin>>n)
        {
            cout<<"Case "<<t++<<":"<<endl;
            memset(vis,false,sizeof(vis));
            ans[1] = 1;//1永远是首元素 
            if(n==1) cout<<"1"<<endl;
            else 
                DFS(2);//1永远是首元素,从2开始DFS ;也防止之后depth-2<0 
            cout<<endl;
        }   
        return 0;
    }
    注:
    • Q:1不是素数,为何要prime[1] = 0?
      • A:1虽然不是素数,但在此假设为0。因为之后判断(判断两个相邻素数和的时候)会出现一些问题:
        if(prime[ans[depth-1]+ans[depth-2]]!=0)
        在主函数初始进入DFS(2)时,这一句之中的depth-2等于0,ans[0]不在讨论范围之中,故仍然为0,而ans[1]为1,ans[depth-1]+ans[depth-2]=1,prime[1]如果不等于0的话,将会直接return。
    展开全文
  • 回溯法八皇后问题素数环(Prime Ring Problem) 在递归构造中,生成和检查过程可以有机结合起来,从而减少不必要的枚举,这就是回溯法。当把问题分成若干步骤并递归求解时,如果当前步骤没有合法选择,则函数将返回...
  • hdoj 1016

    2010-04-16 22:44:00
    题目大意:给出n 1……n 组成的素数环 即环内任意两数和为素数。思路:深搜回溯 使用递归~一开始看了别人的代码后自己写了遍 没有对循环内visit[]重新标记~记住记住~ #include using namespace std;bool prime...
  • C++:C++语言入门级基础知识考察点回顾之函数、结构体和类 ...2.1、函数的递归嵌套:求解约瑟夫问题——n只猴子选猴王的问题 2.2、函数的递归应用:递归求和 2.3、函数的递归应用:等差数列求和 2.4、函数的递...
  • 素数环:从1到n这n个数摆成一个环,要求相邻的两个数的和是一个素数。 大佬们应该都接触过这个题,我就不详细说别的了。 本人刚接触递归回溯这个算法,无法理解 我怎么总觉得到了dfs(n,r,cur+1)这一行之后会...
  • 今天继续使用回溯法来解决一个新的题目,跟N后问题还有素数环相似都很简单,都是填空判断递归回溯。 问题介绍:从三个元素的集合【A,B,C】中选取元素生成一个N个字符组成的序列,使得没有两个相邻字的子序列(子...
  • HDU-1016 Prime Ring Problem

    2019-05-21 15:14:24
    搜索 HDU-1016 Prime ...解题思路:DFS 因为所为一个 又要字典序排序 所以第一个数字一定为1 同一级递归确定的数字为同一个位置放的数字 如果递归到n+1位则将n位与1位数字之和相加判断输出 若不是n+1位 则从2开...
  • 6. 素数环问题 7. 迷宫问题 8. *农场灌溉问题(ZOJ2412) 9. *图像的周长(ZOJ1047) 10. *骨牌矩阵 11. *字母转换(ZOJ1003) 12. *踩气球(ZOJ1004) 实验三:搜索 1. Floodfill 2. 电子老鼠闯迷宫 3. 跳马 4. ...
  • 200个经典C程序【源码】

    千次下载 热门讨论 2013-08-08 10:48:40
    175 取符合特定要求的素数 176 统计符合特定条件的数 177 字符串倒置 178 部分排序 179 产品销售记录处理 180 特定要求的字符编码 181 求解三角方程 182 新完全平方数 183 三重回文数 184 奇数方差 185 ...
  • 200个C程序.rar

    2021-05-06 12:46:56
    059 约瑟夫 060 记录个人资料 061 二叉树遍利 062 浮点数转换为字符串 063 汉诺塔问题 064 哈夫曼编码 065 图的深度优先遍利 066 图的广度优先遍利 067 求解最优交通路径 068 八皇后问题 069 骑士巡游 ...
  • 059 约瑟夫 060 记录个人资料 061 二叉树遍利 062 浮点数转换为字符串 063 汉诺塔问题 064 哈夫曼编码 065 图的深度优先遍利 066 图的广度优先遍利 067 求解最优交通路径 068 八皇后问题 069 骑士巡游 ...
  • 175 取符合特定要求的素数 176 统计符合特定条件的数 177 字符串倒置 178 部分排序 179 产品销售记录处理 180 特定要求的字符编码 181 求解三角方程 182 新完全平方数 183 三重回文数 184 奇数方差 185 ...
  • 175 取符合特定要求的素数 176 统计符合特定条件的数 177 字符串倒置 178 部分排序 179 产品销售记录处理 180 特定要求的字符编码 181 求解三角方程 182 新完全平方数 183 三重回文数 ...
  • C语言学习实例220例

    2015-06-16 23:47:59
    175 取符合特定要求的素数 176 统计符合特定条件的数 177 字符串倒置 178 部分排序 179 产品销售记录处理 180 特定要求的字符编码 181 求解三角方程 182 新完全平方数 183 三重回文数 184 奇数方差 185 统计选票 ...
  • C语言实例解析精粹

    2014-03-14 21:57:05
    175 取符合特定要求的素数 176 统计符合特定条件的数 177 字符串倒置 178 部分排序 179 产品销售记录处理 180 特定要求的字符编码 181 求解三角方程 182 新完全平方数 183 三重回文数 184 奇数方差 185 ...
  • 175 取符合特定要求的素数 176 统计符合特定条件的数 177 字符串倒置 178 部分排序 179 产品销售记录处理 180 特定要求的字符编码 181 求解三角方程 182 新完全平方数 183 三重回文数 184 奇数方差 185 ...
  • 175 取符合特定要求的素数 176 统计符合特定条件的数 177 字符串倒置 178 部分排序 179 产品销售记录处理 180 特定要求的字符编码 181 求解三角方程 182 新完全平方数 183 三重回文数 184 奇数方差 185 ...
  • 175 取符合特定要求的素数 176 统计符合特定条件的数 177 字符串倒置 178 部分排序 179 产品销售记录处理 180 特定要求的字符编码 181 求解三角方程 182 新完全平方数 183 三重回文数 184 奇数方差 185 ...
  • C语言程序源代码(大集合).rar

    热门讨论 2010-10-30 19:06:59
    175 取符合特定要求的素数 176 统计符合特定条件的数 177 字符串倒置 178 部分排序 179 产品销售记录处理 180 特定要求的字符编码 181 求解三角方程 182 新完全平方数 183 三重回文数 184 奇数方差 185 ...
  • C语言常用算法

    2012-03-28 10:48:37
    175 取符合特定要求的素数 176 统计符合特定条件的数 177 字符串倒置 178 部分排序 179 产品销售记录处理 180 特定要求的字符编码 181 求解三角方程 182 新完全平方数 183 三重回文数 184 奇数方差 185 ...
  • 059 约瑟夫 060 记录个人资料 061 二叉树遍利 062 浮点数转换为字符串 063 汉诺塔问题 064 哈夫曼编码 065 图的深度优先遍利 066 图的广度优先遍利 067 求解最优交通路径 068 八皇后问题 069 骑士巡游 ...
  • C语言源代码实例.rar

    2009-08-27 20:17:58
    175 取符合特定要求的素数 176 统计符合特定条件的数 177 字符串倒置 178 部分排序 179 产品销售记录处理 180 特定要求的字符编码 181 求解三角方程 182 新完全平方数 183 三重回文数 184 奇数方差 185 ...
  • 059 约瑟夫 060 记录个人资料 061 二叉树遍利 062 浮点数转换为字符串 063 汉诺塔问题 064 哈夫曼编码 065 图的深度优先遍利 066 图的广度优先遍利 067 求解最优交通路径 068 八皇后问题 069 骑士巡游 070 用栈...
  • 175 取符合特定要求的素数 176 统计符合特定条件的数 177 字符串倒置 178 部分排序 179 产品销售记录处理 180 特定要求的字符编码 181 求解三角方程 182 新完全平方数 183 三重回文数 184 奇数方差 185 ...
  • 经典的C程序220案列

    2008-10-26 11:09:36
    175 取符合特定要求的素数 176 统计符合特定条件的数 177 字符串倒置 178 部分排序 179 产品销售记录处理 180 特定要求的字符编码 181 求解三角方程 182 新完全平方数 183 三重回文数 184 奇数方差 185 ...

空空如也

空空如也

1 2 3 4
收藏数 62
精华内容 24
关键字:

递归求素数环