Java每日一练(20230501)

简介: Java每日一练(20230501)

1. 路径交叉


给你一个整数数组 distance 。


从 X-Y 平面上的点 (0,0) 开始,先向北移动 distance[0] 米,然后向西移动 distance[1] 米,向南移动 distance[2] 米,向东移动 distance[3] 米,持续移动。也就是说,每次移动后你的方位会发生逆时针变化。


判断你所经过的路径是否相交。如果相交,返回 true ;否则,返回 false


示例 1:

8ff63b9228149b90de12438778363e72.jpeg


输入:distance = [2,1,1,2]

输出:true



示例 2:

61bb0e4736e54f12fc1585be35dc8b92.jpeg

输入:distance = [1,2,3,4]

输出:false


示例 3:

bdefbc868dc738985c3e5a16ec3225f5.jpeg

输入:distance = [1,1,1,1]

输出:true


提示:

   1 <= distance.length <= 10^5

   1 <= distance[i] <= 10^5

出处:

https://edu.csdn.net/practice/26912042


代码:

class Solution {
    public boolean isSelfCrossing(int[] x) {
        if (x.length < 4)
            return false;
        int a = 0, b = 0, c = 0;
        int d = x[0], e = x[1], f = x[2];
        for (int i = 3; i < x.length; i++) {
            a = b;
            b = c;
            c = d;
            d = e;
            e = f;
            f = x[i];
            if (e < c - a && f >= d)
                return true;
            if (c - a <= e && e <= c && f >= (d - b < 0 ? d : d - b))
                return true;
        }
        return false;
    }
}


输出:

true

false

true


2. 环形链表


给定一个链表,判断链表中是否有环。

如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,我们使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果 pos 是 -1,则在该链表中没有环。注意:pos 不作为参数进行传递,仅仅是为了标识链表的实际情况。


如果链表中存在环,则返回 true 。 否则,返回 false 。


进阶:

你能用 O(1)(即,常量)内存解决此问题吗?


示例 1:

4a18acda10c1606aa5d1132b9de26d61.png


输入:head = [3,2,0,-4], pos = 1

输出:true

解释:链表中有一个环,其尾部连接到第二个节点。


示例 2:

输入:head = [1,2], pos = 0

输出:true

解释:链表中有一个环,其尾部连接到第一个节点。


示例 3:

输入:head = [1], pos = -1

输出:false

解释:链表中没有环。


提示:

  • 链表中节点的数目范围是 [0, 10^4]
  • -10^5 <= Node.val <= 10^5
  • pos-1 或者链表中的一个 有效索引

出处:

https://edu.csdn.net/practice/26912043

代码:


import java.util.*;
public class hasCycle {
    public static class ListNode {
        int val;
        ListNode next;
        ListNode(int x) {
            val = x;
            next = null;
        }
    }
    public static class Solution {
        public boolean hasCycle(ListNode head) {
            if (head == null || head.next == null)
                return false;
            ListNode fast = head.next;
            ListNode slow = head;
            while (fast != slow) {
                if (fast.next == null || fast.next.next == null)
                    return false;
                fast = fast.next.next;
                slow = slow.next;
            }
            return true;
        }
    }
    public static ListNode createRingNodeList(int[] nums, int pos) {
        if (nums == null || nums.length == 0) {
            return null;
        }
        ListNode head = new ListNode(nums[0]);
        ListNode tail = head;
        for (int i = 1; i < nums.length; i++) {
            tail.next = new ListNode(nums[i]);
            tail = tail.next;
        }
        if (pos >= 0) {
            ListNode p = head;
            while (pos > 0) {
                p = p.next;
                pos--;
            }
            tail.next = p;
        }
        return head;
    }
    public static void main(String[] args) {
        Solution s = new Solution();
        int[] nums = {3,2,0,-4};
        ListNode head = createRingNodeList(nums, 1);
        System.out.println(s.hasCycle(head));
        int[] nums2 = {1,2};
        head = createRingNodeList(nums2, 0);
        System.out.println(s.hasCycle(head));
        int[] nums3 = {1};
        head = createRingNodeList(nums3, -1);
        System.out.println(s.hasCycle(head));
    }
}



输出:

true

true

false


3. 被围绕的区域


给你一个 m x n 的矩阵 board ,由若干字符 'X''O' ,找到所有被 'X' 围绕的区域,并将这些区域里所有的 'O''X' 填充。


示例 1:

5a3a22bfad68fd1d22012a0ee48ec665.jpeg



输入:board = [["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]]

输出:[["X","X","X","X"],["X","X","X","X"],["X","X","X","X"],["X","O","X","X"]]

解释:被围绕的区间不会存在于边界上,换句话说,任何边界上的 'O' 都不会被填充为 'X'。 任何不在边界上,或不与边界上的 'O' 相连的 'O' 最终都会被填充为 'X'。如果两个元素在水平或垂直方向相邻,则称它们是“相连”的。


示例 2:

输入:board = [["X"]]

输出:[["X"]]


提示:

   m == board.length

   n == board[i].length

   1 <= m, n <= 200

   board[i][j] 为 'X' 或 'O'


出处:

https://edu.csdn.net/practice/26912044

代码:

import java.util.*;
import java.util.LinkedList;
public class solve {
    public static class Solution {
        int[] dx = { 1, -1, 0, 0 };
        int[] dy = { 0, 0, 1, -1 };
        public void solve(char[][] board) {
            int n = board.length;
            if (n == 0) {
                return;
            }
            int m = board[0].length;
            Queue<int[]> queue = new LinkedList<int[]>();
            for (int i = 0; i < n; i++) {
                if (board[i][0] == 'O') {
                    queue.offer(new int[] { i, 0 });
                }
                if (board[i][m - 1] == 'O') {
                    queue.offer(new int[] { i, m - 1 });
                }
            }
            for (int i = 1; i < m - 1; i++) {
                if (board[0][i] == 'O') {
                    queue.offer(new int[] { 0, i });
                }
                if (board[n - 1][i] == 'O') {
                    queue.offer(new int[] { n - 1, i });
                }
            }
            while (!queue.isEmpty()) {
                int[] cell = queue.poll();
                int x = cell[0], y = cell[1];
                board[x][y] = 'A';
                for (int i = 0; i < 4; i++) {
                    int mx = x + dx[i], my = y + dy[i];
                    if (mx < 0 || my < 0 || mx >= n || my >= m || board[mx][my] != 'O') {
                        continue;
                    }
                    queue.offer(new int[] { mx, my });
                }
            }
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    if (board[i][j] == 'A') {
                        board[i][j] = 'O';
                    } else if (board[i][j] == 'O') {
                        board[i][j] = 'X';
                    }
                }
            }
        }
    }
    public static void main(String[] args) {
        Solution s = new Solution();
        char[][] board = {{'X','X','X','X'},{'X','O','O','X'},{'X','X','O','X'},{'X','O','X','X'}};
        s.solve(board);
        System.out.println(Arrays.deepToString(board));
    }
}

输出:

[[X, X, X, X], [X, X, X, X], [X, X, X, X], [X, O, X, X]]



目录
打赏
0
0
0
0
74
分享
相关文章
|
10月前
|
CSDN每日一练(Java)--小艺的英文名
CSDN每日一练(Java)--小艺的英文名
|
10月前
|
2023-3-25 java选择题每日一练
2023-3-25 java选择题每日一练
60 1
|
10月前
|
Rust 编程小技巧摘选(6)
Rust 编程小技巧摘选(6)
118 1
Rust 编程小技巧摘选(6)
|
10月前
|
Rust 重载运算符|复数结构的“加减乘除”四则运算
Rust 重载运算符|复数结构的“加减乘除”四则运算
129 0
Rust 重载运算符|复数结构的“加减乘除”四则运算
|
10月前
|
Linux 终端命令之文件浏览(1) cat
Linux 终端命令之文件浏览(1) cat
79 0
Linux 终端命令之文件浏览(1) cat
|
10月前
|
Rust 编程小技巧摘选(7)
Rust 编程小技巧摘选(7)
147 0
Rust 编程小技巧摘选(7)
|
10月前
|
Windows 使用 Linux 子系统,轻轻松松安装多个linux
Windows 使用 Linux 子系统,轻轻松松安装多个linux
853 0
Windows 使用 Linux 子系统,轻轻松松安装多个linux
|
10月前
|
Rust 数据类型 之 类C枚举 c-like enum
Rust 数据类型 之 类C枚举 c-like enum
88 0
Rust 数据类型 之 类C枚举 c-like enum
|
10月前
|
Golang每日一练(leetDay0120) 反转字符串中的元音字母、前K个高频元素
Golang每日一练(leetDay0120) 反转字符串中的元音字母、前K个高频元素
94 0
Golang每日一练(leetDay0120) 反转字符串中的元音字母、前K个高频元素
|
10月前
|
Golang每日一练(leetDay0116) 路径交叉、回文对
Golang每日一练(leetDay0116) 路径交叉、回文对
76 0
Golang每日一练(leetDay0116) 路径交叉、回文对

热门文章

最新文章

AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等