多米诺骨牌(模拟)

  • 初始化数据结构

    • 使用一个布尔数组 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"));
      }

      }

相关推荐
CoovallyAIHub7 小时前
中科大DSAI Lab团队多篇论文入选ICCV 2025,推动三维视觉与泛化感知技术突破
深度学习·算法·计算机视觉
NAGNIP8 小时前
Serverless 架构下的大模型框架落地实践
算法·架构
moonlifesudo8 小时前
半开区间和开区间的两个二分模版
算法
moonlifesudo8 小时前
300:最长递增子序列
算法
CoovallyAIHub13 小时前
港大&字节重磅发布DanceGRPO:突破视觉生成RLHF瓶颈,多项任务性能提升超180%!
深度学习·算法·计算机视觉
CoovallyAIHub14 小时前
英伟达ViPE重磅发布!解决3D感知难题,SLAM+深度学习完美融合(附带数据集下载地址)
深度学习·算法·计算机视觉
聚客AI1 天前
🙋‍♀️Transformer训练与推理全流程:从输入处理到输出生成
人工智能·算法·llm
大怪v1 天前
前端:人工智能?我也会啊!来个花活,😎😎😎“自动驾驶”整起!
前端·javascript·算法
惯导马工1 天前
【论文导读】ORB-SLAM3:An Accurate Open-Source Library for Visual, Visual-Inertial and
深度学习·算法
骑自行车的码农2 天前
【React用到的一些算法】游标和栈
算法·react.js