多米诺骨牌(模拟)

  • 初始化数据结构

    • 使用一个布尔数组 arr 来表示每个位置是否被占用。初始时所有位置均为 false(未占用)。
    • 使用一个 LinkedHashMap(命名为 queue)来记录最近的 R 操作的位置。这个结构可以保持插入顺序,方便后续处理。
  • 遍历输入字符串

    • 遍历每个字符,根据字符的类型(.LR)进行不同的处理:
      • .:表示空位,跳过。
      • L
        • 如果 queue 为空(没有 R),将当前位置之前的所有位置标记为占用(true)。
        • 如果 queue 不为空,处理最近的 R
          • queue 中获取并移除最近的 R 的位置。
          • 计算从这个 R 到当前 L 之间的影响区域,并根据位置关系决定标记的方式。具体来说,如果 LR 之间的距离是偶数,则需要跳过中间位置;如果是奇数,则可以直接标记所有位置为占用。
      • R :将当前索引加入 queue,以备后续处理。
  • 处理剩余的 R

    • 遍历完字符串后,如果 queue 中还有 R,取出第一个 R 的位置,将这个位置及其后所有位置标记为占用。
  • 计算未占用的位置

    • 遍历 arr 数组,统计未被占用的位置,并将它们的索引(1-based)加入结果队列。
  • 构造结果字符串

    • 如果没有未占用的位置,返回 "0"

    • 否则,构造结果字符串,格式为 "count:pos1,pos2,...",并返回。

      import java.util.ArrayDeque;
      import java.util.LinkedHashMap;
      import java.util.Map;
      import java.util.Iterator;

      public class Main {
      public static String solution(int num, String data) {
      boolean[] arr = new boolean[data.length()];
      LinkedHashMap<Character, Integer> queue = new LinkedHashMap<>();

      复制代码
          for (int i = 0; i < data.length(); i++) {
              switch (data.charAt(i)) {
                  case '.':
                      break;
                  case 'L':
                      if (queue.isEmpty()) {
                          for (int j = 0; j <= i; j++) {
                              arr[j] = true;
                          }
                      } else {
                          Iterator<Map.Entry<Character, Integer>> iterator = queue.entrySet().iterator();
                          Map.Entry<Character, Integer> firstEntry = iterator.next(); // 获取第一个条目
                          iterator.remove();
      
                          boolean skipTwo = false;
                          int top = firstEntry.getValue();
                          int extra = (i + top) / 2;
                          if ((i - top) % 2 != 0) {
                              skipTwo = true;
                          }
                          for (int j = top; j <= i; j++) {
                              if (skipTwo) {
                                  arr[j] = true;
                              } else {
                                  if (j != extra) {
                                      arr[j] = true;
                                  }
                              }
                          }
                      }
                      break;
                  case 'R':
                      queue.put('R', i);
                      break;
              }
          }
      
          // Check if the queue is not empty
          if (!queue.isEmpty()) {
              // Retrieve and remove the first entry
              Iterator<Map.Entry<Character, Integer>> iterator = queue.entrySet().iterator();
              Map.Entry<Character, Integer> firstEntry = iterator.next();
              iterator.remove(); // Pop the first entry
      
              if (firstEntry.getKey() == 'R') {
                  int topValue = firstEntry.getValue();
                  for (int j = topValue; j < arr.length; j++) {
                      arr[j] = true; // Set all subsequent elements to true
                  }
              }
          }
      
          int count = 0;
          ArrayDeque<Integer> result = new ArrayDeque<>();
          for (int i = 0; i < data.length(); i++) {
              if (!arr[i]) {
                  count++;
                  result.add(i + 1); // 1-based index
              }
          }
      
          if (count == 0) {
              return "0"; // All positions are filled
          }
      
          StringBuilder resultString = new StringBuilder(count + ":");
          for (int pos : result) {
              resultString.append(pos).append(",");
          }
      
          resultString.setLength(resultString.length() - 1); // Remove the last comma
          return resultString.toString();
      }
      
      public static void main(String[] args) {
          // // You can add more test cases here
          System.out.println(solution(14, ".L.R...LR..L..").equals("4:3,6,13,14"));
          System.out.println(solution(5, "R....").equals("0"));
          System.out.println(solution(1, ".").equals("1:1"));
      }

      }

相关推荐
艾莉丝努力练剑36 分钟前
【LeetCode&数据结构】单链表的应用——反转链表问题、链表的中间节点问题详解
c语言·开发语言·数据结构·学习·算法·leetcode·链表
_殊途2 小时前
《Java HashMap底层原理全解析(源码+性能+面试)》
java·数据结构·算法
珊瑚里的鱼6 小时前
LeetCode 692题解 | 前K个高频单词
开发语言·c++·算法·leetcode·职场和发展·学习方法
秋说7 小时前
【PTA数据结构 | C语言版】顺序队列的3个操作
c语言·数据结构·算法
lifallen7 小时前
Kafka 时间轮深度解析:如何O(1)处理定时任务
java·数据结构·分布式·后端·算法·kafka
liupenglove7 小时前
自动驾驶数据仓库:时间片合并算法。
大数据·数据仓库·算法·elasticsearch·自动驾驶
python_tty8 小时前
排序算法(二):插入排序
算法·排序算法
然我8 小时前
面试官:如何判断元素是否出现过?我:三种哈希方法任你选
前端·javascript·算法
risc1234569 小时前
BKD 树(Block KD-Tree)Lucene
java·数据结构·lucene
F_D_Z9 小时前
【EM算法】三硬币模型
算法·机器学习·概率论·em算法·极大似然估计