“剑指Offer”动态规划篇：java实现

1. 最长不含重复字符的子字符串

/**
 * 【动态规划】解题思路：定义函数f(i)表示以第i个字符为结尾的不包含重复字符的子字符串的最大长度
 * I. 如果第i个字符之前没有出现过，f(i) = f(i-1) + 1;
 * II. 如果第i个字符之前已经出现过：第i个字符和它上次出现在字符串中的位置的距离记为d
 *      (1) 如果 d <= f(i-1)，则f(i) = d；
 *      (2) 如果 d > f(i)，则f(i) = f(i-1) + 1。
 */
public class Offer48_LongestSubString {
    public int longestSubString(String str) {
        int curLen = 0;
        int maxLen = 0;
        int[] prePosition = new int[26]; //当前字符上次出现在字符串中的位置
        Arrays.fill(prePosition, -1); //初始化为-1
        for (int i = 0; i < str.length(); i++) {
            int preIndex = prePosition[str.charAt(i) - 'a'];
            if (preIndex < 0 || i - preIndex > curLen) {
                curLen++;
            } else {
                maxLen = Math.max(curLen, maxLen);
                curLen = i - preIndex;
            }
            prePosition[str.charAt(i) - 'a'] = i;
        }
        maxLen = Math.max(curLen, maxLen);
        return maxLen;
    }

    public static void main(String[] args) {
        Offer48_LongestSubString offer48 = new Offer48_LongestSubString();
        String str = "arabcacfr";
        System.out.println(offer48.longestSubString(str));
    }
}

2. n个骰子点数和的所有可能的值及出现概率

/**
 * 【动态规划】解题思路：定义函数f(i,j)为前i个骰子点数之和为j的所有可能情况的总数
 * f(i,j) = f(i-1,j-1) + f(i-1,j-2) + f(i-1,j-3) + f(i-1,j-4) + f(i-1,j-5) + f(i-1,j-6)
 */
public class Offer60_PrintProbabilityOfDiceSum {
    public Map<Integer, Double> PrOfDiceSum(int num) {
        Map<Integer, Double> result = new HashMap<>();
        if (num <= 0) {
            return result;
        }
        final int MAX_POINT = 6;
        int[][] occurNum = new int[2][MAX_POINT * num + 1];
        int flag = 0;
        for (int i = 1; i <= MAX_POINT; i++) {
            occurNum[0][i] = 1;
        }
        for (int i = 2; i <= num; i++) {
            for (int j = 0; j <= MAX_POINT * i; j++) {
                occurNum[1 - flag][j] = 0; //旋转数组清零
            }
            for (int j = i; j <= MAX_POINT * i; j++) {
                for (int k = 1; k <= MAX_POINT && k <= j; k++) {
                    occurNum[1 - flag][j] += occurNum[flag][j - k];
                }
            }
            flag = 1 - flag;
        }
        final double TOTAL_NUM = Math.pow(MAX_POINT, num);
        for (int i = num; i <= MAX_POINT * num; i++) {
            result.put(i, occurNum[flag][i] / TOTAL_NUM);
        }
        return result;
    }

    public static void main(String[] args) {
        Offer60_PrintProbabilityOfDiceSum offer60 = new Offer60_PrintProbabilityOfDiceSum();
        Map<Integer, Double> probability = offer60.PrOfDiceSum(2);
        System.out.println(probability.toString());
    }
}