哈希

哈希

134. 报文回路

import java.util.Scanner;
import java.util.*;


// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int count = Integer.parseInt(in.nextLine());
        Map<Integer, Set<Integer>> map = new HashMap<>();
        for (int i = 0; i < count; i++) {
            String[] split = in.nextLine().split(" ");
            int key = Integer.parseInt(split[0]);
            int value = Integer.parseInt(split[1]);
            Set<Integer> orDefault = map.getOrDefault(key, new HashSet<>());
            orDefault.add(value);
            map.put(key, orDefault);
        }

         for (Integer integer : map.keySet()) {
            Set<Integer> set = map.get(integer); //  key 对应的所有 value
            for (Integer integer1 : set) {
                Set<Integer> temp = map.get(integer1);
                //  如果
                //  1. 没有值 = value 的 key
                //  2. 值 = value 的key 的 value 要包含 当前key
                if (!map.containsKey(integer1) || !temp.contains(integer)){
                    System.out.println("False");
                    return;
                }
            }
        }
        System.out.println("True");
    }
}

137. 找出2个整数数组中同时出现的整数

import java.util.Scanner;
import java.util.*;


// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    static int[] arr1;
    static int[] arr2;

    public static void main(String[] args) {
       Map<Integer, Integer> map1 = new HashMap<>();
        Map<Integer, Integer> map2 = new HashMap<>();
        Map<Integer, Integer> map = new HashMap<>();

        Scanner in = new Scanner(System.in);
        String[] A = in.nextLine().split(",");
        arr1 = new int[A.length];
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = Integer.parseInt(A[i]);
        }
        for (int i : arr1) {
            map1.put(i, map1.getOrDefault(i, 0) + 1);
        }
        String[] B = in.nextLine().split(",");
        arr2 = new int[B.length];
        for (int i = 0; i < arr2.length; i++) {
            arr2[i] = Integer.parseInt(B[i]);
        }
        for (int i : arr2) {
            map2.put(i, map2.getOrDefault(i, 0) + 1);
        }

        for (Integer integer : map1.keySet()) {
            if (map2.containsKey(integer)){
                map.put(integer, Math.min(map1.get(integer), map2.get(integer)));
            }
        }

        if (map.size() == 0){
            System.out.println("NULL");
            return;
        }

        Map<Integer, String> res = new TreeMap<>(); //  注意输出也要按照key顺序输出，所以用 treeMap

        map.keySet().stream().sorted(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                int count1 = map.get(o1);
                int count2 = map.get(o2);
                if (count1 != count2){
                    return count1 - count2;
                }
                return Integer.compare(o1, o2);
            }
        }).forEach(integer -> {
            Integer value = map.get(integer);
            res.put(value, res.getOrDefault(value, "") + integer + ",");
        });

        for (Integer integer : res.keySet()) {
            String s = res.get(integer);
            System.out.println(integer + ":" + s.substring(0, s.length() - 1));
        }
    }
}

251. 连续字母长度

import java.util.Scanner;
import java.util.*;
import java.util.regex.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();   //  第一行有一个子串(1<长度<=100)，只包含大写字母。
        int k = Integer.parseInt(in.nextLine());
         if (k <= 0){
            System.out.println(-1);
            return;
        }
        String reg = "([A-Z])\\1{0,}";
        Matcher matcher = Pattern.compile(reg).matcher(s);
        Map<String, Integer> map = new HashMap<>();
        while (matcher.find()) {
            String group = matcher.group();
            String temp = group.charAt(0) + "";
            if (map.containsKey(temp)) {
                Integer count = map.get(temp);  //  旧的长度
                if (count < group.length()) {
                    map.put(temp, group.length());
                }
                continue;
            }
            map.put(temp, matcher.group().length());
        }
        if (map.size() < k){
            System.out.println(-1);
            return;
        }
        ArrayList<Integer> res = new ArrayList<>();
        map.values().stream().sorted(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        }).limit(k).forEach(integer -> res.add(integer));
        System.out.println(res.get(k - 1));
    }
}

158. 五子棋迷

你得帮他写一个程序，算出最有利的出子位置。 最有利定义：
找到一个空位(0)，用棋子(1/-1)填充该位置，可以使得当前子的最大连续长度变大【先求出原先旧的长度！！！】
如果存在多个位置，返回最靠近中间的较小的那个坐标
如果不存在可行位置，直接返回-1
连续长度不能超过5个(五字棋约束)

import java.util.Scanner;
import java.util.*;


// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
       Scanner in = new Scanner(System.in);
        int now = Integer.parseInt(in.nextLine());
        String[] split = in.nextLine().split(" ");
        int[] arr = new int[split.length];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = Integer.parseInt(split[i]);
        }
        int oldLen = 0;
        for (int i = 0; i < arr.length; i++) {
            int len = 0;
            if (arr[i] == now){ //  当前是 now
                len++;
                while (i + 1 < arr.length && arr[i + 1] == now){
                    i++;
                    len++;
                }
                oldLen = Math.max(oldLen, len);
            }
        }
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == 0){
                int result = getResult(i, arr, now);
                if (result > 5){
                    continue;
                }
                if (getResult(i, arr, now) > oldLen) {
                    map.put(i, getResult(i, arr, now));
                }
            }
        }
        if (map.size() == 0){
            System.out.println(-1);
            return;
        }

      
        Map<Integer, String> res = new TreeMap<>();
        map.keySet().stream().sorted(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                int len1 = map.get(o1);
                int len2 = map.get(o2);
                if (len1 != len2){
                    return len2 - len1;
                }
                return o1 - o2;
            }
        }).forEach(integer -> {
            Integer value = map.get(integer);
            res.put(value, res.getOrDefault(value, "") + integer + ",");
        });
       res.keySet().stream().sorted(new Comparator<Integer>() {
           @Override
           public int compare(Integer o1, Integer o2) {
               return o2 - o1;
           }
       }).limit(1).forEach(integer -> {
           int mid = arr.length / 2;
           int len = Integer.MAX_VALUE;
           int ans = 0;
           String s = res.get(integer);
           String[] split1 = s.split(",");
           for (String s1 : split1) {
               int temp = Integer.parseInt(s1); //  当前位置
               if (Math.abs(mid - temp) < len){ //  距离中点最近的位置！！！
                   len = Math.abs(mid -temp);
                   ans = temp;
               }
           }
           System.out.println(ans);
       });
    }
    public static int getResult(int index, int[] arr, int now){
        int sum = 1;    //  初始值就是1个
        int leftIndex = index - 1;
        int rightIndex = index + 1;
        while (leftIndex >= 0 && arr[leftIndex] == now){
            sum++;
            leftIndex--;
        }
        while (rightIndex < arr.length && arr[rightIndex] == now){
            sum++;
            rightIndex++;
        }
        return sum;
    }
}

237.打印任务排序

import java.util.Scanner;
import java.util.*;


// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
        static int[] flag;

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String[] split = in.nextLine().split(",");
        int n = split.length;
        int[] arr = new int[n];
        flag = new int[10]; //  标志等级：1 - 9
        Deque<Job> deque = new ArrayDeque<>();
        for (int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(split[i]);
            flag[arr[i]]++; //  统计所有等级
            deque.add(new Job(i, arr[i]));
        }
        int index = 0;
        Map<Integer, Integer> map = new HashMap<>();
        while (!deque.isEmpty()){
            Job job = deque.removeFirst();
            if (isHaveMoreRank(job.rank)){  //  有比我高的
                deque.add(job);
                continue;
            }
            map.put(job.index, index++);  //  当前索引是第几个输出的
        }
        
        StringBuilder res = new StringBuilder();
        map.values().stream().forEach(integer -> res.append(integer+","));
        System.out.println(res.toString().substring(0, res.length() - 1));
    }

    public static boolean isHaveMoreRank(int n){    //  待插入的数
        for (int i = n + 1; i < flag.length; i++) {
            if (flag[i] > 0){
                return true;
            }
        }
        flag[n]--;      //  没有比我高的，弹出，输出
        return false;
    }
}

class Job{
    int index;
    int rank;

    public Job(int index, int rank) {
        this.index = index;
        this.rank = rank;
    }
}