Merge pull request #211 from GitGarden2019/master

第四周算法作业#35

Author: GeekUniversity

Week_04/id_35/Leetcode_169_35.java

@@ -0,0 +1,107 @@
+package com.leecode.week04;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.stream.Collectors;
+
+/**
+ * 求众数 给定一个大小为 n 的数组，找到其中的众数。众数是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。
+ *
+ * 你可以假设数组是非空的，并且给定的数组总是存在众数。
+ *
+ * @author xuemin.zhu
+ */
+public class Leetcode_169_35 {
+
+    public static void main(String[] args) {
+
+        Leetcode_169_35 lc = new Leetcode_169_35();
+        //System.out.println(lc.majorityElement(new int[]{3, 2, 3}));
+        System.out.println(lc.majorityElement(new int[]{2, 2, 1, 1, 1, 2, 2}));
+        System.out.println(lc.majorityElement(new int[]{1}));
+        System.out.println(lc.majorityElement(new int[]{2,2}));
+        System.out.println(lc.majorityElement(new int[]{6,5,5}));
+
+    }
+
+    /**
+     * Boyer-Moore:
+     * 思路说明：把所有数据都看成是众数和非众数两类,然后就像玩消消乐那样一个碰一个去抵消掉 这里是不一样的抵消掉
+     * 因为众数是数量比较多的，把全部非众数灭掉之后还有剩，剩下的就是我们要找的众数了
+     */
+    public int majorityElement(int[] nums) {
+
+        //题目中保证要有众数，两个元素的情况只能是两个一样的了
+        if (nums.length == 1 || nums.length == 2) {
+            return nums[0];
+        }
+
+        int majorIndex = 0;//首先选择0作为众数
+        int majorCount = 0;//当前众数的计数个数
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] == nums[majorIndex]) {
+                majorCount++;
+            } else {
+                majorCount--;
+            }
+
+            if (majorCount == 0) {
+                //当前众数是0之后需要重新选举新的众数,i 会在经过majorCount时majorCount会变成1
+                majorIndex = i + 1;
+
+            }
+        }
+
+        return nums[majorIndex];
+    }
+
+
+    /**
+     * 思路1：最直接的搞法就是先计算出每个数字出现的次数，再看看是不是超过n/2 这里想试试jdk8中新式写法^^
+     */
+
+    public int majorityElement_v1(int[] nums) {
+
+        Map<String, Long> map = Arrays.stream(nums)
+            .mapToObj(num -> new Tuple(String.valueOf(num), num))
+            .collect(Collectors.groupingBy(Tuple::getKey, Collectors.counting()));
+
+        List<Entry<String, Long>> entrys = map.entrySet().stream()
+            .filter(s -> s.getValue() > nums.length / 2).collect(Collectors.toList());
+
+        if (entrys.isEmpty() || entrys.size() != 1) {
+            return -1;
+        }
+
+        return Integer.valueOf(entrys.get(0).getKey());
+    }
+
+    static class Tuple {
+
+        private String key;
+        private Integer val;
+
+        public Tuple(String key, Integer val) {
+            this.key = key;
+            this.val = val;
+        }
+
+        public Integer getVal() {
+            return val;
+        }
+
+        public void setVal(Integer val) {
+            this.val = val;
+        }
+
+        public String getKey() {
+            return key;
+        }
+
+        public void setKey(String key) {
+            this.key = key;
+        }
+    }
+}

Week_04/id_35/Leetcode_198_35.java

@@ -0,0 +1,58 @@
+package com.leecode.week04;
+
+/**
+ * 打家劫舍
+ * 你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
+ *
+ * 给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。
+ *
+ */
+public class Leetcode_198_35 {
+
+    public static void main(String[] args) {
+        Leetcode_198_35 lc=new Leetcode_198_35();
+
+        System.out.println(lc.rob(new int[]{1,2,3,1}));
+
+        System.out.println(lc.rob(new int[]{2,9,7,3,1}));
+
+
+    }
+
+    /**
+     * 相邻的房间不能偷，转换成我在当前的一套房间的行为
+     * 1.前一个房间我没有偷，那么当前的房间我可以偷
+     * 2.前一个房间我是偷了的，当前的房间就不能偷了
+     * 所以偷到当前的房间的最高金额就是在两种方案中选择最高的
+     *
+     * dp[i]=max(dp[i-1]+0),dp[i-2]+num[i]
+     *
+     * @param nums
+     * @return
+     */
+    public int rob(int[] nums) {
+        int[] dp=new int[nums.length];
+
+         if(nums==null||nums.length==0){
+             return 0;
+         }
+
+         if(nums.length==1){
+             return nums[0];
+         }
+
+        if(nums.length==2){
+           return Math.max(nums[0],nums[1]);
+        }
+
+
+        dp[0]=nums[0];
+        dp[1]=Math.max(dp[0],nums[1]);//第一次偷了就是dp[0],第一次不偷0+第二次偷num[1]，两种情况找个比较大的
+
+        for(int i=2;i<nums.length;i++){
+            dp[i]=Math.max(dp[i-1],dp[i-2]+nums[i]);
+        }
+
+        return dp[nums.length-1];
+    }
+}

Week_04/id_35/Leetcode_213_35.java

@@ -0,0 +1,68 @@
+package com.leecode.week04;
+
+/**
+ * 213. 打家劫舍 II 这次去偷四合院，屋子是连着的 这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警
+ */
+public class Leetcode_213_35 {
+
+
+
+    public static void main(String[] args) {
+        Leetcode_213_35 lc=new Leetcode_213_35();
+
+        System.out.println(lc.rob(new int[]{2,3,2}));
+
+        System.out.println(lc.rob(new int[]{1,2,3,1}));
+
+
+    }
+
+    /**
+     * 思路分析：这个题目是在打家劫舍版本上面首位相连，也就是第一家和最后一家会连着的 那么把情况这两种情况单独拿出来看 1.第一家我可以偷，意味着最后那家就不能偷了
+     * 2.第一家不偷，最后那家就可以偷 这里的偷和不偷只是要不要纳入本次迭代的考虑范围，求最优解的时候也不一定就一定会要偷
+     *
+     * 最后两种方案找个最好的结果就行
+     */
+    public int rob(int[] nums) {
+
+
+        if (nums == null || nums.length == 0) {
+            return 0;
+        }
+
+        if (nums.length == 1) {
+            return nums[0];
+        }
+
+        if (nums.length == 2) {
+            return Math.max(nums[0], nums[1]);
+        }
+
+
+        int[] dp1=new int[nums.length-1];
+
+        dp1[0] = nums[0];
+        dp1[1] = Math.max(dp1[0], nums[1]);
+
+        //可以偷第一家,最后那家的不能偷，循环终止是nums.length-1
+        for (int i = 2; i < nums.length-1; i++) {
+            dp1[i] = Math.max(dp1[i - 1], dp1[i - 2] + nums[i]);
+        }
+
+
+
+         //可以偷最后一家
+        int[] dp2=new int[nums.length];
+        dp2[0]=0;//第一家是强行不能偷
+        dp2[1]=nums[1];
+
+        for (int i=2;i<nums.length;i++){
+            dp2[i] = Math.max(dp2[i - 1], dp2[i - 2] + nums[i]);
+        }
+
+
+        return Math.max(dp1[nums.length - 2],dp2[nums.length - 1]);
+    }
+
+
+}

Week_04/id_35/Leetcode_70_35.java

@@ -0,0 +1,51 @@
+package com.leecode.week04;
+
+/**
+ * https://leetcode-cn.com/problems/climbing-stairs/ 还是爬楼梯问题，这次换成动态规划的方式来做
+ *
+ * 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
+ *
+ * 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
+ */
+public class Leetcode_70_35 {
+
+    public static void main(String[] args) {
+        Leetcode_70_35 lc = new Leetcode_70_35();
+        System.out.println(lc.climbStairs(1));
+        System.out.println(lc.climbStairs(2));
+        System.out.println(lc.climbStairs(3));
+        System.out.println(lc.climbStairs(4));
+        System.out.println(lc.climbStairs(6));
+        System.out.println(lc.climbStairs(8));
+        System.out.println(lc.climbStairs(20));
+
+    }
+
+    /**
+     * 思路分析: 1.楼梯在1阶时候，没得选择，只能是走一步,走法也就是一种 2.楼梯两阶的时候，可以一步+一步或者一次性两步 (1,1) (2)两种 3.楼梯三阶的时候，我们考虑
+     * 怎样走到3阶的，反正规则就是一次只能走一步或者走两步 a.一次走了一步就到三步了，那么前面就要先走两步了 b.一次走了两步到了三步，那么前面就要走一步
+     *
+     * 对任意的N>=3的时候都有这种关系 dp[n]=dp[n-1]+d[n-2],表示的是剩下一步走到N的情况和剩下走两步走到N的情况，所以要走到N步就是前面两者的和
+     */
+    public int climbStairs(int n) {
+        int oneStep = 1;
+        int twoStep = 2;
+
+        switch (n) {
+            case 1:
+                return oneStep;
+            case 2:
+                return twoStep;
+            default:
+                int[] dp = new int[n];
+                dp[0] = oneStep;
+                dp[1] = twoStep;
+                for (int i = 2; i < n; i++) {
+                    dp[i] = dp[i - 1] + dp[i - 2];
+                }
+                return dp[n - 1];
+        }
+
+
+    }
+}