常用算法解析-动态规划

import java.util.HashMap;

/**
 * 
 *原文链接： https://wx.abbao.cn/a/4736-4b66e5f9ec584ee0.html
 * 
 * 走楼梯问题：有一座高度是10级台阶的楼梯，从下往上走，每跨一步只能向上1级或者2级台阶。要求用程序来求出一共有多少种走法。
 * 
 * 這是一道入门级的动态递归问题
 * 
 * 问题分析：
 * 
 * 最有子结构： 最后一步走到第十层有多少种方法？2种：8-》10；9-》10 那么如果走到 8 有x种情况，走到9有y中情况 走到10可以看成x+y
 * 
 * 状态转移方程 若用公式表达f(10)=f(9)+f(8) 既 f(n) = f(n-1) + f(n-2)
 * 
 * 边界 走到第二层可以走一步，也可以走俩步。即f(2) = 2 第一层只能走一步 f(1) =1
 * 
 * 以上是问题建模 解析来是问题求解
 */
public class WalkStair {
    public static void main(String[] args) {
        System.out.println(getWayStair1(10));
        System.out.println(getWayStair2(10, new HashMap<Integer, Integer>()));
        System.out.println(getWayStair3(10));
    }

    /**
     * 第一种思路：用递归的方式
     * 
     * @param n n层楼梯
     * 
     *          这里需要注意一下复杂度问题 这个二叉树长度n-1,节点2^n-1,时间复杂度2^n
     */
    public static int getWayStair1(int n) {
        if (n == 1) {
            return 1;
        }
        if (n == 2) {
            return 2;
        }
        return getWayStair1(n - 1) + getWayStair1(n - 2);
    }

    /**
     * 第二种思路：还是递归，但是重复的计算几点可以不在计算，叫做备忘录算法 利用map将已经计算过的节点保存
     * 
     * 时间复杂度是 o(n)
     * 
     * @param n
     * @param map
     * @return
     */
    public static int getWayStair2(int n, HashMap<Integer, Integer> map) {
        if (n == 1) {
            return 1;
        }
        if (n == 2) {
            return 2;
        }
        if (map.containsKey(n)) {
            return map.get(n);
        } else {
            int value = getWayStair1(n - 1) + getWayStair1(n - 2);
            map.put(n, value);
            return value;
        }
    }

    /**
     * 第三种思路：动态规划，每次得到的结果只是上俩次结果的和 时间复杂度o(n) 空间复杂度o（1）
     * 
     * @param n
     * @return
     */
    public static int getWayStair3(int n) {
        if (n == 0) {
            return 0;
        }
        if (n == 1) {
            return 1;
        }
        if (n == 2) {
            return 2;
        }

        int a = 1;
        int b = 2;
        int temp = 0;
        for (int i = 3; i <= n; i++) {
            temp = a + b;
            a = b;
            b = temp;
        }
        return temp;
    }
}

/**
 * 问题描述：十个人挖五座金矿，求挖到的最多的金子个数
 * 
 * 思路： 最优子结构： ‘1：第五座金矿挖 ’2：第五座金矿不挖 边界： ‘1：挖一座金矿 人数够 ’2：挖一座金矿人数不够 状态转移方程
 *
 */
public class GoldMiner {
    /**
     * 
     * @param n 前 n 座矿
     * @param w 工人个数
     * @param p 每座矿需要的工人个数
     * @param g 每座矿的金子个数
     * @return
     */
    public static int getMaxGold(int n, int w, int p[], int g[]) {

        // ‘前三个if是边界值
        if (n < 1) {
            return 0;
        }
        if (n == 1 && w < p[0]) {
            return 0;
        }
        if (n == 1 && w >= p[0]) {
            return g[0];
        }

        // ’这里是初始化结果
        int[] preResult = new int[w + 1];
        int[] result = new int[w + 1];
        for (int i = 0; i < w; i++) {
            if (w >= p[0]) {
                preResult[i] = g[0];
            } else {
                preResult[i] = 0;
            }
        }

        /**
         * ‘外层循环控制挖第几座金矿，内层第一层循环控制可能挖的最优结果，内层第二层循环刷新可能获得最优结果，最後返回當前人人数能挖的最优结果
         */
        for (int i = 0; i < n; i++) {
            for (int j = 0; j <= w; j++) {
                if (j < p[i]) {
                    result[j] = preResult[j];
                } else {
                    result[j] = Math.max(preResult[j], preResult[j - p[i]] + g[i]);
                }
            }
            for (int j = 0; j <= w; j++) {
                preResult[j] = result[j];
            }
        }
        return result[w];
    }

    public static void main(String[] args) {
        int[] g = { 400, 500, 200, 300, 350 };
        int[] p = { 5, 5, 3, 4, 3 };
        System.out.println(getMaxGold(5, 10, p, g));
    }
}

import java.util.ArrayList;
import java.util.List;

/**
 * 问题：
 * Given a non-empty string s and a dictionary wordDict containing a list of
 * non-empty words, determine if s can be segmented into a space-separated
 * sequence of one or more dictionary words.
 *
 */
public class Lc139 {
    /**
     * 思路：dp 上一个串的位置到当前截取串的位置恰好是一个字典串
     * @param s
     * @param wordDict
     * @return
     */
    public static boolean wordBreak(String s, List<String> wordDict) {
        boolean[] dp = new boolean[s.length() + 1];
        dp[0] = true;

        for (int i = 1; i < dp.length; i++) {
            for (int j = 0; j < i; j++) {
                if (true == dp[j] && wordDict.contains(s.substring(j, i))) {
                    dp[i] = true;
                }
            }
        }
        return dp[s.length()];
    }

    public static void main(String[] args) {
        String s = "leetcode";
        String s1 = "leet";
        String s2 = "code";
        List<String> wordDict = new ArrayList<String>();
        wordDict.add(s1);
        wordDict.add(s2);
        System.out.println(wordBreak(s, wordDict));
    }
}