2023/05/08~14 刷题记录

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量462 收藏
点赞数
分类专栏： Java刷题记录 文章标签： java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sora_2021/article/details/130611280
版权

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);
        }
    }
}
PP_2022
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【2023.5.3~2023.5.9】CTF刷题记录
qq_66633020的博客
05-03 628
获取题目附件，根据题目名可知是由python编写，所以直接用uncompyle6进行反编译，dump出py文件。可以看出程序对输入内容进行了两个加密，这两个加密可逆并知道了密文，开始写解密脚本。题目：[GWCTF 2019]pyre。日期：2023.5.3。方向：REVERSE。
leetcodepython001-leetcode:在https://leetcode-cn.com的刷题记录
07-01
leetcode Python 001 | 描述 这个 Repository 是 的代码，命名规则如下： AAAA_BBB_CCC.DD AAAA是难度[简单，中等，困难] BBB 是序列号[001, 002, 003...] CCC 是名称 DD是后缀[py, c, java...] ...027
力扣刷题记录--二叉树/二叉搜索树相关问题
qq_41857397的博客
06-12 506
摘录LeetCode中与二叉树相关的题目，以及一些常用的解法模板
流量分析刷题记录
rev1ve的博客
05-18 227
在 TCP 追踪流里可以看到整个利用一句话木马注入的过程，但是没有看到 flag 有关的信息。猜测仿射密码，a和b的值分别为17和77。先过滤下http流，在这个流中找到线索。下载附件，发现是加密的zip。题目提示还要找到连接的key。解方程，得到x=17或77。丢到cyberchef解码。直接追踪tcp流，看请求包。盲猜伪加密，把9改成0。下面一串疑似flag。
刷题记录upupupupup（题解持续更新）
m0_52806260的博客
11-15 204
刷题
2023 暑期实习历程总结
Hello World!
05-25 5684
Hello 大家好久不见，已经三个月左右没有更新了，那我这三个月在干什么呢？自2023年3月中旬开始到现在五月底这期间接近三个月的时间里，我一直在进行2023暑期实习的投递和面试。这期间投递了包括各大中厂（阿里，腾讯，蚂蚁，美团，携程，拼多多，华为，SHEIN，快手等），外企（PayPal，亚马逊，微软没开），银行金融（微众银行，招商银行信用卡，东方财富，花旗金融，Wind等），其他（联想，吉利，海信，中兴，OPPO）等数十家公司和企业。从一开始的谨慎投递和筛选企业，到后面的没投投谁和查缺补漏；
POJ刷题指南
CooperNiu's Blog
02-20 933
初期: 一.基本算法: (1)枚举. (poj1753,poj2965) (2)贪心(poj1328,poj2109,poj2586) (3)递归和分治法. (4)递推. (5)构造法.(poj3295) (6)模拟法.(poj1068,poj2632,poj1573,poj2993,poj2996) 二.图算法:
POJ刷题分类目录
沧海一根草的专栏
03-19 1299
转载自： http://www.cnblogs.com/kuangbin/archive/2011/07/29/2120667.html 面对POJ上千道题，菜鸟如何起飞。。。。。。。。。 初期: 一.基本算法:      (1)枚举. (poj1753,poj2965)      (2)贪心(poj1328,poj2109,poj2586)      (3)递
POJ题目刷题路线
m0_37876745的博客
02-27 793
转载地址：http://www.cnblogs.com/kuangbin/archive/2011/07/29/2120667.html初期:一.基本算法:(1)枚举. (poj1753,poj2965)(2)贪心(poj1328,poj2109,poj2586)(3)递归和分治法.(4)递推.(5)构造法.(poj3295)(6)模拟法.(poj1068,poj2632,poj1573,poj2...
POJ刷题列表
pyub153的博客
01-08 1515
初期: 一.基本算法:     (1)枚举. (poj1753,poj2965)     (2)贪心(poj1328,poj2109,poj2586)     (3)递归和分治法.     (4)递推.     (5)构造法.(poj3295)     (6)模拟法.(poj1068,poj2632,poj1573,poj2993,poj2996) 二.图算法:     (1)图
代码随想录+刷题笔记记录
03-22
本文主要介绍代码随想录的刷题笔记记录，方便读者更好地利用该网站进行学习。 ## 刷题笔记记录的作用 刷题笔记记录是代码随想录提供的一个功能，用于记录用户在刷题过程中的解题思路和方法。它可以帮助用户更好地...
C语言2022刷题记录代码.zip
10-23
C语言2022刷题记录代码.zipC语言2022刷题记录代码.zipC语言2022刷题记录代码.zipC语言2022刷题记录代码.zipC语言2022刷题记录代码.zipC语言2022刷题记录代码.zipC语言2022刷题记录代码.zip
力扣刷题笔记总结记录666
01-13
力扣刷题笔记总结记录666
CS-Notes:力扣刷题记录~坚持面向offer刷题~
05-29
这是本人的与的刷题记录~坚持面向offer刷题力扣目前已刷300+，74%+正确率~主刷medium与easy，hard只做经典的刷题顺序是按照标签刷，每个标签下又分为easy,medium以及hard三个等级~每道题后面都有一些个人的笔记和...
进阶2 探索图形化编程：扩展图形组件与切片开发的魅力
优树搭的博客
05-30 1497
当这些切片成功地通过图形程序串联起来后，在后续进行程序升级或维护时，大家会惊喜地发现，图形程序就如同清晰的路标一般，可以非常便捷地通过图形程序准确地定位到相关切片，并对这些切片进行在线查看、编辑和执行等操作。而且，这些切片的代码长度通常不会太长，相比传统开发的代码，阅读起来要容易得多，这无疑会给系统后续的工作带来极大的便利。
JAVAEE之多线程进阶（2）_ CAS概念、实现原理、ABA问题及解决方案
2301_80653026的博客
05-29 1531
CAS全称Compare and swap，字面意思:”比较并交换“，它是一条 CPU 并发原语，用于判断内存中某个值是否为预期值，如果是则更改为新的值，这个过程是原子的。全称 Compare and swap, 即 “比较并交换”. 相当于通过一个原子的操作, 同时完成 “读取内存, 比较是否相等, 修改内存” 这三个步骤. 本质上需要 CPU 指令的支撑。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 1062
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 896
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
生成一个markdown语言的代码刷题记录
09-16
我可以给你一些代码，可以让你使用Markdown语言记录你的刷题记录：``` # 刷题记录## 今日刷题- 题目 1: - 解答：- 题目 2: - 解答：## 昨日刷题- 题目 1: - 解答：- 题目 2: - 解答： ``` ### 回答2： 生成一...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值