6.2算法刷题

最新推荐文章于 2024-04-16 10:50:12 发布

flowers_world

最新推荐文章于 2024-04-16 10:50:12 发布

阅读量174

点赞数 1

分类专栏： leetcode算法刷题

本文链接：https://blog.csdn.net/nine_age/article/details/117471132

版权

leetcode算法刷题专栏收录该内容

8 篇文章 0 订阅

订阅专栏

6.2刷题

一、每日一题：连续的子数组和

（523. 连续的子数组和 - 力扣（LeetCode） (leetcode-cn.com)

首先思路是通过前缀和来进行一个判断，由于害怕和直接溢出，于是计算前缀和的时候进行了一个转换，但是还是超时了

在这里插入图片描述

class Solution {
    public boolean checkSubarraySum(int[] nums, int k) {
        int n=nums.length;
        int[] temp=new int[n];
        int count=0;
        int sum=0;
        for(int i=0;i<n;i++){
            if(nums[i]%k==0){
                nums[i]=0;
            }
            else{
                nums[i]=nums[i]%k;
            }
            sum+=nums[i];
            temp[i]=sum;
            System.out.println(sum);
            if(i>0) if(sum%k==0) return true;
        }
        System.out.println(Arrays.toString(temp));
        //System.out.println(count);
        for(int i=0;i<n;i++){
            for(int j=i+2;j<n;j++){
                if((temp[j]-temp[i])%k==0) return true;
            }
        }
        return false;
    }
}

查看了解析之后发现用前缀和加哈希表可以减少后面的一个两重循环，相当于只有一次遍历

因为如果两个数遍历的余数相同的时候，表明他们中间加了一个k或者k的倍数，于是通过哈希表可以取到他们的下标。
在这里插入图片描述

图来源于：

作者：Xiaohu9527
链接：https://leetcode-cn.com/problems/continuous-subarray-sum/solution/zheng-ming-dong-tu-bang-ni-chi-tou-ben-t-nldg/
来源：力扣（LeetCode）

class Solution {
    public boolean checkSubarraySum(int[] nums, int k) {
      int n=nums.length;
        if (n < 2) {
            return false;
        }
        int sum=0;
        Map<Integer,Integer> map=new HashMap<>();
        map.put(0,-1);
        for(int i=0;i<n;i++){
            sum=(sum+nums[i])%k;
            if(map.containsKey(sum)){
                int prevIndex = map.get(sum);
                if (i - prevIndex >= 2) {
                    return true;
                }
            } else {
                map.put(sum, i);
            }
        }
        return false;
    }
}

！！重点是，今天这题让我想到了我昨天超时的那个牛客上面的笔试题，于是我又回去实验了一下

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[] arr = new int[n];
        for(int i = 0;i < n;i++){
            arr[i] = sc.nextInt();
        }
        System.out.println(f(arr,m));
    }
    public static long f(int[] arr,int m){
        HashMap<Integer,Integer> map = new HashMap<>();
        map.put(0,1);
        int sum = 0;
        long res = 0;
        for(int i = 0; i< arr.length; i++){
            sum =(sum+arr[i]) % m ;
            if(map.containsKey(sum)){
                res += map.get(sum);
                map.put(sum,map.get(sum)+1);
            }else{
                map.put(sum,1);
            }
        }
        return res;
    }
}

腾讯音乐娱乐（TME）2021暑期实习生招聘技术类笔试

二、狡猾的雇主

一位雇主想要招聘一个工人，有[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n8wPEhEx-1622619778559)(https://www.nowcoder.com/equation?tex=%5Cmathit%20n%5C)]个人前来应聘，这位雇主让每个人写下期望的薪资，然后再进行选择。

因为这个雇主十分狡猾，ta会选择期望薪资最低的人，但是这个人可能不是唯一的，为了避免纠纷，ta会选择在没有和其他人提出的期望薪资相同的情况下期望薪资最低的人录用。

求这个最低薪资，如果没有合适的人，则输出-1

//排序加哈希表
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        int n=scan.nextInt();
        int[] temp=new int[n];
        for(int i=0;i<n;i++){
            temp[i]=scan.nextInt();
        }
        int res=-1;
        Arrays.sort(temp);
        Map<Integer,Integer> map=new HashMap<>();
        for(int t:temp){
            map.put(t,map.getOrDefault(t,0)+1);
        }
        for(int t:temp){
            if(map.get(t)==1){
                res=t;
                break;
            }
        }
        System.out.println(res);
    }
}

一、军营选择

只过了20%，虽然我觉得方法没啥问题

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

public class Main {
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        int time=scan.nextInt();
        for(int t=0;t<time;t++){
            //m个点
            int m=scan.nextInt();
            List<Integer>[] graph=new List[m+1];
            for(int i=0;i<m+1;i++){
                graph[i]=new ArrayList();
            }
            for(int i=1;i<m;i++){
                int x=scan.nextInt();
                int y=scan.nextInt();
                graph[x].add(y);
                graph[y].add(x);
            }
            int result[]=new int[4];
            int max_sum=0;
            boolean flag=false;
            for(int j=1;j<m+1;j++){
                if(graph[j].size()==m-1){
                    result[3]=j;
                    result[2]=graph[j].get(0);
                    result[1]=graph[j].get(0);
                    result[0]=j;
                    flag=true;
                    System.out.println(result[0]+" "+result[1]);
                    System.out.println(result[2]+" "+result[3]);
                    break;
                }
                if(max_sum<graph[j].size()){
                    result[3]=j;
                    max_sum=graph[j].size();
                }
            }
            if(!flag){
                int que=0;
                boolean[] jugde=new boolean[m+1];
                jugde[0]=true;
                jugde[result[3]]=true;
                for(int p:graph[result[3]]){
                    jugde[p]=true;
                }
                for(int p=0;p<m+1;p++){
                    if(jugde[p]==false) {
                        que=p;
                        break;
                    }
                }
                result[2]=que;
                result[1]=graph[que].get(0);
                result[0]=que;
                System.out.println(result[0]+" "+result[1]);
                System.out.println(result[2]+" "+result[3]);
            }
        }
    }
}

三、三国鼎立

典型的dfs岛屿问题

前面读题没有读清楚，然后m、n没有分清楚，所以导致有问题，后面就好了


import java.util.Scanner;

public class Main {

    static int[] x = new int[]{0,1,0,-1};
    static int[] y = new int[]{1,0,-1,0};
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        char[][] pro = new char[n][m];
        for (int i = 0; i < n; i++) {
            pro[i] = scanner.next().toCharArray();
        }
        int count = count(n, m, pro);
        System.out.println(count);
    }

    private static int count(int n, int m, char[][] pro) {
        int res=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(pro[i][j]!='-'){
                    dfs(i,j,pro,pro[i][j]);
                    res++;
                }
            }
        }
        return res;
    }

    private static void dfs(int i, int j, char[][] pro, char target) {
        pro[i][j]='-';
        for(int k=0;k<4;k++){
            if(i+x[k]<pro.length&&j+y[k]<pro[0].length&&i+x[k]>=0&&j+y[k]>=0&&pro[i+x[k]][j+y[k]]==target){
                dfs(i+x[k],j+y[k],pro,target);
            }
        }
    }
}

har[][] pro, char target) {
pro[i][j]=’-’;
for(int k=0;k<4;k++){
if(i+x[k]<pro.length&&j+y[k]<pro[0].length&&i+x[k]>=0&&j+y[k]>=0&&pro[i+x[k]][j+y[k]]==target){
dfs(i+x[k],j+y[k],pro,target);
}
}
}
}

flowers_world

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
6.2算法刷题

6.2刷题一、每日一题：连续的子数组和（523. 连续的子数组和 - 力扣（LeetCode） (leetcode-cn.com)首先思路是通过前缀和来进行一个判断，由于害怕和直接溢出，于是计算前缀和的时候进行了一个转换，但是还是超时了class Solution { public boolean checkSubarraySum(int[] nums, int k) { int n=nums.length; int[] temp=new int[n];
复制链接

扫一扫