leetcode

Author: beston123

src/main/java/code/algorithm/recall/EightQueen.java renamed to src/main/java/code/algorithm/backtracking/EightQueen.java

@@ -1,4 +1,4 @@
-package code.algorithm.recall;
+package code.algorithm.backtracking;
 
 /**
  * 〈8皇后问题〉<p>

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

@@ -0,0 +1,31 @@
+package code.algorithm.dp;
+
+/**
+ * 〈一句话功能简述〉<p>
+ * 〈功能详细描述〉
+ *
+ * @author zixiao
+ * @date 2020/3/6
+ */
+public class Coin {
+
+    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) {
+        Coin coin = new Coin();
+        coin.waysToChange(30);
+    }
+
+
+
+}

src/main/java/code/algorithm/greedy/TianjiRace.java

@@ -0,0 +1,153 @@
+package code.algorithm.greedy;
+
+import org.springframework.util.Assert;
+
+import java.util.Arrays;
+
+/**
+ * 〈田忌赛马〉<p>
+ * 1、田忌和齐王的马都按从慢到快排序
+ * 2、比较田忌最慢的马比齐王最慢的马
+ *  2.1 如果田忌最慢马慢，则用田忌最慢马与齐王最快马比赛，最小代价输
+ *  2.2 如果田忌最慢马快，则用田忌最慢马与齐王最慢马比赛，必赢
+ *  2.3 如果双方最慢马一样快，则比较田忌最快的马与齐王最快的马
+ *      2.3.1 如果田忌最快马慢，则用田忌最慢马与齐王最快马比赛，最小代价输
+ *      2.3.2 如果田忌最快马快，比较田忌最快的马与齐王最快的马比赛，必赢
+ *      2.3.3 如果双方最快马一样快，则用田忌最慢马与齐王最快马比赛，最小代价输
+ *
+ *  注: 最慢/最快的马都是指剩余未比赛过的马中最快/最慢
+ *
+ * @author zixiao
+ * @date 2020/1/16
+ */
+public class TianjiRace {
+
+    /**
+     * 马数量
+     */
+    private int horseNum;
+
+    /**
+     * 田忌的马
+     */
+    private int[] tianHorses;
+
+    /**
+     * 齐王的马
+     */
+    private int[] kingHorses;
+
+    /**
+     * 田忌马起始位置
+     */
+    private int tianFirst;
+
+    /**
+     * 田忌马终止位置
+     */
+    private int tianLast;
+
+    /**
+     * 齐王马起始位置
+     */
+    private int kingFirst;
+
+    /**
+     * 齐王马终止位置
+     */
+    private int kingLast;
+
+    /**
+     * 田忌得分
+     */
+    private int tianScore;
+
+    public void startRace(int[] tHorses, int[] kHorses){
+        Assert.isTrue(tHorses.length == kHorses.length, "");
+        this.horseNum = tHorses.length;
+        this.tianHorses = tHorses;
+        this.kingHorses = kHorses;
+
+        //从慢到快排序
+        Arrays.sort(this.tianHorses);
+        Arrays.sort(this.kingHorses);
+
+        tianScore = 0;
+        tianFirst = kingFirst = 0;
+        tianLast = kingLast = horseNum - 1;
+
+        System.out.println("*********** Start horse race ************");
+
+        for (int i = 0; i < horseNum; i++) {
+            race();
+        }
+
+        System.out.println("Tianji score: " + tianScore);
+    }
+
+    private void race(){
+        //1 比较田忌最慢的马与齐王最慢的马
+        int compare = tianHorses[tianFirst] - kingHorses[kingFirst];
+        if(compare < 0){
+            //1.1 如果田忌最慢马慢，则用田忌最慢马与齐王最快马比赛，最小代价输
+            race(tianHorses[tianFirst], kingHorses[kingLast]);
+            tianFirst++;
+            kingLast--;
+        }else if(compare > 0){
+            //1.2 如果田忌最慢马快，则用田忌最慢马与齐王最慢马比赛，必赢
+            race(tianHorses[tianFirst], kingHorses[kingFirst]);
+            tianFirst++;
+            kingFirst++;
+        }else {
+            //1.3 比较田忌最快的马与齐王最快的马
+            int compareFast = tianHorses[tianLast] - kingHorses[kingLast];
+            if(compareFast < 0){
+                //1.3.1 如果田忌最快马慢，则用田忌最慢马与齐王最快马比赛，最小代价输
+                race(tianHorses[tianFirst], kingHorses[kingLast]);
+                tianFirst++;
+                kingLast--;
+            }else if(compareFast > 0){
+                //1.3.2 如果田忌最快马快，比较田忌最快的马与齐王最快的马比赛，必赢
+                race(tianHorses[tianLast], kingHorses[kingLast]);
+                tianLast--;
+                kingLast--;
+            }else{
+                //1.3.3 如果双方最快马一样快，则用田忌最慢马与齐王最快马比赛，最小代价输
+                race(tianHorses[tianFirst], kingHorses[kingLast]);
+                tianFirst++;
+                kingLast--;
+            }
+        }
+    }
+
+    /**
+     * 比赛，赢加1分，输减1分，平局0分
+     * @param tianHorse
+     * @param kingHorse
+     */
+    private void race(int tianHorse, int kingHorse){
+        System.out.println(tianHorse + " => " + kingHorse);
+        if(tianHorse > kingHorse){
+            tianScore++;
+        }else if(tianHorse < kingHorse){
+            tianScore--;
+        }
+    }
+
+    /**
+     *
+     * @param args
+     */
+    public static void main(String[] args) {
+        TianjiRace race = new TianjiRace();
+        // 30 20 10 : 35 25 15
+        race.startRace(new int[]{30, 20, 10}, new int[]{35, 25, 15});
+
+        // 10 20 30 : 10 20 30
+        race.startRace(new int[]{10, 20, 30}, new int[]{10, 20, 30});
+
+        // 8 20 31 : 10 20 30
+        race.startRace(new int[]{8, 20, 31}, new int[]{10, 20, 30});
+
+    }
+}

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

@@ -0,0 +1,93 @@
+package code.algorithm.leetcode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 〈和为s的连续正数序列〉<p>
+ * 输入一个正整数 target ，输出所有和为 target 的连续正整数序列（至少含有两个数）。
+ * 序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。
+ *
+ * 示例 1：
+ * 输入：target = 9
+ * 输出：[[2,3,4],[4,5]]
+ *
+ * 示例 2：
+ * 输入：target = 15
+ * 输出：[[1,2,3,4,5],[4,5,6],[7,8]]
+ *  
+ * 限制：
+ * 1 <= target <= 10^5
+ *
+ * 链接：https://leetcode-cn.com/problems/he-wei-sde-lian-xu-zheng-shu-xu-lie-lcof
+ *
+ * @author zixiao
+ * @date 2020/3/6
+ */
+public class M57 {
+
+    static class MN {
+        int m;
+        int n;
+
+        public MN(int m, int n) {
+            this.m = m;
+            this.n = n;
+        }
+    }
+
+    public int[][] findContinuousSequence(int target) {
+        if (target <= 2 || target == 4) {
+            return new int[0][];
+        }
+        int max = (target+1)/2;
+        int l = 1;
+        int r = 2;
+        int sum = 0;
+        for (; l<max; l++){
+            sum = l;
+            for(; r<=max; r++){
+
+            }
+        }
+
+
+        return new int[0][];
+    }
+
+    public int[][] findContinuousSequence1(int target) {
+        if (target <= 2 || target == 4) {
+            return new int[0][];
+        }
+
+        List<MN> mnList = new ArrayList();
+        int maxN = (target + 1) / 2;
+        for (int m = 1; m < maxN; m++) {
+            for (int n = m + 1; n <= maxN; n++) {
+                if ((m + n) * (n - m + 1) / 2 == target) {
+                    mnList.add(new MN(m, n));
+                    break;
+                }
+            }
+        }
+        if (!mnList.isEmpty()) {
+            int[][] result = new int[mnList.size()][];
+            for (int i = 0; i < mnList.size(); i++) {
+                MN mn = mnList.get(i);
+                result[i] = new int[mn.n - mn.m + 1];
+                for (int j = mn.m, k = 0; j <= mn.n; j++, k++) {
+                    result[i][k] = j;
+                }
+            }
+            return result;
+        }
+        return new int[0][];
+    }
+
+    public static void main(String[] args) {
+        M57 m57 = new M57();
+       // m57.findContinuousSequence(1);
+        m57.findContinuousSequence(9);
+    }
+
+}

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

@@ -0,0 +1,80 @@
+package code.algorithm.leetcode;
+
+/**
+ * 〈一句话功能简述〉<p>
+ * 〈功能详细描述〉
+ *
+ * @author zixiao
+ * @date 2020/3/5
+ */
+public class P1103 {
+
+    public int[] distributeCandies(int candies, int num) {
+        int[] ans = new int[num];
+
+        int round = 0;
+        int remain = candies;
+        int num_x_num = num * num;
+        int n_n_2 = (num_x_num + num) / 2;
+        while (remain > 0) {
+            int cost = round * num_x_num + n_n_2;
+            if (remain >= cost) {
+                remain -= cost;
+                round++;
+            } else {
+                break;
+            }
+        }
+
+        if (round == 0) {
+            for (int i = 0; i < num; i++) {
+                if (remain == 0) {
+                    break;
+                }
+                ans[i] = Math.min(i + 1, remain);
+                remain -= ans[i];
+            }
+            return ans;
+        }
+
+        int round_x_num = round * num;
+        int rrn2 = (round - 1) * round_x_num / 2;
+        for (int i = 0; i < num; i++) {
+            ans[i] = rrn2 + (i + 1) * round;
+        }
+
+        if (remain > 0) {
+            for (int i = 0; i < num; i++) {
+                if (remain == 0) {
+                    break;
+                }
+                int add = Math.min(round_x_num + i + 1, remain);
+                ans[i] += add;
+                remain -= add;
+            }
+        }
+
+        return ans;
+    }
+
+    public static void main(String[] args) {
+        P1103 solution = new P1103();
+        for (int i : solution.distributeCandies(7, 4)) {
+            System.out.print(i + ",");
+        }
+        System.out.println();
+
+        for (int i : solution.distributeCandies(10, 3)) {
+            System.out.print(i + ",");
+        }
+        System.out.println();
+
+        for (int i : solution.distributeCandies(13, 3)) {
+            System.out.print(i + ",");
+        }
+        System.out.println();
+
+        System.out.println(6>>1);
+    }
+
+}