递归实现指数型枚举

已于 2023-03-27 10:45:34 修改
阅读量207 收藏
点赞数
分类专栏： java 蓝桥杯 文章标签： java 蓝桥杯
于 2023-03-20 13:53:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RGHLY21/article/details/129663465
版权

普通方法：

引例：如果题目不要求输出方案必须升序

填坑，从填1个坑到填n个坑。
坑可以随便填，比如第1个坑选了2之后，第2个坑可以填1（非升序），也可以填3（升序）

代码：

import java.io.*;
import java.math.BigInteger;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

public class Main
{
    static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    static int N = 100010;
    static int num[] = new int[N];
    static boolean state[] = new boolean[N];

    static int n;

    static void dfs(int pos,int tar)
    {
        if(pos == tar + 1)
        {
            for(int i = 1 ; i <= tar ; i ++)  pw.print(num[i] + " ");
            pw.println();
            return;
        }

        for(int i = 1 ; i <= n ; i ++)
        {
            if(!state[i])
            {
                num[pos] = i;
                state[i] = true;
                dfs(pos + 1, tar);
                num[pos] = 0;
                state[i] = false;
            }
        }
    }

    public static void main(String[] args) throws NumberFormatException, IOException
    {
        n = rd.nextInt();
        pw.println(); // 不取
        for(int i = 1 ; i <= n ; i ++)  dfs(1,i);
        pw.flush();
    }
}

class rd
{
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer tokenizer = new StringTokenizer("");

    static String nextLine() throws IOException { return reader.readLine(); }
    static String next() throws IOException
    {
        while(!tokenizer.hasMoreTokens())  tokenizer = new StringTokenizer(reader.readLine());
        return tokenizer.nextToken();
    }
    static int nextInt() throws IOException { return Integer.parseInt(next()); }
    static double nextDouble() throws IOException { return Double.parseDouble(next()); }
    static long nextLong() throws IOException { return Long.parseLong(next()); }
    static BigInteger nextBigInteger() throws IOException
    {
        BigInteger d = new BigInteger(rd.nextLine());
        return d;
    }
}

class math
{
    int gcd(int a,int b)
    {
        if(b == 0)  return a;
        else return gcd(b,a % b);
    }

    int lcm(int a,int b)
    {
        return a * b / gcd(a, b);
    }

    // 求n的所有约数
    List get_factor(int n)
    {
        List<Long> a = new ArrayList<>();
        for(long i = 1; i <= Math.sqrt(n) ; i ++)
        {
            if(n % i == 0)
            {
                a.add(i);
                if(i != n / i)  a.add(n / i);  // // 避免一下的情况：x = 16时，i = 4 ，x / i = 4的情况，这样会加入两种情况  ^-^复杂度能减少多少是多少
            }
        }

        // 相同因子去重，这个方法，完美
        a = a.stream().distinct().collect(Collectors.toList());

        // 对因子排序（升序）
        Collections.sort(a);

        return a;
    }

    // 判断是否是质数
    boolean check_isPrime(int n)
    {
        if(n < 2) return false;
        for(int i = 2 ; i <= n / i; i ++)  if (n % i == 0) return false;
        return true;
    }
}

class PII implements Comparable<PII>
{
    int x,y;
    public PII(int x ,int y)
    {
        this.x = x;
        this.y = y;
    }
    public int compareTo(PII a)
    {
        if(this.x-a.x != 0)
            return this.x-a.x;  //按x升序排序
        else return this.y-a.y;  //如果x相同，按y升序排序
    }
}

class Edge
{
    int a,b,c;
    public Edge(int a ,int b, int c)
    {
        this.a = a;
        this.b = b;
        this.c = c;
    }
}

但是，题目要求输出所有升序方案

依旧是填坑，从填1个坑到填n个坑。
和上面不同的是，上面是第1个坑选了2之后，第2个坑还可以从2之前的数开始填坑，现在是第1个坑选了2之后，第2个坑只能从大于2的数里选了。
即，当前的坑pos处填了num，则填下一个坑pos+1时，只能从大于num的数里选择填坑。

解决办法：dfs里加一个start，选数的时候，只能从start之后的数里面选择

总结：dfs需要四个变量记录当前状态：
当前位于的坑pos，当前可以选的最小数字start，当前的目标总坑数tar，当前已经填的坑数组num[]。

题目AC代码：

import java.io.*;
import java.math.BigInteger;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

public class Main
{
    static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    static int N = 100010;
    static int num[] = new int[N];
    static boolean used[] = new boolean[N]; //判断数字有没有用过

    static int n;

    static void dfs(int pos, int startindex ,int num_size)
    {
        if(pos == num_size + 1)
        {
            for(int i = 1 ; i <= num_size ; i ++)  pw.print(num[i] + " ");
            pw.println();
            return;
        }

        // 枚举pos位置可以填哪些数
        for(int i = startindex ; i <= n ; i ++)
        {
            if(!used[i])
            {
                num[pos] = i; // pos位置填i
                used[i] = true; // i标记为已使用过
                dfs(pos + 1, i + 1, num_size); // 进入下一层
                num[pos] = 0;
                used[i] = false;
            }
        }
    }

    public static void main(String[] args) throws NumberFormatException, IOException
    {
        n = rd.nextInt();
        pw.println(); // 不取
        // 枚举每一个要选好数的数组大小
        for(int i = 1 ; i <= n ; i ++)  dfs(1,1,i);
        pw.flush();
    }
}

class rd
{
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer tokenizer = new StringTokenizer("");

    static String nextLine() throws IOException { return reader.readLine(); }
    static String next() throws IOException
    {
        while(!tokenizer.hasMoreTokens())  tokenizer = new StringTokenizer(reader.readLine());
        return tokenizer.nextToken();
    }
    static int nextInt() throws IOException { return Integer.parseInt(next()); }
    static double nextDouble() throws IOException { return Double.parseDouble(next()); }
    static long nextLong() throws IOException { return Long.parseLong(next()); }
    static BigInteger nextBigInteger() throws IOException
    {
        BigInteger d = new BigInteger(rd.nextLine());
        return d;
    }
}

class math
{
    int gcd(int a,int b)
    {
        if(b == 0)  return a;
        else return gcd(b,a % b);
    }

    int lcm(int a,int b)
    {
        return a * b / gcd(a, b);
    }

    // 求n的所有约数
    List get_factor(int n)
    {
        List<Long> a = new ArrayList<>();
        for(long i = 1; i <= Math.sqrt(n) ; i ++)
        {
            if(n % i == 0)
            {
                a.add(i);
                if(i != n / i)  a.add(n / i);  // // 避免一下的情况：x = 16时，i = 4 ，x / i = 4的情况，这样会加入两种情况  ^-^复杂度能减少多少是多少
            }
        }

        // 相同因子去重，这个方法，完美
        a = a.stream().distinct().collect(Collectors.toList());

        // 对因子排序（升序）
        Collections.sort(a);

        return a;
    }

    // 判断是否是质数
    boolean check_isPrime(int n)
    {
        if(n < 2) return false;
        for(int i = 2 ; i <= n / i; i ++)  if (n % i == 0) return false;
        return true;
    }
}

class PII implements Comparable<PII>
{
    int x,y;
    public PII(int x ,int y)
    {
        this.x = x;
        this.y = y;
    }
    public int compareTo(PII a)
    {
        if(this.x-a.x != 0)
            return this.x-a.x;  //按x升序排序
        else return this.y-a.y;  //如果x相同，按y升序排序
    }
}

class Edge
{
    int a,b,c;
    public Edge(int a ,int b, int c)
    {
        this.a = a;
        this.b = b;
        this.c = c;
    }
}

y总的思路：

枚举每个位置，看看该位置填不填数，填的话填哪些数字

AC代码：（自己写的！！！）
 

import java.io.*;
import java.math.BigInteger;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

public class Main
{
    static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    static int N = 100010;
    static List<Integer> num = new LinkedList<>();
    static boolean state[] = new boolean[N];
    static boolean used[] = new boolean[N];

    static int n;

    // dfs存的状态：当前第pos位置
    static void dfs(int pos)
    {
        if(pos == n + 1)
        {
            for(int i = 1 ; i <= n ; i ++)   if(state[i]) pw.print(i + " ");  // state[i]为true，即该位置选了，需要输出
            pw.println();
            return;
        }

        // pos位置不选
        state[pos] = false;
        dfs(pos + 1);
        state[pos] = true;


        // pos位置选
        state[pos] = true;
        dfs(pos + 1);
        state[pos] = false;
    }

    public static void main(String[] args) throws NumberFormatException, IOException
    {
        n = rd.nextInt();

        dfs(1);
        pw.flush();
    }
}

class rd
{
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer tokenizer = new StringTokenizer("");

    static String nextLine() throws IOException { return reader.readLine(); }
    static String next() throws IOException
    {
        while(!tokenizer.hasMoreTokens())  tokenizer = new StringTokenizer(reader.readLine());
        return tokenizer.nextToken();
    }
    static int nextInt() throws IOException { return Integer.parseInt(next()); }
    static double nextDouble() throws IOException { return Double.parseDouble(next()); }
    static long nextLong() throws IOException { return Long.parseLong(next()); }
    static BigInteger nextBigInteger() throws IOException
    {
        BigInteger d = new BigInteger(rd.nextLine());
        return d;
    }
}

class math
{
    int gcd(int a,int b)
    {
        if(b == 0)  return a;
        else return gcd(b,a % b);
    }

    int lcm(int a,int b)
    {
        return a * b / gcd(a, b);
    }

    // 求n的所有约数
    List get_factor(int n)
    {
        List<Long> a = new ArrayList<>();
        for(long i = 1; i <= Math.sqrt(n) ; i ++)
        {
            if(n % i == 0)
            {
                a.add(i);
                if(i != n / i)  a.add(n / i);  // // 避免一下的情况：x = 16时，i = 4 ，x / i = 4的情况，这样会加入两种情况  ^-^复杂度能减少多少是多少
            }
        }

        // 相同因子去重，这个方法，完美
        a = a.stream().distinct().collect(Collectors.toList());

        // 对因子排序（升序）
        Collections.sort(a);

        return a;
    }

    // 判断是否是质数
    boolean check_isPrime(int n)
    {
        if(n < 2) return false;
        for(int i = 2 ; i <= n / i; i ++)  if (n % i == 0) return false;
        return true;
    }
}

class PII implements Comparable<PII>
{
    int x,y;
    public PII(int x ,int y)
    {
        this.x = x;
        this.y = y;
    }
    public int compareTo(PII a)
    {
        if(this.x-a.x != 0)
            return this.x-a.x;  //按x升序排序
        else return this.y-a.y;  //如果x相同，按y升序排序
    }
}

class Edge
{
    int a,b,c;
    public Edge(int a ,int b, int c)
    {
        this.a = a;
        this.b = b;
        this.c = c;
    }
}

21RGHLY
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
船长 海盗oj235 递归实现指数枚举
07-01
c语言代码
易语言递归实现目录枚举所有子目录
06-03
@901。Tags：易语言递归目录枚举。
递归实现指数型枚举 .md
11-17
递归实现指数型枚举 .md
AcWing蓝桥杯辅导课：第一讲递推与递归
weixin_51624761的博客
02-24 622
AcWing蓝桥杯辅导课第一讲 递推与递归
AcWing蓝桥杯第一讲递归与递推总结（Java）
北比臼的博客
03-03 739
目录高效率输入输出输入输出AcWing 92. 递归实现指数型枚举思路 高效率输入输出 输入 import java.io.*; import java.util.Scanner; BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); Scanner sc = new Scanner(new BufferedReader(new InputStreamReader(System.in))); StreamToke
【算法练习】日常刷题记录
Mxeron的博客
02-20 299
一、递归与递推 递归实现指数型枚举 import java.util.*; public class Main { static int n; static LinkedList<Integer> tmp = new LinkedList<>(); public static void main(String[] args) { Scanner scan = new Scanner(System.in); n = scan.
Java蓝桥杯——递归实现指数型枚举
m0_50388933的博客
03-22 773
问题描述： 输入N，在1~N之间，以不同方案取数 输出格式： 每行输出一种方案。 同一行内的数必须升序排列，相邻两个数用恰好11个空格隔开。 对于没有选任何数的方案，输出空行。 本题有自定义校验器（SPJ），各行（不同方案）之间的顺序任意。 问题分析： 具体代码： package easy; import java.util.Scanner; public class Number_n { public static boolean[] a = new boole...
92. 递归实现指数型枚举
qq_45895217的博客
12-23 645
92. 递归实现指数型枚举 全排列 首先回忆一下全排列。 在不同的位置放1~n的数字。需要用到回溯，因为后面的位置还可能写前面的数字。 pos是不同的位置，当到n+1的时候说明前面n个位置的数字都已经放好了。所以输出。 #include <iostream> using namespace std; const int N = 1e3; int n; int vis[N]; int a[N]; void dfs(int pos) { if(pos == n+1) {
19071 递归实现指数型枚举
weixin_63551790的博客
04-10 512
Description 递归实现指数型枚举是一种常用的DFS算法，复杂度是2^n，只能在n比较小的时候使用。 一般用于：从 1∼n 这 n 个整数中随机选取（或者有某些规则限制）任意多个，输出所有可能的选择方案。 其实背包问题也可以用这种方法解决，只是复杂度会比较高...... 一个旅行者有一个最多能装 M 公斤的背包，现在有 n 件物品，它们的重量分别是W1，W2，...,Wn，旅行者最多能装多少重量。 本题目题面： 给你N个整数，从中选取任意多个（至少选择一个），输出所有可能的选择方案， 无需输
Acwing---92.递归实现指数型枚举
qq_51251599的博客
12-24 224
递归 —DFS—顺序从 1-n 依次考虑每个数 选 或 不选；
递归实现排列型枚举.md
11-17
递归实现排列型枚举.md
递归实现组合型枚举.md
11-17
递归实现组合型枚举.md
android高斯模糊填充imageview背景
cf8833的博客
05-21 257
说明：最近碰到一个需求，安卓app显示在线的url图片，然后imageview没占满的部分，使用该图片的模糊背景填充。
分布式锁2-Zookeeper分布式锁实战
qq_43676797的博客
05-19 368
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
java学习和项目总结
2301_79390585的博客
05-24 193
JRE：JRE是Java 运行时环境，主要包括了两个运行需要的组件：JVM 和 Java 核心类库，如果不进行java开发只想运行就可以只下载JRE。而Java语言，它的代码会先通过javac编译成字节码，再通过jvm将字节码转换成机器码（0和1）执行，即解释运行和编译运行配合使用，所以是混合型。在程序运行之前，通过编译器将源程序编译成机器码可运行的二进制，以后执行这个程序时，就不用再进行编译了。JVM：JVM是java进行编译的虚拟机，是Java 能够跨平台运行的核心。特点：执行速度慢、效率低；
微信小程序uniapp+django洗脚按摩足浴城消费系统springboot
最新发布
QQ1304979694的博客
05-24 294
Python语言官方规范访问数据库的统一接口规范(Python DB-API)，防止在使用不同数据库时，由于底层数据库技术不同造成接口程序紊乱的问题。（3）项目初期开发，美工设计，前端实现，开发信息系统的用户功能的实现，完善界面排版，实现信息提取发送等一系列功能。项目系统最后阶段的修改及最终测试运行。当然，在研究过程中也可以直接调查，对调查搜集到的资料进行综合分析、比较，调查法是科学研究中普遍的研究方法。（5）系统测试：对设计好的程序进行最终调试，通过调试发现存在的问题并解决，从而达到完善系统的目的。
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 792
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Solon 的 InjectGather 在 AppContext 里起到了什么作用？
Itmastergo的博客
05-20 790
Solon是一款轻量级的Java开发框架，其设计理念简单且易于使用，主要应用于微服务和现代化的Java应用开发。Solon框架的核心目标是提供一个高效且简洁的开发环境，使开发者能够快速构建和部署应用程序。在Solon框架中，AppContext是核心上下文，它管理着整个应用程序的生命周期，包括bean的注册、依赖注入、事件管理等。AppContext是一个应用程序的核心容器，类似于Spring中的。Bean管理：负责注册和管理应用程序中的所有bean。依赖注入：提供自动化的依赖注入机制。事件管理。
pta7-5 h0093-递归实现组合型枚举
05-16
题目描述 输入两个正整数 n≤m≤10，输出从 n 个不同元素中取出 m 个元素组成的组合，按照字典序从小到大输出所有组合。 输入格式 两个正整数 n，m。 输出格式 每行输出一种组合。 ...C++ 代码

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

21RGHLY

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值