牛客刷题记录

CC10 判断链表中是否有环

判断给定的链表中是否有环。如果有环则返回true，否则返回false。

要求：空间复杂度 O(1)O(1)，时间复杂度 O(n)O(n)

输入分为两部分，第一部分为链表，第二部分代表是否有环，然后将组成的head头结点传入到函数里面。-1代表无环，其它的数字代表有环，这些参数解释仅仅是为了方便读者自测调试。实际在编程时读入的是链表的头节点。

例如输入{3,2,0,-4},1时，对应的链表结构如下图所示：

可以看出环的入口结点为从头结点开始的第1个结点（注：头结点为第0个结点），所以输出true。

import java.util.*;
/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null && fast.next.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow) {
                return true;
            }
        }
        return false;
    }
}

BM8 链表中倒数最后k个结点

输入一个长度为 n 的链表，设链表中的元素的值为 ai ，返回该链表中倒数第k个节点。

如果该链表长度小于k，请返回一个长度为 0 的链表。

要求：空间复杂度 O(n)O(n)，时间复杂度 O(n)O(n)

进阶：空间复杂度 O(1)O(1)，时间复杂度 O(n)O(n)

例如输入{1,2,3,4,5},2时，对应的链表结构如下图所示：

其中蓝色部分为该链表的最后2个结点，所以返回倒数第2个结点（也即结点值为4的结点）即可，系统会打印后面所有的节点来比较。

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pHead ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    public ListNode FindKthToTail (ListNode pHead, int k) {
        ListNode head = pHead;
        int length = 0;
        while (pHead != null) {
            pHead = pHead.next;
            length++;
        }
        if (k > length) {
            return null;
        }
        int index = length - k + 1;
        for (int i = 1; i <= index - 1; i++) {
            head = head.next;
        }
        return head;
    }
}

HJ43 迷宫问题

定义一个二维数组 N*M ，如 5 × 5 数组下所示：

int maze[5][5] = {
0, 1, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的路线。入口点为[0,0],既第一格是可以走的路。

输入描述：

输入两个整数，分别表示二维数组的行数，列数。再输入相应的数组，其中的1表示墙壁，0表示可以走的路。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。

输出描述：

左上角到右下角的最短路径，格式如样例所示。

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

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();
        int[][] square = new int[m][n];
        int[][] visited = new int[m][n];
        for (int i = 0; i <= m - 1; i++) {
            for (int j = 0; j <= n - 1; j++) {
                square[i][j] = sc.nextInt();
            }
        }
        List<Info> steps = new ArrayList<>();
        steps.add(new Info(0, 0));
        process(square, visited, m, n, 0, 0, steps);
    }


    public static void process(int[][] square, int[][] visited, int m, int n,
                               int m1, int n1, List<Info> steps) {
        // System.out.println(new Info(m1, n1));
        if (m1 == m - 1 && n1 == n - 1) {
            printResult(steps);
            return;
        }

        if (m1 >= m || n1 >= n || m1 <= -1 || n1 <= -1) {
            return;
        }

        if (visited[m1][n1] == 1 || square[m1][n1] == 1) {
            return;
        }
        visited[m1][n1] = 1;

        steps.add(new Info(m1 + 1, n1));
        process(square, visited, m, n, m1 + 1, n1, steps);
        steps.remove(steps.size() - 1);

        steps.add(new Info(m1 - 1, n1));
        process(square, visited, m, n, m1 - 1, n1, steps);
        steps.remove(steps.size() - 1);

        steps.add(new Info(m1, n1 + 1));
        process(square, visited, m, n, m1, n1 + 1, steps);
        steps.remove(steps.size() - 1);

        steps.add(new Info(m1, n1 - 1));
        process(square, visited, m, n, m1, n1 - 1, steps);
        steps.remove(steps.size() - 1);
    }


    public static void printResult(List<Info> steps) {
        for (Info info : steps) {
            System.out.println(info);
        }
    }

    public static class Info {
        public int m;
        public int n;
        public Info(int m1, int n1) {
            m = m1;
            n = n1;
        }
        public String toString() {
            return "(" + m + "," + n + ")";
        }
    }
}