leecode，rt_phm更新更新

Big_data_example/Spark/src/main/java/com/atguigu/spark/streaming/SparkStreaming02_Queue.scala

@@ -2,7 +2,7 @@ package com.atguigu.spark.streaming
 
 import org.apache.spark.SparkConf
 import org.apache.spark.rdd.RDD
-import org.apache.spark.streaming.dstream.ReceiverInputDStream
+import org.apache.spark.streaming.dstream.{InputDStream, ReceiverInputDStream}
 import org.apache.spark.streaming.{Seconds, StreamingContext}
 
 import scala.collection.mutable
@@ -27,7 +27,7 @@ object SparkStreaming02_Queue {
     val rddQueue = new mutable.Queue[RDD[Int]]()
 
     //4.创建QueueInputDStream
-    val inputStream = ssc.queueStream(rddQueue,oneAtATime = false)
+    val inputStream: InputDStream[Int] = ssc.queueStream(rddQueue,oneAtATime = false)
 
 
     //5.处理队列中的RDD数据

Big_data_example/Spark/src/main/java/com/atguigu/spark/streaming/SparkStreaming06_state_transform.scala

@@ -29,10 +29,10 @@ object SparkStreaming06_state_transform {
     //和直接map的区别:写code的位置
     //Driver端
     val newDS: DStream[String] = lines.transform(
-      rdd =>{
+      rdd => {
         //code:Driver端，(周期性执行)
         rdd.map(
-          str =>{
+          str => {
             //code:Executor端
             str
           }
@@ -42,7 +42,7 @@ object SparkStreaming06_state_transform {
 
     //code:Driver端
     val newDS1: DStream[String] = lines.map(
-      str =>{
+      str => {
         //code:executor端，无周期性执行
         str
       }

Leecode/src/main/java/com/markilue/leecode/hot100/second/T72_239_MaxSlidingWindow.java

@@ -19,7 +19,7 @@ public class T72_239_MaxSlidingWindow {
     public void test() {
         int[] nums = {1, 3, -1, -3, 5, 3, 6, 7};
         int k = 3;
-        System.out.println(Arrays.toString(maxSlidingWindow1(nums, k)));
+        System.out.println(Arrays.toString(maxSlidingWindow2(nums, k)));
     }
 
     @Test
@@ -110,4 +110,37 @@ public class T72_239_MaxSlidingWindow {
     }
 
 
+    //构造一个单调栈，只有后面的值比前面的值小，前面的值就是无用的
+    public int[] maxSlidingWindow2(int[] nums, int k) {
+
+        ArrayDeque<Integer> stack = new ArrayDeque<>();
+
+        int[] result = new int[nums.length - k + 1];
+
+        //构造第一个窗口
+        for (int i = 0; i < k; i++) {
+            while (!stack.isEmpty() && nums[stack.peekLast()] <= nums[i]) {
+                stack.pollLast();
+            }
+            stack.offerLast(i);
+        }
+        result[0] = nums[stack.peekFirst()];
+
+        for (int i = k; i < nums.length; i++) {
+            //先排除过期元素
+            while (!stack.isEmpty() && i - stack.peekFirst() >= k) {
+                stack.pollFirst();
+            }
+            //添加在合适的位置
+            while (!stack.isEmpty() && nums[stack.peekLast()] <= nums[i]) {
+                stack.pollLast();
+            }
+            stack.offerLast(i);
+            result[i - k + 1] = stack.isEmpty() ? -1 : nums[stack.peekFirst()];
+        }
+        return result;
+
+    }
+
+
 }

Leecode/src/main/java/com/markilue/leecode/interview/meituan/T0415/Question2.java

@@ -0,0 +1,49 @@
+package com.markilue.leecode.interview.meituan.T0415;
+
+import java.util.Scanner;
+
+
+/**
+ *@BelongsProject: Leecode
+ *@BelongsPackage: com.markilue.leecode.interview.meituan.T0415
+ *@Author: markilue
+ *@CreateTime: 2023-06-07  10:28
+ *@Description:
+ * TODO  小美分糖:
+ *  某一天，小美从商店买了两种糖果，分别买了a个和b个，要分给班上n个小朋友。为了不浪费，每块糖果都得恰好分到一个小朋友。
+ *  另外，两种糖果一起吃的话味道其实并不好，所以每一个小朋友都只能得到其中一种糖果。
+ *  小美希望分得最少糖果的那个小朋友能得到尽量多的糖果。小美的任务是求得这个数量是多少。
+ *@Version: 1.0
+ */
+public class Question2 {
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int count = sc.nextInt();
+
+        for (int i = 0; i < count; i++) {
+            int n = sc.nextInt();
+            int a = sc.nextInt();
+            int b = sc.nextInt();
+            solve(n, a, b);
+        }
+    }
+
+    //挨个遍历均分，看看谁的最小更大
+    private static void solve(int n, int a, int b) {
+        if (a > b) {
+            solve(n, b, a);
+            return;
+        }
+        int min = Integer.MIN_VALUE;
+        for (int i = 1; i < n; i++) {
+            int curMin = Math.min(a / i, b / (n - i));
+            if (min > curMin) {
+                break;//在递减了，直接break
+            } else {
+                min = curMin;
+            }
+        }
+        System.out.println(min);
+    }
+}

Leecode/src/main/java/com/markilue/leecode/interview/meituan/T0415/Question3.java

@@ -0,0 +1,142 @@
+package com.markilue.leecode.interview.meituan.T0415;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+/**
+ *@BelongsProject: Leecode
+ *@BelongsPackage: com.markilue.leecode.interview.meituan.T0415
+ *@Author: markilue
+ *@CreateTime: 2023-06-07  11:00
+ *@Description:
+ * TODO  交通规划:
+ *  A国有n个城市，这n个城市排成一列，依次编号为1,2,3,...,n。
+ *  一开始，这n座城市之间都没有任何交通路线，于是政府打算修建一些铁路来进行交通规划。
+ *  接下来T天，每一天会进行如下操作的其中一种：
+ *      - “L x”：表示编号为 x 的城市与其左边的城市之间修建一条铁路。如果 x 左边没有城市或者已经修建了铁路，则无视该操作；
+ *      - “R x”：表示编号为 x 的城市与其右边的城市之间修建一条铁路。如果 x 右边没有城市或者已经修建了铁路，则无视该操作；
+ *      - “Q x”：表示查询 x 往左边和往右边最远能到达的城市编号。
+ *  你的任务是模拟以上操作，并对于每一条“Q x”操作，输出对应的答案。
+ *@Version: 1.0
+ */
+public class Question3 {
+
+    public static void main(String[] args) {
+
+        Scanner sc = new Scanner(System.in);
+        int total = sc.nextInt();
+        //构建图
+        List<Node> edge = new ArrayList<>();
+        for (int i = 0; i < total; i++) {
+            edge.add(new Node(i));
+        }
+
+        int count = sc.nextInt();
+
+        for (int i = 0; i < count; i++) {
+            String action = sc.next();
+            int node = sc.nextInt() - 1;//num => index
+            if (action.equals("L") && node - 1 >= 0) {
+                edge.get(node).left = edge.get(node - 1);
+            } else if (action.equals("R") && node + 1 < edge.size()) {
+                edge.get(node).right = edge.get(node + 1);
+            } else if (action.equals("Q")) {
+                //查询
+                Node cur = edge.get(node);
+                Node tempLeft = cur;
+                while (tempLeft.left != null) {
+                    tempLeft = tempLeft.left;
+                }
+                Node tempRight = cur;
+                while (tempRight.right != null) {
+                    tempRight = tempRight.right;
+                }
+                System.out.println((tempLeft.val + 1) + " " + (tempRight.val + 1));
+            }
+        }
+
+    }
+
+    static class Node {
+        Node left;
+        Node right;
+        int val;
+
+        public Node() {
+        }
+
+        public Node(int val) {
+            this.val = val;
+        }
+    }
+
+
+    int[] father;
+
+    public void init(int[] father) {
+        for (int i = 0; i < father.length; i++) {
+            father[i] = i;
+        }
+    }
+
+    public int find(int x) {
+        if (x == father[x]) return x;
+        father[x] = find(father[x]);
+        return father[x];
+    }
+
+    public void union(int u, int v) {
+        u = find(u);
+        v = find(v);
+        if (u == v) return;
+        father[v] = u;
+    }
+
+
+    //并查集:这题本质上就是一个无向图，考察连通性，因此可以使用并查集简化计算
+    public void solve1() {
+        Scanner sc = new Scanner(System.in);
+        int total = sc.nextInt();
+        //构建图
+        father = new int[total + 2];
+        init(father);
+
+
+        int count = sc.nextInt();
+
+        for (int i = 0; i < count; i++) {
+            String action = sc.next();
+            int node = sc.nextInt();//num => index
+            if (action.equals("L")) {
+                union(node, node - 1);
+            } else if (action.equals("R")) {
+                union(node, node + 1);
+            } else {
+                //查询  左边二分找到连通的最小值
+                int l = 1;
+                int r = node;
+                while (l < r) {
+                    int mid = l + ((r - l) >> 1);
+                    if (find(node) == find(mid)) r = mid;//父亲是一样的，我们认为是联通的,所以缩小范围找更小的
+                    else l = mid + 1;
+                }
+                int res1 = r;
+                //查询  右边二分找到连通的最大值
+                l = node;
+                r = total;
+                while (l < r) {
+                    int mid = l + ((r - l) >> 1);
+                    if (find(node) == find(mid)) l = mid;//父亲是一样的，我们认为是联通的,所以缩小范围找更大的
+                    else r = mid - 1;
+                }
+                System.out.println(res1 + " " + r);
+
+            }
+        }
+    }
+
+
+}