【迅雷10-19】解题第一思路的方向性很关键-CSDN博客

本文链接：https://blog.csdn.net/weixin_43232955/article/details/109170358

文章目录

🍳总结

今天的题目，对菜鸡的自己来说相对友好一些。2个题A了1.6，主要的原因是第一题可能思考的方向有偏差。

解题第一思路的方向性很关键。一定要把题考虑清楚清除了，用什么方法解，边界条件是什么再动手写代码。不然，没考虑清楚的话，如果不可行推倒重来。时间不够，会很容易慌，完全乱了阵脚！

针对笔试题来说，一道题从拿到题到AC，最多预留时间就是30min。相对简单的题，自己感觉会，但是在有限的时间内，有思路和AC是两个完全不同的概念！主要原因是：

自己做的题太少了，没有解题的思维
代码熟练度太差，基本算法的代码模板写不出来（例如滑动窗口）

继续努力刷题吧！

1. 链表乱序节点按序输出

原有的链表 aa => bb => cc => dd => ee 节点断开乱序了，输出原链表节点元素。

【输入】

4        // 输入行数
cc dd    // 节点值，并且代表 cc -> dd 子链表
aa bb
dd ee
bb cc

【输出】

aa
bb
cc
dd
ee

乍一看，是连标题，拿着就做。

【当时的做题思维】

将每行输入的元素放到一个字符串数组里，然后生成每一行的子链表
每一行的子链表放入到链表数组中，然后合并K个升序链表
有序链表节点值去重

按着上面思维写，最终过了0.6。

实际上，当做字符串来做即可！考察的是对链表的理解。

在这里插入图片描述

public class Solution {
    static List<String> list = new ArrayList<>();

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        in.nextLine();
        String[][] nodes = new String[4][2];
        Set<String> set = new HashSet<>();
        String a = null, b = null;
        for (int i = 0; i < n; i++) {
            a = nodes[i][0] = in.next();
            b = nodes[i][1] = in.next();
            set.add(a);
            set.add(b);
        }

        //拿到头结点
        for (int i = 0; i < nodes.length; i++) {
            if (set.contains(nodes[i][1])) {
                set.remove(nodes[i][1]);
            }
        }
        //获取集合的第一个元素
        String head = set.iterator().next();
        list.add(head);
        listRefactor(nodes, head);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }

    private static void listRefactor(String[][] nodes, String head) {
        for (int i = 0; i < nodes.length; i++) {
            if (nodes[i][0].equals(head)) {
                list.add(nodes[i][1]);
                listRefactor(nodes, nodes[i][1]);
            }
        }
    }
}

2. 杨氏矩阵按序输出

杨氏矩阵元素由小到大有序输出
在这里插入图片描述
【输入】

4 3 // 4行3列
1 2 3
2 3 4
4 5 6
6 7 8

【输出】

暴力解

直接将二位数组放入到ArrayList中，然后Collections.sort()排序输出

调整堆，递归解

public class Solution2 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int m = in.nextInt();
        int n = in.nextInt();
        in.nextLine();
        int[][] arr = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                arr[i][j] = in.nextInt();
            }
        }
        youngExtract(arr);
    }

    public static void youngExtract(int[][] arr) {
        int min = 0;
        for (int i = arr.length - 1; i >= 0; i--) {
            for (int j = arr[0].length - 1; j >= 0; j--) {
                min = arr[0][0];
                if (min != Integer.MAX_VALUE) {
                    System.out.println(min);
                }
                arr[0][0] = arr[i][j];
                arr[i][j] = Integer.MAX_VALUE;
                youngHeapify(arr, 0, 0);
            }
        }
    }


    public static void youngHeapify(int[][] arr, int row, int col) {
        int N = arr.length;
        int M = arr[0].length;
        int min_i = row;
        int min_j = col;
        if (min_j < M - 1 && arr[row][col + 1] != Integer.MAX_VALUE && arr[min_i][min_j] > arr[row][col + 1]) {
            min_i = row;
            min_j = col + 1;
        }

        if (min_i < N - 1 && arr[row + 1][col] != Integer.MAX_VALUE && arr[min_i][min_j] > arr[row + 1][col]) {
            min_i = row + 1;
            min_j = col;
        }

        if (min_i != row || min_j != col) {
            int tmp = arr[min_i][min_j];
            arr[min_i][min_j] = arr[row][col];
            arr[row][col] = tmp;
            youngHeapify(arr, min_i, min_j);
        }
    }
}

【文章参考】