2023/05/08~14 刷题记录

news2024/11/28 9:41:06

A - Plus and Multiply

在这里插入图片描述

题意：在这里插入图片描述

题解：
题目说可以将集合里面的数字 *a 或者 +b 操作，并将新的值放进集合中，首先想到 dfs 暴力求解，但是太暴力了，直接 时间超限 。通过观察我们可以知道，要求 n 是否在集合中，如果在 一定会存在 一个 x1、x2 使得 a(乘x1次) + b(加x2次) == n。为什么不会出现先加上 b 再乘上 a 的情况呢？因为如果你先加上了一个 b，那么后面乘上 a 相当于是 加了 a 个 b。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int t = sc.nextInt();

        while (t-- != 0) {
            long n = sc.nextInt();
            long a = sc.nextInt();
            long b = sc.nextInt();

            boolean k = false;

            if (a == 1) {
                if (n % b == 1 || b == 1) System.out.println("Yes");
                else System.out.println("No");
                continue;
            }

            for (int i = 1; i <= n; i *= a) {
                if ((n - i) % b == 0)
                    k = true;
                if (k)
                    break;
            }

            if (k)
                System.out.println("Yes");
            else
                System.out.println("No");
        }
    }
}

B - Air Conditioner

在这里插入图片描述

题目大意：
在这里插入图片描述

题解：
那么我们可以按顾客到达的顺序来处理。 维护温度可能的区间[L,R]。从顾客i-1到i时，过去的时间d = t - t(i-1)，温度可能的区间[L, R]=[L - d,R＋d]。
又因为要满足第i个顾客的需求，所以我们将这个区间与[l,r;]取交集即可。取交集:[L,R] ∩ [l, ri]=[max(L, li), min(R, ri)]

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int t = sc.nextInt();

        while (t-- != 0) {
            int n = sc.nextInt();
            int m = sc.nextInt();

            ArrayList<Guest> guests = new ArrayList<>(n);
            for (int i = 0; i < n; i++) 
                guests.add(new Guest(sc.nextInt(), sc.nextInt(), sc.nextInt()));
            
            // 根据时间排序
            guests.sort((o1, o2) -> o1.getT() - o2.getT());

            int l = m, r = m, now = 0;
            boolean k = false;
            for (Guest guest : guests) {
                int hh = guest.getH();
                int ll = guest.getL();
                int time = guest.getT();

                int x = time - now;
                now = time;
                l -= x;
                r += x;
                k = true;

                // 取区间最小值。
                // 一个是可以到达的最低和最高温度，一个是为满足客户可以到达的最低最高温度
                l = Math.max(l, ll);
                r = Math.min(r, hh);

                if (l > r) {
                    k = false;
                    break;
                }
            }

            if (k)
                System.out.println("YES");
            else
                System.out.println("NO");
        }
    }
}

class Guest {
    int t, l, h;

    public int getT() {
        return t;
    }

    public void setT(int t) {
        this.t = t;
    }

    public int getL() {
        return l;
    }

    public void setL(int l) {
        this.l = l;
    }

    public int getH() {
        return h;
    }

    public void setH(int h) {
        this.h = h;
    }

    public Guest(int t, int l, int h) {
        this.t = t;
        this.l = l;
        this.h = h;
    }
}

C - Theatre Square

在这里插入图片描述

大致题义：
在这里插入图片描述

题解：
分别求出该广场的长和宽分别需要多长的石板，然后将 长和宽 相乘即可。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();
        int m = sc.nextInt();
        int a = sc.nextInt();
        
        // 求解长和宽，并相乘输出
        System.out.println((long) Math.ceil((double) m / a) * (long) Math.ceil(n / (double) a));
    }
}

D - Bargaining Table

在这里插入图片描述

大致题义：
在这里插入图片描述

题解：
使用 二维前缀和 取计算矩阵周长是否全是 ‘0‘，也就是是否存在 ‘1’。如果不存在 ‘1’，则尝试作为答案，判断大小。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        n = sc.nextInt();
        m = sc.nextInt();
        sc.nextLine();

        // 输入地图，并计算 二维前缀和
        int[][] map = new int[n + 1][m + 1];
        sum = new int[n + 1][m + 1];
        for (int i = 1; i <= n; i++) {
            String s = sc.nextLine();

            // 计算 二维前缀和
            int temp = 0;
            for (int j = 1; j <= m; j++) {
                map[i][j] = Integer.parseInt(String.valueOf(s.charAt(j - 1)));
                temp += map[i][j];
                sum[i][j] = sum[i - 1][j] + temp;
            }
        }

        // 全遍历 并剪枝
        int ans = 0;
        for (int x1 = 1; x1 <= n; x1++)
            for (int y1 = 1; y1 <= m; y1++)
                if (map[x1][y1] == 0) 
                    for (int x2 = x1; x2 <= n; x2++)
                        for (int y2 = y1; y2 <= m; y2++)
                            if (fun(x1, y1, x2, y2) == 0)
                                ans = Math.max(ans, ((x2 - x1 + 1) + (y2 - y1 + 1)) * 2);

        System.out.println(ans);
    }

    static int n, m;
    //存储 二维前缀和
    static int[][] sum;

    // 求 (x1, y1) 到 (x2, y2) 之间的二维前缀和
    static int fun(int x1, int y1, int x2, int y2) {
        return sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][y1 - 1] + sum[x1 - 1][y1 - 1];
    }
}

E - Coins

在这里插入图片描述

大致题义：
在这里插入图片描述

题解：
求解出素数，因为一个合数就是由很多素数组成，从小到大 一个一个 除尽 依次输出即可。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();
        System.out.print(n + " ");

        ArrayList<Integer> primeNumbers = getPrimeNumbers(n);

        // 遍历每一个素数， 因为合数就是由若干个素数组成，让这个数除每个素数
        for (Integer primeNumber : primeNumbers) {
            while (n % primeNumber == 0) {
                n /= primeNumber;
                System.out.print(n + " ");

                if (n == 1)
                    break;
            }
        }
    }

    // 求素数，埃筛
    private static ArrayList<Integer> getPrimeNumbers(int n) {
        ArrayList<Integer> primeNumbers = new ArrayList<>();

        int len = n + 1;

        // 初始化素数
        int[] temp = new int[len];
        temp[0] = 1;
        temp[1] = 1;

        for (int i = 2; i < len; i++) {
            if (temp[i] == 0) {
                for (int j = i * 2; j < len; j += i)
                    temp[j] = 1;

                primeNumbers.add(i);
            }
        }
        return primeNumbers;
    }
}

F - Alice, Bob and Chocolate

在这里插入图片描述

大致题义：
在这里插入图片描述

题解：
使用 双指针 循环遍历，L 代表 左指针 指向左下标，R 代表 右指针 指向右下标

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();

        int[] a = new int[n];
        for (int i = 0; i < n; i++)
            a[i] = sc.nextInt();

        // 使用 双指针 指向数组，依次遍历
        int l = 0, r = n - 1;
        while (l + 1 < r) {
            if (a[l] < a[r]) {
                a[r] -= a[l];
                l++;
            } else if (a[l] > a[r]) {
                a[l] -= a[r];
                r--;
            } else {
                l++;
                r--;
            }
        }

        // 因为 下标 比 序号 小 1，所以下标需要加一 变成个数
        l++;
        // 同时，因为他们可能同时到达同一个 “巧克力棒”，而女士优先
        // 故取 l 作为 Alice 答案，n-l 作为 Bob 答案
        System.out.println(l + " " + (n - l));
    }
}

H - Sale

在这里插入图片描述

大致题义：
在这里插入图片描述

题解：
题目就是要求我们求出 在 m 个电器的范围内，最大可以 “赚” 多少钱，也就是看 电视机 的负数价格有多少。
很显然，快排，然后遍历。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();
        int m = sc.nextInt();

        ArrayList<Integer> a = new ArrayList<>();
        for (int i = 0; i < n; i++)
            a.add(sc.nextInt());

        // 快排
        Collections.sort(a);

        // 遍历 至多 m 个，求负数之和为多少
        int ans = 0;
        for (int i = 0; i < m; i++)
            if (a.get(i) < 0)
                ans -= a.get(i);
            else
                break;

        System.out.println(ans);
    }
}

I - Laptops

在这里插入图片描述

大致题义：
在这里插入图片描述

题解：
使用快排对 笔记本的价格 进行排序，然后再依次遍历，判断 每一台计算机 是否 比前一台计算机质量高。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();

        ArrayList<Goods> goods = new ArrayList<Goods>();
        for (int i = 0; i < n; i++)
            goods.add(new Goods(sc.nextInt(), sc.nextInt()));

        // 根据 笔记本 的价格 快速排序
        goods.sort((o1, o2) -> o1.a - o2.a);

        boolean k = false;
        // 如果有一台 笔记本 在价值低的情况下，反而质量更好 就标记
        // ps：在这里为什么不要 把每台计算机前面的所有计算机都比较一下质量呢？
        // 因为 这个质量一定是呈现递增的趋势，不然 循环已经终止了(也就是说，前一台计算机一定是 前面所有计算机中 质量最好的)
        for (int i = 1; i < goods.size(); i++) {
            if (goods.get(i - 1).b > goods.get(i).b) {
                k = true;
                break;
            }
        }

        if (k)
            System.out.println("Happy Alex");
        else
            System.out.println("Poor Alex");
    }
}

class Goods {
    int a, b;

    Goods(int a, int b) {
        this.a = a;
        this.b = b;
    }
}

J - Trust Nobody

在这里插入图片描述

题目大意：
在这里插入图片描述

题解：
注意题目中所说的 “至少”。
通过分析题目，我们了解到了，假设一组数据中答案是 5，则 说大于 5 的人则在说假话。
因此，我们使用桶排 统计所有人说的 x 的次数，使用 a[x] 表示。
再遍历的过程中 使用前缀和优化循环次数。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int t = sc.nextInt();

        while (t-- != 0) {
            int n = sc.nextInt(), x;

            // 桶排 统计所有人说的 x 的次数，使用 a[x] 表示。
            int[] a = new int[n];
            for (int i = 0; i < n; i++) {
                x = sc.nextInt();
                // 如果 大于等于 n，则肯定在说谎，不必统计
                if (x < n)
                    a[x]++;
            }

            // 前缀和 统计结果，如果没有答案输出 -1
            int ans = -1, sum = 0;
            for (int i = 0; i < n; i++) {
                sum += a[i];

                if (i == n - sum) {
                    ans = i;
                    break;
                }
            }

            System.out.println(ans);
        }
    }
}

K - Dreaming of Freedom

在这里插入图片描述

题目大意：
在这里插入图片描述
题解：
模拟题。
注意剪枝，时间复杂度。
如果 “程序员” 的个数 n 是一个合数，也就是可以被素数整除的话（同时这个素数得 小于 题目的个数 m）则可以一直选下去，没有尽头。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int t = sc.nextInt(), n, m;

        boolean k;
        while (t-- != 0) {
            n = sc.nextInt();
            m = sc.nextInt();

            if (n == 1 || m == 1) {
                System.out.println("YES");
                continue;
            } else if (m >= n) {
                System.out.println("NO");
                continue;
            }

            // 注意剪枝 i <= n / i
            k = false;
            for (int i = 2; i <= m && i <= n / i; i++) {
                if (n % i == 0) {
                    k = true;
                    break;
                }
            }

            if (!k)
                System.out.println("YES");
            else
                System.out.println("NO");
        }
    }
}

L - Lunatic Never Content

在这里插入图片描述

题目大意：
在这里插入图片描述

题解：
这道题不难，但解决前需要知道几个知识点：
在这里插入图片描述
因此，这道题变成了找所有对数差的最大公因数。

除此之外，x 可以为无限大的情况就是数组 a 本身是回文的情况，需要特判输出 0。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int t = sc.nextInt();

        while (t-- != 0) {
            int n = sc.nextInt();

            ArrayList<Integer> a = new ArrayList<>(n);
            for (int i = 0; i < n; i++)
                a.add(sc.nextInt());
            
            Set<Integer> ans = new HashSet<>(n);
            for (int i = 0; i < n / 2; i++)
                ans.add(Math.abs(a.get(i) - a.get(n - i - 1)));
            
            // 如果 都是 0 说明 这个本身就是一个回文数，可以被无限大除 输出 0
            ans.remove(0);
            if (ans.size() > 0)
                System.out.println(fun(ans));
            else
                System.out.println(0);
        }
    }

    // 求解一个集合中所有数的 最小公约数
    static int fun(Set<Integer> ans) {
        int result = ans.iterator().next();

        for (Integer an : ans) {
            int min = Math.min(result, an);

            while (result % min != 0 || an % min != 0)
                min--;

            result = min;
        }

        return result;
    }
}

M - Running Miles

在这里插入图片描述

题目大意：
在这里插入图片描述

题解：
两个指针指向 左右最合适的边界点。
遍历每个点寻找答案，把每个点（去首尾）当作为中间点，加上 左右边界 最合适的点 求解答案

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int t = sc.nextInt();

        while (t-- != 0) {
            int n = sc.nextInt();

            ArrayList<Integer> a = new ArrayList<>(n);
            for (int i = 0; i < n; i++)
                a.add(sc.nextInt());

            // 求解 只考虑 后面 i 个元素时，r 取哪个值最合适，存储哪个值的下标
            int[] last = new int[n];
            last[n - 1] = n - 1;
            for (int i = 1; i < n; i++)
                last[n - 1 - i] = a.get(last[n - i]) - last[n - i] > a.get(n - i) - (n - i) ? last[n - i] : n - i;

            // 两个指针指向 左右最合适的边界点。
            int l = 0, r, ans = 0;
            // 遍历每个点寻找答案，把每个点（去首尾）作为中间点，加上 左右边界 最合适的点 求解答案
            for (int i = 1; i < a.size() - 1; i++) {
                r = last[i];

                ans = Math.max(ans, a.get(l) + a.get(i) + a.get(r) + l - r);

                if (a.get(l) + l - i <= a.get(i))
                    l = i;
            }

            System.out.println(ans);
        }
    }
}

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

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

相关文章

前端模块化

前端模块化

什么是模块化 事实上模块化开发最终目的是将程序划分成一个个小的结构在这个结构中编写属于自己的逻辑代码&#xff0c;有自己的作用域&#xff0c;不会影响到其他的结构这个结构可以将自己希望暴露的变量、函数、对象等导出给其他结构使用。可以通过某种方式&#xff0c;导入…
阅读更多...
电脑软件：国内最好用解压缩软件 7-Zip 新版本发布

电脑软件：国内最好用解压缩软件 7-Zip 新版本发布

5 月 9 日消息&#xff0c;7-Zip 是一款拥有极高压缩比的的开源压缩软件&#xff0c;支持 LZMA2 等 7 种开源算法&#xff0c;以及支持较广泛的压缩格式 .7z&#xff0c;体积不大&#xff08;1.5MB&#xff09;、功能完善&#xff0c;除了默认 UI 不符合国内审美外几乎没什么可…
阅读更多...
Oracle数据库安装教程，并实现公网远程连接【内网穿透】

Oracle数据库安装教程，并实现公网远程连接【内网穿透】

✨ 目录 &#x1f388; 前言&#x1f388; 1. 数据库搭建&#x1f388; 2. 内网穿透&#x1f388; 2.1 安装cpolar内网穿透&#x1f388; 2.2 创建隧道映射 &#x1f388; 3. 公网远程访问&#x1f388; 4. 配置固定TCP端口地址&#x1f388; 4.1 保留一个固定的公网TCP端口地址…
阅读更多...
Java经典笔试题—day08

Java经典笔试题—day08

Java经典笔试题—day08 &#x1f50e;选择题&#x1f50e;编程题&#x1f95d;两种排序方法&#x1f95d;求最小公倍数 &#x1f50e;结尾 &#x1f50e;选择题 (1)下列选项中关于Java中super关键字的说法正确的是&#xff08;&#xff09; A.super关键字是在子类对象内部指代…
阅读更多...
JAVA JDK下载安装手册

JAVA JDK下载安装手册

JDK的介绍与安装 JDK简介 JDK是 Java 语言的软件开发工具包&#xff0c;主要用于移动设备、嵌入式设备上的java应用程序。编写 Java 程序必须使用 JDK&#xff0c;它提供了编译和运行 Java 程序的环境。是整个java开发的核心。 准备JDK 本次使用的是JDK1.8 如下所示: 下载完…
阅读更多...
记两道AES-CBC题

记两道AES-CBC题

文章目录 知识导入&#xff08;AES-CBC模式&#xff09;题一(buu [ACTF新生赛2020]crypto-aes 1)题目描述&#xff1a;题目分析&#xff1a;知识导入os.urandom(n)函数比特&#xff0c;字节&#xff0c;二进制数之间的关系AES.new(key,AES.MODE_CBC,iv) 题二(crack AES-CBC IV)…
阅读更多...
小黑子—Java从入门到入土过程：第九章-IO流

小黑子—Java从入门到入土过程：第九章-IO流

Java零基础入门9.0 Java系列第九章- IO流1. 初识IO流2. IO流的体系2.1 字节流2.1.1 FileOutputStream 字符串输出流2.1.1 - I 字符串输出流的细节2.1.1 - II FileOutputStream写数据的3种方式2.1.1 -III FileOutputStream写数据的两个小问题 2.1.2 FileInputStream 字符串输入流…
阅读更多...
点线面产生局部坐标系以及计算到世界坐标系的旋转矩阵

点线面产生局部坐标系以及计算到世界坐标系的旋转矩阵

欢迎关注更多精彩 问题描述 给定点O&#xff0c;线段AB&#xff0c;平面OP&#xff0c;求以OP法向为某一轴&#xff0c;以AB在OP上的投影为另一轴&#xff0c;O为原点的局部坐标系。要求给出X,Y,Z轴的单位向量&#xff0c;以及原点O. 求出转换到世界坐标系的旋转矩阵RT。 如…
阅读更多...
ChatGPT的简单了解

ChatGPT的简单了解

ChatGPT 是 InstructGPT 的同级模型&#xff0c;它经过训练可以按照提示中的说明进行操作并提供详细的响应。 InstructGPT论文&#xff1a;https://arxiv.org/pdf/2203.02155.pdf InstructGPT怎么准备和标记数据集&#xff1a;https://harryliu.blog.csdn.net/article/detail…
阅读更多...
【连续介质力学】张量的性质2

【连续介质力学】张量的性质2

张量的代数操作 张量的性质 张量迹 Tensor Trace 定义 e ^ i ⨂ e ^ j \hat e_i \bigotimes \hat e_j e^i​⨂e^j​的迹: T r ( e ^ i ⨂ e ^ j ) e ^ i ⋅ e ^ j δ i j Tr(\hat e_i \bigotimes \hat e_j) \hat e_i \cdot \hat e_j \delta_{ij} Tr(e^i​⨂e^j​)e^i​⋅…
阅读更多...
总结如何申请注册 GitHub 教师教育优惠 Benefits for Teachers 来免费使用 copilot

总结如何申请注册 GitHub 教师教育优惠 Benefits for Teachers 来免费使用 copilot

目录 1. GitHub 教师教育优惠有什么2. 如何申请教师教育优惠呢2.1 选择学校2.2 更改个人信息2.3 准备证明材料2.4 提交申请2.5 遇到的问题2.5.1 问题 12.5.2 问题 22.5.3 问题 3 3. 申请免费的 GitHub Copilot 学生注册不在此处赘述了&#xff0c;网上有很多教程可以参考。但是…
阅读更多...
软件测试面试面对HR提出的问题，怎么回答才不会被面试官“套路”

软件测试面试面对HR提出的问题，怎么回答才不会被面试官“套路”

面试中&#xff0c;如何回答HR提出的问题很大程度上决定了面试能不能成功。 下面是软件测试人员在面试过程中经常被问到的10个问题&#xff0c;告诉你怎么回答才不会被面试官套路...... 请你做一个自我介绍 误区&#xff1a; 一般人回答这个问题过于平常&#xff0c;只说姓…
阅读更多...
JVM学习（一）

JVM学习（一）

一、JVM介绍 1.1基本概念 JVM 是可运行 Java 代码的假想计算机 &#xff0c;包括一套字节码指令集、一组寄存器、一个栈、 一个垃圾回收&#xff0c;堆 和 一个存储方法域。JVM 是运行在操作系统之上的&#xff0c;它与硬件没有直接 的交互。 1.2 运行过程 我们都知道 Java …
阅读更多...
1000W用户1Wqps高并发签到系统的架构和实操

1000W用户1Wqps高并发签到系统的架构和实操

说在前面 在尼恩的&#xff08;50&#xff09;读者社群中&#xff0c;经常有小伙伴面试的时候&#xff0c;遇到一个一个高并发 架构方面的问题&#xff0c;比如&#xff1a; (1) 高并发秒杀系统如何架构&#xff1f; (2) 高并发签到系统如何架构&#xff1f; (3) 等等等等… 刚…
阅读更多...
【C++】函数高级

【C++】函数高级

目录 &#x1f34a;一.函数的默认参数&#x1f34a; 1.默认参数的性质 2.函数默认参数的注意事项 &#x1f34e;二.函数的占位参数&#x1f34e; &#x1f34f;三.函数的重载 &#x1f34f; 1.重载的性质和条件 &#xff08;1&#xff09;修改参数的个数 &#xff…
阅读更多...
go语言中文文档 学习笔记(未完)

go语言中文文档 学习笔记(未完)

这里写目录标题 网络编程互联网协议介绍socket编程socket图解TCP编程服务端客户端 UDP编程TCP黏包 http编程WebSocket编程 网络编程 互联网协议介绍 socket编程 socket图解 Socket是应用层与TCP/IP协议族通信的中间软件抽象层。在设计模式中&#xff0c;Socket其实就是一个门…
阅读更多...
12.设计模式之门面模式

12.设计模式之门面模式

前言 门面模式&#xff0c;是指提供一个统一的接口去访问多个子系统的多个不同的接口&#xff0c;它为子系统中的一组接口提供一个统一的高层接口。使得子系统更容易使用。日志框架slf4J是门面模式最经典的应用场景。 本节&#xff0c;我们就门面模式&#xff0c;展开详细介绍…
阅读更多...
1.setContentView流程分析

1.setContentView流程分析

1. setContentView初步分析之继承自Activity 我们创建的MainActivity继承自Activity,在代码中使用setContentView(R.layout.activity_main),查看他在Activity中的源码如下: public void setContentView(LayoutRes int layoutResID) {//这里的getWindow方法获取到一个PhoneWind…
阅读更多...
什么是好代码/坏代码？给普通人的图解示例

什么是好代码/坏代码？给普通人的图解示例

本文翻译自国外论坛 medium&#xff0c;原文地址&#xff1a;https://medium.com/todbotts.triangles/what-is-good-bad-code-an-illustrated-example-for-non-programmers-1222b600a0f0 我曾经在某个地方读到过一句话&#xff0c;基本上有以下内容&#xff1a; 在现代世界中&a…
阅读更多...
算法（一）—— 回溯（3）

算法（一）—— 回溯（3）

文章目录 1 78 子集2 90 子集II3 491 递增子序列 子集问题 1 78 子集 如果把 子集问题、组合问题、分割问题都抽象为一棵树的话&#xff0c;那么组合问题和分割问题是收集树的叶子节点&#xff0c;而子集问题是找树的所有节点&#xff01; 因为需要找到所有的节点&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023