leetcode

Author: beston

src/main/java/code/algorithm/dp/Coin.java

@@ -0,0 +1,32 @@
+package code.algorithm.dp;
+
+/**
+ * 〈钱币表示〉<p>
+ * 有数量不限的硬币，币值为25分、10分、5分和1分，请编写代码计算n分有几种表示法。
+ * 给定一个int n，请返回n分有几种表示法。保证n小于等于100000，为了防止溢出，请将答案Mod 1000000007。
+ *
+ *  地推方程：dp[i] += dp[i-1] + dp[i-5] + dp[i-10] + dp[i-25]
+ *
+ * @author zixiao
+ * @date 2020/3/6
+ */
+public class Coins {
+
+    public int waysToChange(int n) {
+        int[] dp = new int[n+1];
+        dp[0] = 1;
+        int[] coins = new int[]{1, 5 ,10, 25};
+        for(int coin : coins){
+            for(int i=coin; i<=n; i++){
+                dp[i] = (dp[i] + dp[i-coin])%1000000007;
+            }
+        }
+        return dp[n];
+    }
+
+    public static void main(String[] args) {
+        Coins coin = new Coins();
+        System.out.println(coin.waysToChange(30));
+    }
+
+}

src/main/java/code/algorithm/dp/Coins.java

@@ -0,0 +1,30 @@
+package code.algorithm.dp;
+
+/**
+ * 一般解决动态规划问题，分为四个步骤，分别是
+ * 1 问题拆解，找到问题之间的具体联系
+ * 2 状态定义
+ * 3 递推方程推导
+ * 4 实现
+ *
+ * n个1相加的结果： 1+1+1+1+1+1+1+1+1
+ * 问题拆解: 9个1等于8个1+1， 8个1等于7个1+1 ...
+ * 状态变化: 后一个问题的答案 = 前一个问题的答案 + 1，状态的每次变化就是 +1
+ * 递推方程:  dp[i] = dp[i - 1] + 1
+ */
+public class OnePlus {
+
+    public int calc(int n){
+        int[] dp = new int[n+1];
+        dp[0] = 0;
+
+        for (int i = 1; i <= n; i++) {
+            dp[i] = dp[i-1]+1;
+        }
+        return dp[n];
+    }
+
+    public static void main(String[] args) {
+        System.out.println(new OnePlus().calc(8));
+    }
+}

src/main/java/code/algorithm/dp/OnePlus.java

@@ -0,0 +1,25 @@
+package code.algorithm.dp;
+
+/**
+ * 爬楼梯，每次走1或2级，爬完n几台阶 有几种方法
+ * 递推方程：dp[i] = dp[i-1] + dp[i-2]
+ */
+public class StairDp {
+
+    public int f(int n){
+        int dp[] = new int[n+1];
+        dp[0] = 0;
+        dp[1] = 1;
+        dp[2] = 2;
+
+        for (int i = 3; i <= n; i++) {
+            dp[i] = dp[i-1] + dp[i-2];
+        }
+        return dp[n];
+    }
+
+    public static void main(String[] args) {
+        //89
+        System.out.println(new StairDp().f(10));
+    }
+}

src/main/java/code/algorithm/dp/StairDp.java

@@ -0,0 +1,57 @@
+package code.algorithm.leetcode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class P120 {
+
+    public int minimumTotal(List<List<Integer>> triangle) {
+        int n = triangle.size();
+        int[][] dp = new int[n][n];
+
+        //dp最后一行填充 三角形最后一行
+        List<Integer> lastRow = triangle.get(n-1);
+        for (int j = 0; j < n; j++) {
+            dp[n-1][j] = lastRow.get(j);
+        }
+
+        //dp[i][j] = min(dp[i+1][j], dp[i+1][j]) + triangle[i+1][j+1]
+        for (int i=n-2; i>=0; i--){
+            for (int j = 0; j < i+1; j++) {
+                dp[i][j] = Math.min(dp[i+1][j], dp[i+1][j+1]) + triangle.get(i).get(j);
+            }
+        }
+        return dp[0][0];
+    }
+
+    public static void main(String[] args) {
+        //     [2],
+        //    [3,4],
+        //   [6,5,7],
+        //  [4,1,8,3]
+        List<List<Integer>> triangle = new ArrayList<>();
+        List<Integer> row = new ArrayList<>();
+        row.add(2);
+        triangle.add(row);
+
+        row = new ArrayList<>();
+        row.add(3);
+        row.add(4);
+        triangle.add(row);
+
+        row = new ArrayList<>();
+        row.add(6);
+        row.add(5);
+        row.add(7);
+        triangle.add(row);
+
+        row = new ArrayList<>();
+        row.add(4);
+        row.add(1);
+        row.add(8);
+        row.add(3);
+        triangle.add(row);
+
+        System.out.println(new P120().minimumTotal(triangle));
+    }
+}

src/main/java/code/algorithm/leetcode/P120.java

@@ -1,30 +1,44 @@
 package code.algorithm.leetcode;
 
-import java.util.Arrays;
+import org.springframework.util.Assert;
 
 /**
- * 〈一句话功能简述〉<p>
+ * 〈零钱兑换〉<p>
  * 〈功能详细描述〉
+ *  有1,2,5面值的硬币，现在有amount元，想兑换成硬币，最少需要多少枚硬币？
+ *  递推方程： dp[i] = min(dp[i-1]+1, dp[i-2]+1, dp[i-5]+1)
  *
  * @author zixiao
  * @date 2020/1/17
  */
 public class P322 {
 
-    public int coinChange(int[] coins, int amount) {
-        if(coins.length == 0 || amount == 0){
-            return -1;
+    public int coinChange(int[] coins, int amount){
+        int len = amount+1;
+        int[] dp = new int[len];
+        dp[0] = 0;
+
+        for (int i = 1; i <= amount; i++) {
+            int min = len;
+            for (int coin : coins){
+                if(i>=coin && dp[i-coin] != -1){
+                    min = Math.min(min, dp[i-coin]+1);
+                }
+            }
+            dp[i] = min == len ? -1 : min;
         }
-        int maxIdx = coins.length-1;
-        Arrays.sort(coins);
-        int i = maxIdx;
+        return dp[amount];
+    }
 
-        int num = 0;
+    public static void main(String[] args) {
+        P322 p322 = new P322();
+        System.out.println(p322.coinChange(new int[]{2}, 3));
 
-        num += amount/coins[i];
-        amount = amount%coins[i];
+        System.out.println(p322.coinChange(new int[]{1, 2, 5}, 5));
+        System.out.println(p322.coinChange(new int[]{1, 2, 5}, 9));
+        Assert.isTrue(p322.coinChange(new int[]{186,419,83,408}, 6249)==20, "");
 
-        return num;
+        //System.out.println(p322.coinChange(new int[]{2}, Integer.MAX_VALUE));
     }
 
 }

src/main/java/code/algorithm/leetcode/P322.java

@@ -0,0 +1,25 @@
+package code.algorithm.leetcode;
+
+public class P53 {
+
+    public int maxSubArray(int[] nums){
+        if (nums == null || nums.length == 0) {
+            return 0;
+        }
+
+        int n = nums.length;
+        int dp[] = new int[n];
+        dp[0] = nums[0];
+
+        int max = dp[0];
+        for (int i = 1; i < n; i++) {
+            dp[i] = Math.max(dp[i-1]+nums[i], nums[i]);
+            max = Math.max(max, dp[i]);
+        }
+        return max;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(new P53().maxSubArray(new int[]{-2,1,-3,4,-1,2,1,-5,4}));
+    }
+}

src/main/java/code/algorithm/leetcode/P53.java

@@ -103,13 +103,13 @@ private void findSimilar(TrieNode node, String currentStr, List<String> similarL
      * 2、三个指针，p1指向root，p3指向第一个开始匹配敏感字，p2指向当前参与匹配的字
      * @param text
      * @return
+     * @see https://www.cnblogs.com/kubidemanong/p/10834993.html
      */
     public String filterSensitiveWord(String text){
         char[] textArray = text.toCharArray();
         TrieNode p1 = root;
         int p2 = 0;
         int p3 = 0;
-        boolean matching = false;
 
         while (p2 < textArray.length){
             TrieNode next = p1.children.get(textArray[p2]);
@@ -121,29 +121,17 @@ public String filterSensitiveWord(String text){
 
                     //从下一个位置重新开始
                     p2++;
-                    p3++;
+                    p3 = p2;
                     p1 = root;
-                    matching = false;
                 } else {
-                    //匹配中
+                    //继续匹配下个字符
                     p1 = next;
                     p2++;
-                    matching = true;
                 }
-            } else if (matching) {
-                //匹配中，则p2退回上一个词，p3前进到p2位置
-                if(p2 - p3 > 1){ //如果相差1，则会死循环
-                    p2--;
-                }
-                p3 = p2;
-                p1 = root;
-                matching = false;
             } else {
-                //不是匹配中，则从下一个位置重新开始
-                p2++;
                 p3++;
+                p2 = p3;
                 p1 = root;
-                matching = false;
             }
         }
         return new String(textArray);
@@ -198,7 +186,15 @@ public static void main(String[] args) {
         trie.insert("妈了个逼");
 
         System.out.println(trie.filterSensitiveWord("我去你妈了个逼"));
-        System.out.println(trie.filterSensitiveWord("我艹他们，狗日的见鬼了"));
+        System.out.println(trie.filterSensitiveWord("我艹他码，狗日的见鬼了"));
         System.out.println(trie.filterSensitiveWord("我们操场见"));
+
+        //文本 abcdefghi ,以及三个敏感词"de", "bca", "bcf"
+        trie = new TrieChinese();
+        trie.insert("de");
+        trie.insert("bca");
+        trie.insert("bcf");
+        System.out.println(trie.filterSensitiveWord("abcdefghi"));
+
     }
 }

src/main/java/code/algorithm/search/TrieChinese.java

@@ -2,7 +2,9 @@
 
 /**
  * 〈KMP算法〉<p>
- * 〈功能详细描述〉
+ *  Knuth-Morris-Pratt 字符串查找算法，简称为 KMP算法，
+ *  常用于在一个文本串 S 内查找一个模式串 P 的出现位置。
+ * 时间复杂度：O(m+n)
  *
  * @author zixiao
  * @date 2020/1/17
@@ -31,7 +33,6 @@ public boolean match(String string, String pattern) {
 
         //2 移动比较
         while (curS < sArray.length && curP < pArray.length) {
-            //System.out.print("curP: " + curP + "， curS：" + curS);
             if (sArray[curS] == pArray[curP]) {
                 curP++;
                 curS++;
@@ -40,7 +41,6 @@ public boolean match(String string, String pattern) {
                     break;
                 }
                 //移动到nextArray[curP]位置
-                //System.out.print(" next: " + nextArray[curP]);
                 curP = nextArray[curP];
                 //curP指针为-1时
                 if (curP == -1) {
@@ -51,7 +51,6 @@ public boolean match(String string, String pattern) {
                 }
                 move++;
             }
-            //System.out.println();
             compare++;
         }
         boolean match = curP == pArray.length;
@@ -61,7 +60,7 @@ public boolean match(String string, String pattern) {
 
     private int[] getNextArray(char[] pArray) {
         int pLen = pArray.length;
-        //1 前缀后缀的公共元素的最大长度
+        //1 P串所有子字符串的前缀后缀公共元素的最大长度
         int[] maxArray = new int[pLen];
         for (int i = 0; i < pLen; i++) {
             maxArray[i] = getMaxOfPrefixPostfix(pArray, i);