add leetcode: 1117,39,42

Author: CodeWater404

Algorithm/src/leetCode/multiThread/_1117H2OGeneration.java

@@ -0,0 +1,47 @@
+package leetCode.multiThread;
+
+/**
+ * @author ： CodeWater
+ * @create ：2022-07-31-21:37
+ * @Function Description ：1117.H2O 生成
+ */
+public class _1117H2OGeneration {
+    class H2O {
+        private volatile int state = 0 ;
+        private Object lock = new Object();
+
+        public H2O() {
+
+        }
+
+        public void hydrogen(Runnable releaseHydrogen) throws InterruptedException {
+            synchronized(lock){
+                // state等于2，说明对于H来说，已经有了2个；阻塞当前H线程
+                while( state == 2 ){
+                    lock.wait();
+                }
+                // H线程不满2个的时候可以执行，state对应相加
+                state++;
+                releaseHydrogen.run();
+                lock.notifyAll();
+            }
+
+
+        }
+
+        public void oxygen(Runnable releaseOxygen) throws InterruptedException {
+            synchronized(lock){
+                // 在O线程里面，state不等于2，说明H还不满，所以需要阻塞O线程
+                while( state != 2 ){
+                    lock.wait();
+                }
+                // state等于2满足H，这个时候可以执行O线程，同时重置state。组合一个H2O
+                state = 0;
+                releaseOxygen.run();
+                lock.notifyAll();
+            }
+
+
+        }
+    }
+}

Algorithm/src/leetCode/subject/number1_50/_39SumOfCombination.java

@@ -0,0 +1,54 @@
+package leetCode.subject.number1_50;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author ： CodeWater
+ * @create ：2022-07-31-22:10
+ * @Function Description ：39.组合总和
+ */
+public class _39SumOfCombination {
+    class Solution {
+        /**因为要考虑所有的方案，所以不能优化。
+         爆搜：因为每个数可以重复选择。所以搜索的时候枚举当前数，考虑选0次的情况，
+         1次的情况，2次的情况等等。。。
+
+         */
+        //  res答案  path搜索一次的方案
+        private List<List<Integer>> res = new ArrayList<>();
+        private List<Integer> path = new ArrayList<>();
+
+        public List<List<Integer>> combinationSum(int[] candidates, int target) {
+            //从第一个数开始枚举
+            dfs( candidates , 0 , target );
+            return res;
+        }
+
+        // 每选用一个数就把target对应相减，减到0，可以组合
+        public void dfs( int[] cs , int u , int target ){
+            // 枚举到可以组合target.把当前遍历的路径添加到res中
+            if( target == 0 ){
+                // ================注意这里的语法！！不能写res.add(path);==================
+                res.add( new ArrayList(path) );
+                return;
+            }
+// 如果枚举到最后一个数，但是还没有组合target，直接返回
+            if( u == cs.length ) return ;
+
+            //枚举。可以选0个，但是条件是不要超过target
+            for( int i = 0 ; cs[u] * i <= target ; i++ ){
+                // 第一次选0个不加，直接到下一层
+                dfs(cs , u + 1 , target - cs[u] * i );
+                // 第二次及以后选择了有数字，加到方案中.所以在递归之后加入
+                path.add(cs[u]);
+            }
+
+            // 恢复现场:清空path
+            for( int i = 0 ; cs[u] * i <= target ; i++ ){
+                path.remove( path.size() - 1 );
+            }
+
+        }
+    }
+}

Algorithm/src/leetCode/subject/number1_50/_42RainWater.java

@@ -0,0 +1,38 @@
+package leetCode.subject.number1_50;
+
+import java.util.Stack;
+
+/**
+ * @author ： CodeWater
+ * @create ：2022-07-31-23:31
+ * @Function Description ：42. 接雨水
+ */
+public class _42RainWater {
+    class Solution {
+        public int trap(int[] height) {
+            // 栈存高度的下标
+            Stack<Integer> stk = new Stack<>();
+            int res = 0;
+            // 枚举所有柱子的高度
+            for(int i = 0 ; i < height.length ; i++ ){
+                // 记录上一个柱子的高度，第一次0
+                int last = 0;
+                // 栈非空并且栈顶元素小于等于上一个高度
+                while( stk.size() > 0 && height[stk.peek()] <= height[i] ) {
+                    // 先加上最底下的一部分凹糟的面试
+                    res += ( height[stk.peek()] - last ) * ( i - stk.peek() - 1 );
+                    // 更新成大凹糟的下标
+                    last = height[stk.peek()];
+                    // 计算完当前凹糟后，弹出
+                    stk.pop();
+                }
+                // 宽度 * 高度
+                if( stk.size() > 0 ) res += (i - stk.peek() - 1 ) * (height[i] - last);
+                // 当前元素入栈
+                stk.push(i);
+            }
+
+            return res;
+        }
+    }
+}