算法训练第一周题解汇总

news2024/9/21 0:27:07

A - Sort the Subarray

大意：在s1找一个最大的 [l，r] 子区间，使其经过从小到大的排序后 能够变成 s2

题解：先确定最小的区间，然后慢慢扩大。

最小区间的确定：s1和s2第一个不相等的数开始，到最后一个不相等的数结尾

向两边扩大区间：如果本来就是从小到大排序的，那么就算sort也无影响，否则停止扩展

import java.util.Scanner;

/*
 *@filename: Demo1
 *@author: lyh
 *@date:2023/4/24 19:09
 *@version 1.0
 *@description TODO
 */
public class Demo1 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int t=scanner.nextInt();
        while(t-->0){
            int n=scanner.nextInt();
            int[] vis1=new int[n+1];
            int[] vis2=new int[n+1];
            for(int i=1;i<=n;i++){
                vis1[i]=scanner.nextInt();
            }
            boolean flag=true;
            int left=0,right=0;
            for(int i=1;i<=n;i++){
                vis2[i]=scanner.nextInt();
                if(flag&&vis2[i]!=vis1[i]){
                    left=i;
                    flag=false;
                }else if(vis2[i]!=vis1[i]){
                    right=i;
                }
            }
            while(left-1>0){
                if(vis2[left]>=vis2[left-1]){
                    left--;
                }
                else break;
            }
            while(right+1<=n){
                if(vis2[right]<=vis2[right+1]){
                    right++;
                }
                else break;
            }
            System.out.println(left+" "+right);
        }
    }
}

B - Tear It Apart

大意：给定一个字符串，操作多次后只剩下同一字符，每次操作消除不相邻的多个字符，求最小操作次数  

题解：剩下的那个同一字符将字符串分成了多个区间端，就像隔离带一样。并且我们只要处理最长子串就可以了(因为其他的肯定能顺带移除完毕)。

如何寻找该同一字符：遍历字符串每种已有的字母，计算他们分割子串里的最长子串长度，取最小

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

/*
 *@filename: Demo2
 *@author: lyh
 *@date:2023/4/25 14:46
 *@version 1.0
 *@description TODO
 */
public class Demo2 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int t=scanner.nextInt();
        while(t-->0) {
            String s=scanner.next();
            int length=s.length();
            Map<Character,Integer>map=new HashMap<>(30);
            for(int i=0;i<length;i++){
                if(!map.containsKey(s.charAt(i)))map.put(s.charAt(i),1);
            }
            int minn=Integer.MAX_VALUE;
            for (Map.Entry<Character,Integer>entry:map.entrySet()) {
                  int count=0,temp=0;
                  for(int i=0;i<length;i++){
                      if(s.charAt(i)!=entry.getKey()){
                          count++;
                      }else{
                          temp=Math.max(temp,count);
                          count=0;
                      }
                  }
                  temp=Math.max(temp,count);//最后也要比较一次！
                  minn=Math.min(temp,minn);
            }
            int ans=0;
            while(minn>0){
                minn=minn>>1;//因为不相邻就可以一起消除
                ans++;
            }
            System.out.println(ans);
        }
    }
}

C - Yura's New Name

大意：给出一个仅由 ^ 和 _ 组成的字符串 ，你可以在任意位置添加^或 _ 字符，使得字符串满足：

  • 任意字符要么属于某一子串 ^_^ 的一部分，要么属于某一子串 ^^ 的一部分。

求最少添加的字符数量。

题解：感觉和 括号匹配 是一个题型。开头要求一定得是'^'，两个连续的'_'中间需要加'^'，以'_'结尾需要加'^'。特殊情况只有一个'^'需要注意判断。

import java.util.ArrayList;
import java.util.Scanner;

/*
 *@filename: Demo2
 *@author: lyh
 *@date:2023/4/25 14:46
 *@version 1.0
 *@description TODO
 */
public class Demo2 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int t=scanner.nextInt();
        while(t-->0) {
            int ans=0;
            String s=scanner.next();
            int length=s.length();
            if(length==1&&s.charAt(0)=='^'){
                ans++;
                System.out.println(ans);
                continue;
            }
            if(s.charAt(0)!='^')ans++;
            for(int i=0;i<length-1;i++){
                if(s.charAt(i)==s.charAt(i+1)&&s.charAt(i)=='_'){
                    ans++;
                }
            }
            if(s.charAt(length-1)=='_')ans++;
            System.out.println(ans);
        }
    }
}

F - Li Hua and Maze 

大意：求最少设置多少个障碍物，可以使起点永远无法到达终点。只能上下左右走。

题解：很简单，封住起点或终点，取封这两个需要的最小障碍物数

import java.util.Scanner;

/*
 *@filename: Demo1
 *@author: lyh
 *@date:2023/4/24 19:09
 *@version 1.0
 *@description TODO
 */
public class Demo1 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int t=scanner.nextInt();
        while(t-->0) {
            int n = scanner.nextInt();
            int m = scanner.nextInt();
            int x1= scanner.nextInt();
            int y1= scanner.nextInt();
            int x2= scanner.nextInt();
            int y2= scanner.nextInt();
            int getOutStep1=getStep(x1,y1,n,m);
            int getInStep2=getStep(x2,y2,n,m);
            System.out.println(Math.min(getOutStep1, getInStep2));
        }
    }

    public static int getStep(int x1,int y1,int n,int m){
        int ans=0;
        if(x1-1>=1){
            ans++;
        }
        if(x1+1<=n){
            ans++;
        }
        if(y1+1<=m){
            ans++;
        }
        if(y1-1>=1){
            ans++;
        }
        return ans;
    }
}

G - Li Hua and Pattern

大意：李华有一个大小为 n×n 的图案，每个格子为蓝色或红色。他可以进行恰好 k 次操作。每一次操作，他选择一个格子并改变其颜色（红变蓝，蓝变红）。每个格子可以被选择任意多次。是否可能使得操作后的图案中心对称（翻转180度看起来一样）？ 

题解：首先，遍历每个点，看它与其中心对称的点相比颜色是否一样，如果不一样则需要翻转一次，因为是中心对称，我们只需要遍历前面一半的点就可以了。特别注意的是如果n为奇数需要特别多遍历一行。

如果修改次数大于k，那肯定不行。如果小于k，分n的奇偶性判断：

  • 若n为奇数，一定可以，因为正中心的小正方形无论翻转多少次都不影响整体，可以消耗多余的操作次数
  • 若n为偶数，剩下多余的次数也要为偶数才行
import java.util.Scanner;

/*
 *@filename: Demo1
 *@author: lyh
 *@date:2023/4/24 19:09
 *@version 1.0
 *@description TODO
 */
public class Demo1 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int t=scanner.nextInt();
        while(t-->0) {
            int n=scanner.nextInt();
            int k=scanner.nextInt();
            int[][] vis=new int[n+1][n+1];
            for(int i=1;i<=n;i++){
                for(int j=1;j<=n;j++){
                    vis[i][j]=scanner.nextInt();
                }
            }
            int mod=0;
            for(int i=1;i<=(n>>1);i++){
                for(int j=1;j<=n;j++){
                    if(vis[i][j]!=vis[n-i+1][n-j+1])mod++;
                }
            }
            if((n&1)==1){
                for(int i=1;i<=(n>>1);i++){
                    if(vis[(n>>1)+1][i]!=vis[(n>>1)+1][n-i+1])mod++;
                }
                if(mod<=k){
                    System.out.println("YES");
                }else{
                    System.out.println("NO");
                }
            }else{
                if(mod<=k&&((k-mod)&1)==0){
                    System.out.println("YES");
                }else{
                    System.out.println("NO");
                }
            }
        }
    }

}

J - Playing in a Casino

大意：给出一个T组样例，每组样例给出一个n和m表示给出n条数据，每条有m个数据

每次选两条，每个数据一一对应相减取绝对值，求绝对值的和是多少。

题解：首先一眼模拟暴力，但是时间复杂度n立方，果然超时。

我们可以考虑对列排序，因为改变行的位置不会影响结果。经过从小到大排序后，就简化为两两数字差值的问题了。

先假设有一些数字的差值为1,2,3,4,5，我们会发现

每个差值的最后相加的数量=该层及前面的层数*该层有多少个

最后需要注意答案要用long类型接收

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

/*
 *@filename: Demo1
 *@author: lyh
 *@date:2023/4/24 19:09
 *@version 1.0
 *@description TODO
 */
public class Demo1 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int t=scanner.nextInt();
        while(t-->0) {
           int n=scanner.nextInt();
           int m=scanner.nextInt();
            List<List<Integer>> vis=new ArrayList<>();
            for(int i=1;i<=n;i++){
                List<Integer> x=new ArrayList<>();
                for(int j=1;j<=m;j++){
                    int num=scanner.nextInt();
                    x.add(num);
                }
                vis.add(x);
            }
            long sum=0;
            for(int i=0;i<m;i++){
                int finalI = i;//闭包
                vis.sort(new Comparator<List<Integer>>() {//对列排序
                    @Override
                    public int compare(List<Integer> o1, List<Integer> o2) {
                        return o1.get(finalI)-o2.get(finalI);
                    }
                });
                List<Integer>column=new ArrayList<>();
                for(int j=1;j<n;j++){
                    column.add(vis.get(j).get(i)-vis.get(j-1).get(i));
                }
                int size=column.size();
                for(int j=0;j<size;j++){
                    sum=sum+ (long) column.get(j) *(size-j)*(j+1);
                }
            }
            System.out.println(sum);
        }
    }

}

K - Showstopper

大意： 两组数a、b，a1,a2,......an，b1,b2......bn。每次操作可以把对位的an与bn交换，问是否可以经过多次操作使得an和bn(即最后一个数)分别在数组a、数组b中最大

题解：整体是先从末尾出发往前走，首先处理一下末尾：

如果末尾不是最大的，并且对位元素要大一些，那就交换(贪心思想)。

然后往前遍历，如果当前元素大于末尾元素，并且对位元素也大于末尾元素（说明交换也无法挽救），那么就达不到要求。

import java.util.*;

/*
 *@filename: Demo2
 *@author: lyh
 *@date:2023/4/25 14:46
 *@version 1.0
 *@description TODO
 */
public class Demo2 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int t=scanner.nextInt();
        while(t-->0) {
            int n = scanner.nextInt();
            List<Integer> vis1 = new ArrayList<>();
            List<Integer> vis2 = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                int x = scanner.nextInt();
                vis1.add(x);
            }
            for (int i = 0; i < n; i++) {
                int x = scanner.nextInt();
                vis2.add(x);
            }
            int maxElement1 = Collections.max(vis1);//最大元素
            int maxElement2 = Collections.max(vis2);//最大元素
            if (maxElement1 > vis1.get(n - 1) && vis2.get(n - 1) > vis1.get(n - 1)) {
                int temp = vis1.get(n - 1);
                vis1.set(n - 1, vis2.get(n - 1));
                vis2.set(n - 1, temp);
            } else if (maxElement2 > vis2.get(n - 1) && vis1.get(n - 1) > vis2.get(n - 1)) {
                int temp = vis1.get(n - 1);
                vis1.set(n - 1, vis2.get(n - 1));
                vis2.set(n - 1, temp);
            }
            int pointer = n - 2;
            boolean ans = true;
            while (pointer >= 0) {
                if (vis1.get(pointer) > vis1.get(n - 1)) {
                    if (vis2.get(pointer) > vis1.get(n - 1)||vis1.get(pointer)>vis2.get(n-1)) {
                        System.out.println("NO");
                        ans = false;
                        break;
                    }
                }
                if (vis2.get(pointer) > vis2.get(n - 1)) {
                    if (vis1.get(pointer) > vis2.get(n - 1)||vis2.get(pointer)>vis1.get(n-1)) {
                        System.out.println("NO");
                        ans = false;
                        break;
                    }
                }
                pointer--;
            }
            if(ans) System.out.println("YES");
        }
    }
}

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

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

相关文章

浅谈测试用例设计 | 京东云技术团队

浅谈测试用例设计 | 京东云技术团队

作者&#xff1a;京东物流 王莹莹 一、测试用例为什么存在 1.1 定义 测试用例(Test Case)是指对特定的软件产品进行测试任务的描述&#xff0c;体现测试方案、方法、技术和策略。测试用例内容包括测试目标、测试环境、输入数据、测试步骤、预期结果、测试脚本等&#xff0c;…
阅读更多...
pytorch 计算网络模型的计算量FLOPs和参数量parameter之殊途同归

pytorch 计算网络模型的计算量FLOPs和参数量parameter之殊途同归

计算网络模型的计算量FLOPs和参数量parameter之殊途同归 参数量方法一&#xff1a;pytorch自带方法&#xff0c;计算模型参数总量参数量方法二&#xff1a; summary的使用&#xff1a;来自于torchinfo第三方库参数量方法三&#xff1a; summary的使用&#xff1a;来自于torchsu…
阅读更多...
controlnet1.1预处理器功能详解

controlnet1.1预处理器功能详解

ControlNet 1.1 与 ControlNet 1.0 具有完全相同的体系结构,ControlNet 1.1 包括所有以前的模型&#xff0c;具有改进的稳健性和结果质量,但增加并细化了多个模型。 今天太忙了&#xff0c;有时间就把每个模型的测试样稿发出来 2023.4.27 分类预处理器备注模型黑白倒转invert边…
阅读更多...
数据库物理存储结构

数据库物理存储结构

目录 一、数据库文件和文件组 1、数据库文件 &#xff08;1&#xff09; 主数据库文件&#xff08;Primary Database File&#xff09; &#xff08;2&#xff09; 次数据库文件&#xff08;Secondary Database File&#xff09; &#xff08;3&#xff09; 事务日志文件 …
阅读更多...
[Linux]文档搜索和归档备份

[Linux]文档搜索和归档备份

​⭐作者介绍&#xff1a;大二本科网络工程专业在读&#xff0c;持续学习Java&#xff0c;输出优质文章 ⭐作者主页&#xff1a;逐梦苍穹 ⭐所属专栏&#xff1a;Linux基础操作。本文主要是分享一些Linux系统常用操作&#xff0c;内容主要来源是学校作业&#xff0c;分享出来的…
阅读更多...
配置zabbix自定义监控项

配置zabbix自定义监控项

1.需要安装zabbix-agent服务&#xff0c;使用的zabbix版本为5.0版本 参考&#xff1a;zabbix监控linux主机_Apex Predator的博客-CSDN博客 2.创建存放脚本目录并编辑监控服务的脚本(此处监控一下服务是否存活) mkdir /opt/zabbix_jb vi /opt/zabbix_jb/service_status.sh …
阅读更多...
【容器化应用程序设计和开发】2.2 Dockerfile 的编写和最佳实践

【容器化应用程序设计和开发】2.2 Dockerfile 的编写和最佳实践

往期回顾&#xff1a; 第一章&#xff1a;【云原生概念和技术】 第二章&#xff1a;2.1 容器化基础知识和Docker容器 容器化应用程序设计和开发 2.2 Dockerfile 的编写和最佳实践2.2.1 Dockerfile 包含哪些指令2.2.2 Dockerfile 注意事项 在上篇章节中&#xff0c;我们介绍了…
阅读更多...
什么是索引？MySQL索引的底层数据结构

什么是索引？MySQL索引的底层数据结构

索引(index)是帮助MySQL高效获取数据的数据结构(有序)。在数据之外&#xff0c;数据库系统还维护着满足特定查找算法的数据结构(B树)&#xff0c;这些数据结构以某种方式引用(指向)数据&#xff0c;这样就可以在这些数据结构上实现高级查找算法&#xff0c;这种数据结构就是索引…
阅读更多...
SAP 生产订单修改记录查询

SAP 生产订单修改记录查询

无论在项目实施过程中还是在运维的项目中，经常会遇到生产订单被修改，导致需求发生变更，这个时候用户经常就会需要要求查询生产订单的修改记录。通过SAP的标准程序是没有办法查询到生产订单修改记录，这个时候就从开发的角度去做增强的方式去实现。 1、肯定是在生产订单保存…
阅读更多...
AI（二）：初体验（Cursor、Copilot、Bito）

AI（二）：初体验（Cursor、Copilot、Bito）

Cursor Cursor官网下载&#xff1a;https://www.cursor.so/ && https://github.com/getcursor/cursor Cursor.so是一款基于GPT的代码生成工具&#xff0c;它可以帮助开发者快速生成代码&#xff0c;提高开发效率。GPT是一种自然语言处理技术&#xff0c;可以根据输入…
阅读更多...
Lambda语法解析

Lambda语法解析

Lambda语法解析 一.Lambda语法1.Lambda表达式基本形式&#xff1a;2.capture list&#xff08;捕获列表&#xff09;3.捕获列表程序案例 二.Lambda应用1.使用 lambda 表达式对数组排序&#xff0c;并将排序后的元素存储到新数组中&#xff1a;2.使用 lambda 表达式计算两个矩阵…
阅读更多...
如何安装Auto-GPT

如何安装Auto-GPT

如何安装Auto-GPT 记录一下如何安装Auto-GPT 文章目录 如何安装Auto-GPT前提克隆项目进入项目目录安装所需的依赖重命名 .env.template 文件填写API_KEY创建auto-gpt.json文件运行 Auto-GPT 前提 在安装Auto-GPT之前&#xff0c;你需要具备以下条件&#xff1a; Git环境Python环…
阅读更多...
从历史天气预报 API 看气象大数据的商业价值

从历史天气预报 API 看气象大数据的商业价值

引言 近年来&#xff0c;随着气象观测技术的不断提升和气象大数据的快速发展&#xff0c;越来越多的企业开始将气象数据应用于商业领域。其中&#xff0c;历史天气预报 API 作为一种可获取历史气象数据的接口&#xff0c;具有广泛的商业应用价值。 本文将从历史天气预报 API …
阅读更多...
数字图像处理【8】频域滤波1—关于傅里叶

数字图像处理【8】频域滤波1—关于傅里叶

这一章是数字图像处理基础的最后一章。系统的介绍傅里叶级数、傅里叶变换、离散傅里叶变换&#xff0c;快速傅里叶变换&#xff0c;以及二维傅里叶变换在图像上的应用。 变换的作用 首先我们先来聊聊什么是“变换”&#xff1f;其实在第一章介绍 HSI 颜色模型的时候&#xff0…
阅读更多...
数据库工具——mongostat

数据库工具——mongostat

参考文档&#xff1a;mongostat​​​​​​​​​​​ mongostat提供了当前运行的mongod或者mongos实例的大概状态。mongostat有点类似Linux的vmstat&#xff0c;但mongostat提供的是mongod或者mongos实例的信息。 从MongoDB 4.4开始&#xff0c;mongostat现在与MongoDB Ser…
阅读更多...
第五章——动态规划1

第五章——动态规划1

背包问题 01背包问题 有N个物品和容量是V的背包&#xff0c;每个物品有价值vi和权重&#xff08;价值&#xff09;wi属性&#xff0c;每件物品只能用一次&#xff08;要么用0次&#xff0c;要么用1次&#xff09;&#xff0c;在背包能装得下的情况下&#xff0c;挑一部分物品装…
阅读更多...
网络原理（四）：传输层协议 TCP/UDP

网络原理（四）：传输层协议 TCP/UDP

目录 应用层 传输层 udp 协议 端口号 报文长度&#xff08;udp 长度&#xff09; 校验和 TCP 协议 确认应答 超时重传 链接管理 滑动窗口 流量控制 拥塞控制 延时应答 捎带应答 总结 我们第一章让我们对网络有了一个初步认识&#xff0c;第二章和第三章我们通…
阅读更多...
bounding box线性回归

bounding box线性回归

#bounding box regression原理 如图所示绿色框为飞机的Ground Truth(GT)&#xff0c;红色为提取的positive anchors&#xff0c;即便红色的框被分类器识别为飞机&#xff0c;但是由于红色的框定位不准&#xff0c;这张图相当于没有正确的检测出飞机。所以我们希望采用一种方法对…
阅读更多...
MQTT协议 详解

MQTT协议 详解

文章目录 一、啥是MQTT&#xff1f;1. MQTT协议特点2. 发布和订阅3. QoS&#xff08;Quality of Service levels&#xff09;QoS 0 —— 最多1次QoS 1 —— 最少1次QoS 2 —— 只有1次 二、MQTT 数据包结构1. MQTT固定头2. MQTT可变头 / Variable header3. Payload消息体 三、M…
阅读更多...
Redis集群常用命令及说明

Redis集群常用命令及说明

一、集群的特点 1、集群架构特点 &#xff08;1&#xff09;所有的redis节点彼此互联&#xff08;PING-PONG机制&#xff09;&#xff0c;内部使用二进制协议优化传输速度和带宽&#xff1b; &#xff08;2&#xff09;节点的fail是通过集群中超过半数的节点检测失效时才生效…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023