再见小小ronnie的博客

最优子结构设序列 X = {x1, x2, ..., xm} 和序列 Y = {y1, y2, ... , yn} 的最长公共子序列为 Z  = {z1, z2, ... , zk}， 那么（1）若xm = yn = zk, 则 zk-1也是xm-1和yn-1的LCS（2）若xm!=yn, xm!=zk, 则Z是xm-1和yn的LCS（3）若yn!=xm, yn!=zk, 则Z是x

State machine graph/** * state machine approach * state a(hold): hold stack, sell or rest * state b(sold): just sold stack can only rest * state c(rest): cooldown, buy or rest * translate to for

/** * Similar with 3sum. * Difference is target now becomes -(nums[i]-1), a * and also need a variable diff to save the closest distance * between triplets and targets. */ public class Solution

/** * similar with the Longest Increasing Subsequence (LIS) * let l[i] to be the largest divisible subset ending at index i * to determine l[i+1] we need to do, * i. for every list l[j] in l[1] t

/** * very similar with range sum in 1D array, need a 2D array to save the intermediate values * instantiate a row+1, col+1 array make lot easier* */ public class NumMatrix { private int[][] d

Naive solution. There are many overlapping sub problems.e.g. if we rob(root), we need to know rob(left), rob(right), rob(left.left), rob(left.right), ...then, say if we want to rob(root.left), the

More information. public class Solution { public boolean makesquare(int[] nums) { if (nums == null || nums.length < 4) return false; int sum = 0; for (int num : nums) sum +=

Given a set of positive integers, find if the set can be partitioned into two subsets such that the sum of these two subsets are equal. DFS approach. Sort the array in an increasing order. Create tw

DFS non-DP solution.public class Solution { public List> partition(String s) { List> ret = new ArrayList<>(); List curr = new ArrayList<>(); dfs(0, s, curr, ret)

function f(i) tells the minimum cuts for sub string (0, i).f(0) = 0.f(1) = min(0 if (0, 1) is a palindrome,   f(0)+1 b/c (1, 1) is a palindrome)f(2) = min(0 if (0, 2) is a palindrome,  or f(

/** * allocate an array w[n] to save ways of decryption for a message which length is n * suppose a1a2...an-1 is the first n-1 digits of the encoded message and has w[n-1] ways to decode * then for

/** * let dp[i] be the length of the longest sub-array ending with nums[i] * then dp[n] = dp[m]+1 if nums[n] > nums[m] AND dp[m] is the largest (m is from 1 to n-1) * else dp[n] = 1 */ publi

Catalan numbers./** * # of binary trees = (# of trees on LHS) * (# of choices as root) * (# of trees on RHS) * let c[n] be the total # of binary trees * c[0] = c[1] = 1 * choose 1 as root, no e

/** 1 * 1 2 * 1 2 3 * 1 2 3 4 * from bottom to top, we don't need to consider the last row (b/c if row # equals to 1 there's only one number just return this value), *

/** * given an array 'c[]' represents coins and a target value 'amount' * suppose the solution for 'amount' is sol(a) which refers to minimum # of conins to reach the amount * easy to know sol(a) = mi

@stupidbird911 said in [How does one think up DP solutions for these types of problems?](/post/122697):> Practice on similar questions, think carefully and you would get better understanding. Almost

/** * num binary cnt * 0 0 0 * 1 1 1 * --------------------------------- * 2 10 1+0 * 3 11 1+1 * --------------------

/** * given an array of positive integers and a target * find out if there exists a subset(s) that sum up to the target * subproblems: * 1. the subset includes nums[n] then return isSubsetSum(n-1,

/** * let f(n) to be the count of numbers with unique digits given the length of n * f(1) = 10 * f(2) = f(1) + 9*9, there are 9 choices (1 through 9) to form the first digit, and 9 choices to form

/** * Kadane's algorithm */ public class Solution { public int maxSubArray(int[] nums) { int max_so_far = nums[0]; int max_ending_here = nums[0]; for (int i=1;

/** * k[0] = 1 * k[1] = min(k[0]*2, k[0]*3, k[0]*5) = 2 * k[2] = min(k[1]*2, k[0]*3, k[0]*5) = 3 * k[3] = min(k[1]*2, k[1]*3, k[0]*5) = 5 * k[4] = min(k[1]*2, k[1]*3, k[1]*5) = 4 * ... */ publ

/** * for string c1c2c3c4 ... cn, * check every substring of the string, * substrings may start from c1, c2, c3, ... respectively */ public class Solution { public String longestPalindrome(St