LeetCode 第 267 场周赛

1.买票需要的时间
思路一：
定义买票所需的总时间为 res，每个人需要买票的时间为 1 秒，返回位于位置 k（下标从 0 开始）的人完成买票需要的时间（以秒为单位）

外循环遍历次数：
要令位于位置 k 的人完成买票，即当 tickets[k] = 0 时，
要让 tickets[k] = 0，则要遍历 tickets[k] 遍，即长度为 tickets[k]

内循环遍历数组：
如果数组元素不为 0 ：

• 说明该位置的人需要买票，花费1s，res++；
• 同时该位置需要买的票 - 1，tickets[j]–;

如果数组元素不为 0 ：

• 说明该位置的人不需要买票，跳过

当索引为 k 的元素为 0 时，返回结果 res

class Solution {
    public int timeRequiredToBuy(int[] tickets, int k) {
        int res = 0, len = tickets[k];
        //外循环遍历次数
        for (int i = 0; i < len; i++) {
        	//内循环遍历数组
            for (int j = 0; j < tickets.length; j++) {
                if (tickets[j] != 0) {
                    res++;
                    tickets[j]--;
                }
                if (j == k && tickets[k] == 0) return res;
            }
        }
        return -1;
    }
}

思路二：
在位置 k 前面的人最多买 k 张票，k 后面的人最多买 k - 1 张票

• 索引 k 之前：
  res += Math.min(tickets[i], tickets[k]);
• 索引 k 之后：
  res += Math.min(tickets[i], tickets[k] - 1);

class Solution {
    public int timeRequiredToBuy(int[] tickets, int k) {
        int res = 0;
        for (int i = 0; i < tickets.length; i++) {
            if (i <= k) {
                res += Math.min(tickets[i], tickets[k]);
            } else {
                res += Math.min(tickets[i], tickets[k] - 1);
            }
        }
        return res;
    }
}

2074. 反转偶数长度组的节点
不用原地修改，新创建一个 list 存放所有链表节点

分组遍历数组：

• 其他组
• 最后一组
  我们对最后一组进行特殊处理，再将组里的元素个数进行判断，如果为偶数，则反转

最后再将 list 中的链表节点串起来，最后一个节点指向 null

反转链表（函数）：交换首尾节点

class Solution {
    public ListNode reverseEvenLengthGroups(ListNode head) {
        List<ListNode> list = new ArrayList<>();
        ListNode cur = head;
        while (cur != null) {
            list.add(cur);
            cur = cur.next;
        }
        int len = list.size();
        for (int i = 0, n = 1; i < len; n++) {
            int j = Math.min(len - 1, i + n - 1);
            if ((j - i + 1) % 2 == 0) {
                reverse(list, i, j);
            }
            i = j + 1;
        }
        for (int i = 0; i < len - 1; i++) {
            list.get(i).next = list.get(i + 1);
        }
        list.get(len - 1).next = null;
        return list.get(0);
    }
    public void reverse(List<ListNode> list, int start, int end) {
        while (start < end) {
            ListNode temp = list.get(start);
            list.set(start++, list.get(end));
            list.set(end--, temp);
        }
    }
}

5928. 解码斜向换位密码

• 将字符串转为二维数组：
  定义一个二维数组，行为 rows，列为字符串长度 / rows
  将字符串依次填入对应位置

• 使用 StringBuilder 进行字符串拼接：
  每次从左对角线向右下方遍历拼接

最后将StringBuilder 转为 String 类型去除尾部空格

• 去除字符串首尾空格：String.trim();
• 去除字符串尾部空格：String…replaceAll("\s+$", “”);

class Solution {
    public String decodeCiphertext(String encodedText, int rows) {
        int cols = encodedText.length() / rows;
        char[][] arr = new char[rows][cols];
        int index = 0;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                arr[i][j] = encodedText.charAt(index++);
            }
        }
        StringBuilder sb = new StringBuilder();
        for (int j = 0; j < cols; j++) {
            int i = 0, temp = j;
            while (i < rows && j < cols) {
                sb.append(arr[i][j]);
                i++;j++;
            }
            j = temp;
        }
        return sb.toString().replaceAll("\\s+$", "");
    }
}