CodeTop每日系列三题------------------2021.11.13

LC46. 全排列

class Solution {

    private List<List<Integer>> res = new ArrayList();
    private LinkedList<Integer> item = new LinkedList();
    private int[] used;

    public List<List<Integer>> permute(int[] nums) {
        if(nums.length == 0)
        return res;
        used = new int[nums.length];
        dfs(nums,0);
        return res;
    }

    public void dfs(int[] nums,int n){
        if(n == nums.length)
        //不能是res.add(item)，这只会是一个引用依然会回退元素然后形成一个空数组
        //那么我们需要一个快照的形式，也就是要一个值，res.add(new ArryaList(item))
        res.add(new ArrayList(item));
        for(int i = 0;i < nums.length;i++){
            if(used[i] == 0){
            item.add(nums[i]);
            used[i] = 1;
            dfs(nums,n + 1);
            used[i] = 0;
            item.removeLast();
            }
        }
    }
}

LC200. 岛屿数量

class Solution {
    public int numIslands(char[][] grid) {
        int count = 0;
        int m = grid.length,n = grid[0].length;
        for(int i = 0;i < m;i++){
            for(int j = 0;j < n;j++){
                if(grid[i][j] == '1'){
                    dfs(grid,i,j);
                    count++;
                }
            }
        }
        return count;
    }

    public void dfs(char[][] grid,int i,int j){
        if(i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == '0') return ;
        grid[i][j] = '0';
        dfs(grid,i - 1,j);
        dfs(grid,i,j + 1);
        dfs(grid,i + 1,j);
        dfs(grid,i,j - 1);
    }
}

LC142. 环形链表 II
核心思想看到链表带环那么我们需要双指针。（快慢指针）

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while(true){
            //判断条件也出错了
            if(fast == null || fast.next == null) return null;
            slow = slow.next;
            fast = fast.next.next;
            //少了这一步，导致超时，也就是说我们在进行快慢指针的时候，需要一个结束调节
            //也就是他们第一次相遇的情况下，那么我们就推出循环。
            if(fast == slow) break;
        }
        fast = head;
        while(slow != fast){
            slow = slow.next;
            fast = fast.next;
        }
        return fast;
    }
}