SP Archives - Huahua's Tech Road

花花酱 Min Heap SP21

zxi — Wed, 18 Nov 2020 09:30:19 +0000

C++

// Author: Huahua
#include 

#include 
#include 

using namespace std;

class MinHeap {
public:
  // Return the min element.
  int peek() const { return data_[0]; }

  // Extract the min element.
  int pop() {
    // Swap the min element with the last one. O(1)
    swap(data_.back(), data_[0]);
    // Get the min element. O(1)
    int min_el = data_.back();
    // Evict the min element. O(1)
    data_.pop_back();
    // Maintain heap property. θ(logn)
    heapifyDown(0);
    return min_el;
  }

  // Add a new element to the heap.
  void push(int key) {
    // Add the element to the end of the array. O(1)
    data_.push_back(key);
    // Maintain heap property. θ(logn)
    heapifyUp(data_.size() - 1);
  }

  // Return the size of the heap.
  int size() const { return data_.size(); }
private:
  void heapifyUp(int index) {
    // Stop at root.
    if (index == 0) return;
    int parent = (index - 1) / 2;
    // Stop if greater or euqal to parent.
    if (data_[index] >= data_[parent]) return;
    // Swap with parent.
    swap(data_[index], data_[parent]);
    // Continue heapifyUp on parent.
    heapifyUp(parent);
  }

  void heapifyDown(int index) {
    int left = index * 2 + 1;
    int right = index * 2 + 2;
    // Stop if has no left child.
    if (left >= data_.size()) return;
    // Get the min child.
    int min_child = 
      right < data_.size() && data_[right] < data_[left] ? right : left;
    // Stop if less or euqal to min child.
    if (data_[index] <= data_[min_child])
      return;
    // Swap with min child.
    swap(data_[index], data_[min_child]);
    // Continue heapifyDown on min_child.
    heapifyDown(min_child);
  }

  vector data_;
};

int main() {
  vector data{5,1,3,5,3,4,3,7};
  MinHeap heap;
  for (int x : data)
    heap.push(x);
  vector output;
  while (heap.size())
    output.push_back(heap.pop());
  assert(output == vector({1,3,3,3,4,5,5,7}));
}

Python3

# Author: Huahua
class MinHeap:
  def __init__(self, data = None):
    self.data = list(data) if data else []
    for i in range((len(self.data)) // 2, -1, -1):
      self.heapifyDown(i)

  def push(self, key):
    self.data.append(key)
    self.heapifyUp(len(self.data) - 1)
 
  def pop(self):
    self.swap(0, -1)
    min_el = self.data.pop()
    self.heapifyDown(0)
    return min_el
 
  def size(self):
    return len(self.data)
 
  def swap(self, i, j):
    self.data[i], self.data[j] = self.data[j], self.data[i]
 
  def heapifyDown(self, i):
    smallest = i
    for c in [2 * i + 1, 2 * i + 2]:
      if c < self.size() and self.data[c] < self.data[smallest]: smallest = c
    if smallest != i:
      self.swap(i, smallest)
      self.heapifyDown(smallest)
 
  def heapifyUp(self, i):
    if i == 0: return
    parent = (i - 1) // 2
    if self.data[i] >= self.data[parent]: return
    self.swap(i, parent)
    self.heapifyUp(parent)

def test():
  data = [5,1,3,5,3,4,3,7]
  heap = MinHeap()
  for x in data: heap.push(x)
  output = []
  while heap.size():
    output.append(heap.pop())
  assert output == sorted(data)

def testBuildHeap():
  data = [5,1,3,5,3,4,3,7]
  heap = MinHeap(data)
  output = []
  while heap.size():
    output.append(heap.pop())
  assert output == sorted(data)

def main():
  test()
  testBuildHeap()
 
if __name__ == '__main__':
  main()

The post 花花酱 Min Heap SP21 appeared first on Huahua's Tech Road.

Fast Power for DP SP20

zxi — Thu, 16 Apr 2020 03:37:45 +0000

Iterative DP usually takes O(n) to compute dp[n] from dp[0], we could do better if the problem can be written as matrix multiplication. With fast power, dp[n] can be computed in O(logn)

The post Fast Power for DP SP20 appeared first on Huahua's Tech Road.

KMP Algorithm SP19

zxi — Wed, 01 Apr 2020 03:29:45 +0000

KMP Algorithm, KMP 字符串搜索算法

Time complexity: O(m+n)
Space complexity: O(m)

Implementation

C++

#include 
#include 
using namespace std;

// Author: Huahua
namespace KMP {
vector Build(const string& p) {
  const int m = p.length();
  vector nxt{0, 0};
  for (int i = 1, j = 0; i < m; ++i) {
    while (j > 0 && p[i] != p[j])
      j = nxt[j];
    if (p[i] == p[j])
      ++j;
    nxt.push_back(j);
  }
  return nxt;
}

vector Match(const string& s, const string& p) {
  vector nxt(Build(p));
  vector ans;
  const int n = s.length();
  const int m = p.length();
  for (int i = 0, j = 0; i < n; ++i) {
    while (j > 0 && s[i] != p[j])
      j = nxt[j];
    if (s[i] == p[j])
      ++j;
    if (j == m) {
      ans.push_back(i - m + 1);
      j = nxt[j];
    }
  }
  return ans;
}
};  // namespace KMP

void CheckEQ(const vector& actual, const vector& expected) {
  if (actual != expected) {
    std::cout << "expected:";
    for (int v : expected)
      std::cout << " " << v;
    std::cout << " actual:";
    for (int v : actual)
      std::cout << " " << v;
    std::cout << std::endl;
  } else {
    std::cout << "PASS" << std::endl;
  }
}

int main(int argc, char** argv) {
  CheckEQ(KMP::Build("ABCDABD"), {0, 0, 0, 0, 0, 1, 2, 0});
  CheckEQ(KMP::Build("AB"), {0, 0, 0});
  CheckEQ(KMP::Build("A"), {0, 0});
  CheckEQ(KMP::Build("AA"), {0, 0, 1});
  CheckEQ(KMP::Build("AAA"), {0, 0, 1, 2});
  CheckEQ(KMP::Build("AABA"), {0, 0, 1, 0, 1});
  CheckEQ(KMP::Match("ABC ABCDAB ABCDABCDABDE", "ABCDABD"), {15});
  CheckEQ(KMP::Match("ABC ABCDAB ABCDABCDABDE", "AB"), {0, 4, 8, 11, 15, 19});
  CheckEQ(KMP::Match("ABC ABCDAB ABCDABCDABDE", "B"), {1, 5, 9, 12, 16, 20});
  CheckEQ(KMP::Match("AAAAA", "A"), {0, 1, 2, 3, 4});
  CheckEQ(KMP::Match("AAAAA", "AA"), {0, 1, 2, 3});
  CheckEQ(KMP::Match("AAAAA", "AAA"), {0, 1, 2});
  CheckEQ(KMP::Match("ABC", "ABC"), {0});
  return 0;
}

Python3

#!/usr/bin/env python3
from typing import List

# Author: Huahua


def Build(p: str) -> List[int]:
    m = len(p)
    nxt = [0, 0]
    j = 0
    for i in range(1, m):
        while j > 0 and p[i] != p[j]:
            j = nxt[j]
        if p[i] == p[j]:
            j += 1
        nxt.append(j)
    return nxt


def Match(s: str, p: str) -> List[int]:
    n, m = len(s), len(p)
    nxt = Build(p)
    ans = []
    j = 0
    for i in range(n):
        while j > 0 and s[i] != p[j]:
            j = nxt[j]
        if s[i] == p[j]:
            j += 1
        if j == m:
            ans.append(i - m + 1)
            j = nxt[j]
    return ans


def CheckEQ(actual, expected):
    if actual != expected:
        print('actual: %s, expected: %s' % (actual, expected))
    else:
        print('Pass')


if __name__ == "__main__":
    CheckEQ(Build("ABCDABD"), [0, 0, 0, 0, 0, 1, 2, 0])
    CheckEQ(Build("AB"), [0, 0, 0])
    CheckEQ(Build("A"), [0, 0])
    CheckEQ(Build("AA"), [0, 0, 1])
    CheckEQ(Build("AAAA"), [0, 0, 1, 2, 3])
    CheckEQ(Build("AABA"), [0, 0, 1, 0, 1])
    CheckEQ(Match("ABC ABCDAB ABCDABCDABDE", "ABCDABD"), [15])
    CheckEQ(Match("ABC ABCDAB ABCDABCDABDE", "AB"), [0, 4, 8, 11, 15, 19])
    CheckEQ(Match("ABC ABCDAB ABCDABCDABDE", "B"), [1, 5, 9, 12, 16, 20])
    CheckEQ(Match("AAAAA", "A"), [0, 1, 2, 3, 4])
    CheckEQ(Match("AAAAA", "AA"), [0, 1, 2, 3])
    CheckEQ(Match("AAAAA", "AAAA"), [0, 1])
    CheckEQ(Match("AAAAA", "AAAAA"), [0])
    CheckEQ(Match("AABAABA", "AABA"), [0, 3])

Applications

LeetCode 28. strStr()

C++

// Author: Huahua
class Solution {
public:
  int strStr(string haystack, string needle) {
    if (needle.empty()) return 0;
    auto matches = KMP::Match(haystack, needle);
    return matches.empty() ? -1 : matches[0];
  }
};

LeetCode 459. Repeated Substring Pattern

C++

// Author: Huahua
class Solution {
public:
  bool repeatedSubstringPattern(string str) {
    const int n = str.length();
    auto nxt = KMP::Build(str);
    return nxt[n] && nxt[n] % (n - nxt[n]) == 0;
  }
};

1392. Longest Happy Prefix

C++

// Author: Huahua
class Solution {
public:
  string longestPrefix(const string& s) {    
    return s.substr(0, KMP::Build(s).back());
  }
};

The post KMP Algorithm SP19 appeared first on Huahua's Tech Road.

花花酱 Minimum Spanning Tree (MST) 最小生成树 SP18

zxi — Fri, 24 Jan 2020 15:59:23 +0000

Prim’s Algorithm

Time complexity: O(ElogV)
Space complexity: O(V+E)

C++

// Author: Huahua
#include 
#include 
#include 
using namespace std;

int main(int argc, char** argv) {
  const int n = 4;
  vector> edges{{0,1,1},{0,3,3},{0,2,6},{2,3,2},{1,2,4},{1,3,5}};
  vector>> g(n);
  for (const auto& e : edges) {
    g[e[0]].emplace_back(e[1], e[2]);
    g[e[1]].emplace_back(e[0], e[2]);
  }

  priority_queue> q; // (-w, v)
  vector seen(n);
  q.emplace(0, 0); // (-w, v)

  int cost = 0;
  for (int i = 0; i < n; ++i) {
    while (true) {
      const int w = -q.top().first;
      const int v = q.top().second;
      q.pop();
      if (seen[v]++) continue;
      cost += w;
      for (const auto& p : g[v]) {
        if (seen[p.first]) continue;
        q.emplace(-p.second, p.first);
      }
      break;
    }
  }
  cout << cost << endl;
  return 0;
}

Python

# Author: Huahua
from collections import defaultdict
from heapq import *

n = 4
edges = [[0,1,1],[0,3,3],[0,2,6],[2,3,2],[1,2,4],[1,3,5]]
g = defaultdict(list)
for e in edges:
  g[e[0]].append((e[1], e[2]))
  g[e[1]].append((e[0], e[2]))

q = []
cost = 0
seen = set()
heappush(q, (0, 0))
for _ in range(n):
  while True:
    w, u = heappop(q)
    if u in seen: continue  
    cost += w
    seen.add(u)
    for v, w in g[u]:
      if v in seen: continue
      heappush(q, (w, v))
    break

print(cost)

Kruskal’s Algorithm

Time complexity: O(ElogV)
Space complexity: O(V+E)

C++

// Author: Huahua
#include 
#include 
#include 
#include 
#include 
using namespace std;

int main(int argc, char** argv) {
  const int n = 4;
  vector> edges{{0,1,1},{0,3,3},{0,2,6},{2,3,2},{1,2,4},{1,3,5}};    
  vector> q; // (w, u, v)  
  for (const auto& e : edges)    
    q.push_back({e[2], e[0], e[1]});
  sort(begin(q), end(q));

  vector p(n);
  iota(begin(p), end(p), 0);

  function find = [&](int x) {
    return x == p[x] ? x : p[x] = find(p[p[x]]);
  };

  int cost = 0;
  for (const auto& t : q) {    
    int w = t[0], u = t[1], v = t[2];      
    int ru = find(u), rv = find(v);      
    if (ru == rv) continue;
    p[ru] = rv; // merge (u, v)      
    cost += w;
  }  
  cout << cost << endl;

  return 0;
}

Python

from collections import defaultdict
from heapq import *

n = 4
edges = [[0,1,1],[0,3,3],[0,2,6],[2,3,2],[1,2,4],[1,3,5]]
p = list(range(n))


def find(x):
  if x != p[x]: p[x] = find(p[p[x]])
  return p[x]

cost = 0
for u, v, w in sorted(edges, key=lambda x: x[2]):
  ru, rv = find(u), find(v)
  if ru == rv: continue
  p[ru] = rv
  cost += w

print(cost)

The post 花花酱 Minimum Spanning Tree (MST) 最小生成树 SP18 appeared first on Huahua's Tech Road.

花花酱 Binary Search II SP17

zxi — Sat, 20 Apr 2019 16:48:35 +0000

Binary Search I SP5

For the given function g(x) and a range [l, r] find the smallest int number m such that g(m) is True, if not found, return r + 1.

The post 花花酱 Binary Search II SP17 appeared first on Huahua's Tech Road.

LeetCode 进入千题时代该如何刷题？

zxi — Sat, 16 Feb 2019 18:15:46 +0000

题目列表：https://bit.ly/2E8yBHq

总结一下：

大家的刷题经验都比我丰富，找到最适合自己的方法就好了
200～300题刷2-3边，至少100+小时的投入
同一类型题目一起刷，总结规律和差异
多看别人的（优秀）代码
完整的手写实现，不要copy代码，增强肌肉记忆（视频中没提到）
培养代码风格

The post LeetCode 进入千题时代该如何刷题？ appeared first on Huahua's Tech Road.

花花酱 Segment Tree 线段树 SP14

zxi — Wed, 30 Jan 2019 16:41:06 +0000

Segment tree is a balanced binary tree with O(logn) height given n input segments.
Segment tree supports fast range query O(logn + k), and update O(logn).
Building such a tree takes O(n) time if the input is an array of numbers.

Tree之所以大行其道就是因为其结构和人类组织结构非常接近。就拿公司来说好了，CEO统领全局(root)，下面CTO，CFO等各自管理一个部门，每个部门下面又正好有好两个VP，每个VP下面又有两个director，每个director下面又有2个manager，每个manager下面又有2个底层员工(leaf)，为什么是2？因为我们用二叉树啊~

故事还是要从LeetCode 307. Range Sum Query – Mutable说起。

题目大意是：给你一个数组，再给你一个范围，让你求这个范围内所有元素的和，其中元素的值是可变的，通过update(index, val)更新。

nums = [1, 3, 5]，
sumRange(0, 2) = 1+3+5 = 9
update(1, 2) => [1, 2, 5]
sumRange(0, 2) = 1 + 2 + 5 = 7

暴力求解就是扫描一下这个范围。

时间复杂度：Update O(1), Query O(n)。

如果数组元素不变的话（303题），我们可以使用动态规划求出前n个元素的和然后存在sums数组中。i到j所有元素的和等于0~j所有元素的和减去0~(i-1)所有元素的和，即：

sumRange(i, j) := sums[j] – sums[i – 1] if i > 0 else sums[j]

这样就可以把query的时间复杂度降低到O(1)。

但是这道题元素的值可变，那么就需要维护sums，虽然可以把query的时间复杂度降低到了O(1)，但update的时间复杂度是O(n)，并没有比暴力求解快。

这个时候就要请出我们今天的主人公Segment Tree了，可以做到

Update: O(logn)，Query: O(logn+k)

其实Segment Tree的思想还是很好理解的，比我们之前讲过的Binary Indexed Tree要容易理解的多（回复 SP3 获取视频），但是代码量又是另外一回事情了…

回到一开始讲的公司组织结构上面，假设一个公司有200个底层员工，

最原始的信息（元素的值）只掌握在他们工手里，层层上报。每个manager把他所管理的人的元素值求和之后继续上报，直到CEO。CEO知道但仅知道0-199的和。

当你问CEO，5到199的和是多少？他手上只有0-199的和，一下子慌了，赶紧找来CTO，CFO说你们把5到199的和给报上来，CFO一看报表，心中暗喜：还好我负责的这个区间(100~199)已经计算过了，就直接把之前的总和上报了。CTO一看报表，自己负责0-99这个区间，只知道0-99的和，但5-99的和，还是问下面的人吧… 最后结果再一层层返回给CEO。

说到这里大家应该已经能想象Segment Tree是怎么工作了吧：

每个leaf负责一个元素的值

每个parent负责的范围是他的children所负责的范围的union，并把所有范围内的元素值相加。

同一层的节点没有overlap。

root存储的是所有元素的和。

所以一个SegmentTreeNode需要记录以下信息

start #起始范围
end #终止范围
mid #拆分点，通常是 (start + end) // 2
val #所有子元素的和
left #左子树
right #右子树

Update: 由于每次只更新一个元素的值，所以CEO知道这个员工是哪个人管的，派发下去就行了，然后把新的结果再返回回来。

def update(root, index, val):
  # 到底层员工了，直接更新
  if root.start == index and root.end == index:
    root.val = val
    return
  # 根据拆分点，更新左子树或右子树
  if val <= root.mid:
    update(root.left, index, val)
  else:
    update(root.right, index, val)
  # 重新计算和
  root.val = root.left?.val + root.right?.val

T(n) = T(n/2) + 1 => O(logn)

Query: query的range可以是任意的，就有以下三种情况：

case 1: 这个range正好和我负责的range完全相同。比如sumQuery(CTO, 0, 99)，这个时候CTO直接返回已经求解过的所有下属的和即可。

case 2: 这个range只由我其中一个下属负责。比如sumQuery(CEO, 0, 10)，CEO知道0~10全部由CFO负责，那么他就直接返回sumQuery(CTO, 0, 10)。

case 3: 这个range覆盖了我的两个下属，那么我就需要调用2次。比如sumQuery(CEO, 80, 120)，CEO知道0~99由CTO管，100~199由CFO管，所以他只需要返回：

sumQuery(CTO, 80, 99) + sumQuery(CFO, 100, 120)

由此可见sumQuery的时间复杂度是不确定的，运气好时O(1)，运气不好时是O(logn+k)，k是需要访问的节点的数量。

我做了一个实验，给定N，尝试所有的(i,j)组合，看sumQuery的最坏情况和平均情况，结果如下图：

Query需要访问到的节点数量的worst和average case。Worst case 大约访问 4*logn – 3 个节点，这个数字远远小于n。和n成对数关系。

虽然不像Binary Indexed Tree query是严格的O(logn)，但Segment tree query的worst case增长的非常慢，可以说是对数级别的。当N是2^20的时候，worst case也“只需要”访问77个节点。

最后我们再来讲一下这棵树是怎么创建的，其实方法有很多种，一分为二是比较常规的一种做法。

CEO管200人，那么就找2个人(CTO，CFO各管100人。CTO管100人，再找2个VP各管50人，以此类推，直到manager管2个人，2个人都是底层员工(leaf)，没有人管（双关）。

def buildTree(start, end):
  # 超过范围返回空节点
  if start > end: return None
  boss.start = start
  boss.end = end
  # 如果是叶子节点，记录元素的值
  if start == end: boss.val = nums[start]
  boss.mid = (start + end) // 2
  # 递归构建子树
  boss.left = buildTree(start, mid)
  boss.right = buildTree(mid + 1, end)
  # 求和
  boss.val += boss.left?.val + boss.right?.val
  return boss

CEO = buildTree(0, 199)

CEO.left # CTO 负责0~99
CEO.right # CFO 负责100~199

Query: # of nodes visited: Average and worst are both ~O(logn)

Applications

LeetCode 307 Range Sum Query – Mutable

C++

// Author: Huahua, running time: 24 ms
class SegmentTreeNode {
public:
  SegmentTreeNode(int start, int end, int sum,
                  SegmentTreeNode* left = nullptr,
                  SegmentTreeNode* right = nullptr): 
    start(start),
    end(end),
    sum(sum),
    left(left),
    right(right){}      
  SegmentTreeNode(const SegmentTreeNode&) = delete;
  SegmentTreeNode& operator=(const SegmentTreeNode&) = delete;
  ~SegmentTreeNode() {
    delete left;
    delete right;
    left = right = nullptr;
  }
  
  int start;
  int end;
  int sum;
  SegmentTreeNode* left;
  SegmentTreeNode* right;
};

class NumArray {
public:
  NumArray(vector nums) {
    nums_.swap(nums);
    if (!nums_.empty())
      root_.reset(buildTree(0, nums_.size() - 1));
  }

  void update(int i, int val) {
    updateTree(root_.get(), i, val);
  }

  int sumRange(int i, int j) {
    return sumRange(root_.get(), i, j);
  }
private:
  vector nums_;
  std::unique_ptr root_;
  
  SegmentTreeNode* buildTree(int start, int end) {  
    if (start == end) {      
      return new SegmentTreeNode(start, end, nums_[start]);
    }
    int mid = start + (end - start) / 2;
    auto left = buildTree(start, mid);
    auto right = buildTree(mid + 1, end);
    auto node = new SegmentTreeNode(start, end, left->sum + right->sum, left, right);    
    return node;
  }
  
  void updateTree(SegmentTreeNode* root, int i, int val) {
    if (root->start == i && root->end == i) {
      root->sum = val;
      return;
    }
    int mid = root->start + (root->end - root->start) / 2;
    if (i <= mid) {
      updateTree(root->left, i, val);
    } else {      
      updateTree(root->right, i, val);
    }
    root->sum = root->left->sum + root->right->sum;
  }
  
  int sumRange(SegmentTreeNode* root, int i, int j) {    
    if (i == root->start && j == root->end) {
      return root->sum;
    }
    int mid = root->start + (root->end - root->start) / 2;
    if (j <= mid) {
      return sumRange(root->left, i, j);
    } else if (i > mid) {
      return sumRange(root->right, i, j);
    } else {
      return sumRange(root->left, i, mid) + sumRange(root->right, mid + 1, j);
    }
  }
};

Python3

# Author: Huahua, running time: 176 ms
class SegmentTreeNode:
  def __init__(self, start, end, val, left=None, right=None):
    self.start = start
    self.end = end
    self.mid = start + (end - start) // 2
    self.val = val
    self.left = left
    self.right = right

class NumArray:
  def __init__(self, nums):
    self.nums = nums
    if self.nums:
      self.root = self._buildTree(0, len(nums) - 1)

  def update(self, i, val):      
    self._updateTree(self.root, i, val)

  def sumRange(self, i, j):
    return self._sumRange(self.root, i, j)
    
  
  def _buildTree(self, start, end):
    if start == end: return SegmentTreeNode(start, end, self.nums[start])
    mid = start + (end - start) // 2
    left = self._buildTree(start, mid)
    right = self._buildTree(mid + 1, end)
    return SegmentTreeNode(start, end, left.val + right.val, left, right)
  
  def _updateTree(self, root, i, val):
    if root.start == i and root.end == i:
      root.val = val
      return    
    if i <= root.mid:
      self._updateTree(root.left, i, val)
    else:
      self._updateTree(root.right, i, val)
    root.val = root.left.val + root.right.val
  
  def _sumRange(self, root, i, j):
    if root.start == i and root.end == j:
      return root.val
    if j <= root.mid:
      return self._sumRange(root.left, i, j)
    elif i > root.mid:
      return self._sumRange(root.right, i, j)
    else:
      return self._sumRange(root.left, i, root.mid) + self._sumRange(root.right, root.mid + 1, j)

The post 花花酱 Segment Tree 线段树 SP14 appeared first on Huahua's Tech Road.

花花酱 LeetCode Binary Trees 二叉树 SP12

zxi — Sun, 16 Dec 2018 18:24:48 +0000

Binary tree is one of the most frequently asked question type during interview.

二叉树是面试中经常会问到的问题。

The candidate needs to understand the recursively defined TreeNode and solve the problem through recursion.

面试者需要理解递归定义的TreeNode数据类型，并且通过使用递归的方式来解决问题。

The post 花花酱 LeetCode Binary Trees 二叉树 SP12 appeared first on Huahua's Tech Road.

Knapsack Problem 背包问题

zxi — Sat, 10 Nov 2018 17:37:14 +0000

Videos

上期节目中我们对动态规划做了一个总结，这期节目我们来聊聊背包问题。

背包问题是一个NP-complete的组合优化问题，Search的方法需要O(2^N)时间才能获得最优解。而使用动态规划，我们可以在伪多项式（pseudo-polynomial time）时间内获得最优解。

0-1 Knapsack Problem 0-1背包问题

Problem

Given N items, w[i] is the weight of the i-th item and v[i] is value of the i-th item. Given a knapsack with capacity W. Maximize the total value. Each item can be use 0 or 1 time.

0-1背包问题的通常定义是：一共有N件物品，第i件物品的重量为w[i]，价值为v[i]。在总重量不超过背包承载上限W的情况下，能够获得的最大价值是多少？每件物品可以使用0次或者1次。

例子：

重量 w = [1, 1, 2, 2]

价值 v = [1, 3, 4, 5]

背包承重 W = 4

最大价值为9，可以选第1,2,4件物品，也可以选第3，4件物品；总重量为4，总价值为9。

动态规划的状态转移方程为：

dp[i][j] = max(dp[i-1][j], dp[i][j-w[i]] + v[i])

Solutions

Search

def knapsack01DFS(w, v, W):
  def dfs(s, cur_w, cur_v, ans):
    ans[0] = max(ans[0], cur_v)
    if s == N: return
    for i in range(s, N):
      if cur_w + w[i] <= W:
        dfs(i + 1, cur_w + w[i], cur_v + v[i], ans)
  ans = [0]
  dfs(0, 0, 0, ans)
  return ans[0]

DP2

def knapsack01(w, v, W):
  dp = [[0] * (W + 1) for _ in range(N+1)]
  for i in range(1, N + 1):
    dp[i] = dp[i-1].clone()
    for j in range(w[i], W + 1):
      dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i - 1]] + v[i - 1])
  return max(dp[N])

DP1/tmp

def knapsack01R(w, v, W):
  dp = [0] * (W + 1)
  for i in range(0, N):
    tmp = list(dp)
    for j in range(w[i], W + 1):
      tmp[j] = max(tmp[j], dp[j - w[i]] + v[i])
    dp = tmp
  return max(dp)

DP1/push

def knapsack01R2(w, v, W):
  dp = [0] * (W + 1)
  for i in range(0, N):
    for j in range(W, w[i] - 1, -1):
      dp[j] = max(dp[j], dp[j - w[i]] + v[i])
  return max(dp)

DP1/pull

def knapsack01R1(w, v, W):
  dp = [0] * (W + 1)
  for i in range(0, N):
    for j in range(W - w[i], -1, -1):
      dp[j + w[i]] = max(dp[j + w[i]], dp[j] + v[i])
  return max(dp)

Unbounded Knapsack Problem 完全背包

完全背包、多重背包是常见的变形。和01背包的区别在于，完全背包每件物品可以使用无限多次，而多重背包每件物品最多可以使用n[i]次。两个问题都可以转换成01背包问题进行求解。

但是Naive的转换会大大增加时间复杂度：

完全背包：“复制”第i件物品到一共有 W/w[i] 件

多重背包：“复制”第i件物品到一共有 n[i] 件

然后直接调用01背包进行求解。

时间复杂度：

完全背包 O(Σ(W/w[i])*W)

多重背包 O(Σn[i]*W)

不难看出时间复杂度 = O(物品数量*背包承重)

背包承重是给定的，要降低运行时候，只有减少物品数量。但怎样才能减少总的物品数量呢？

这就涉及到二进制思想：任何一个正整数都可以用 (1, 2, 4, …, 2^K)的组合来表示。例如14 = 2 + 4 + 8。
原本需要放入14件相同的物品，现在只需要放入3件（重量和价值是原物品的2倍，4倍，8倍）。大幅降低了总的物品数量从而降低运行时间。

完全背包：对于第i件物品，我们只需要创建k = log(W/w[i])件虚拟物品即可。

每件虚拟物品的重量和价值为：1*(w[i], v[i]), 2*(w[i], v[i]), …, 2^k*(w[i], v[i])。

多重背包：对于第i件物品，我们只需要创建k + 1件虚拟物品即可，其中k = log(n[i])。

每件虚拟物品的重量和价值为：1*(w[i], v[i]), 2*(w[i], v[i]), …, 2^(k-1)*(w[i], v[i]), 以及 (n[i] – 2^k – 1) * (w[i], v[i])。

例如：n[i] = 14, k = 3, 虚拟物品的倍数为 1, 2, 4 和 7，这4个数组合可以组成1 ~ 14中的任何一个数，并且不会>14，即不超过n[i]。

二进制转换后直接调用01背包即可

时间复杂度：

完全背包 O(Σlog(W/w[i])*W)

多重背包 O(Σlog(n[i])*W)

空间复杂度 O(W)

其实完全背包和多重背包都可以在 O(NW)时间内完成，前者在视频中有讲到，后者属于超纲内容，以后有机会再和大家深入分享。

Bounded Knapsack Problem 多重背包

The post Knapsack Problem 背包问题 appeared first on Huahua's Tech Road.

花花酱 LeetCode DP Summary 动态规划总结

zxi — Fri, 02 Nov 2018 06:18:52 +0000

Summary: Input size / sub-problem size / sub-problem complexity / time complexity / space complexity

Category 1.1

Input: O(n)
Sub-problems: O(n)
Each sub-problem depends on O(1) smaller problems
Time complexity: O(n)
Space complexity: O(n) -> O(1)
dp[i] := solution of A[1->i] // prefix

Template

dp = new int[n + 1]
for i = 1 to n:
  dp[i] = f(A[i], dp[i-1], dp[i-2], ...)
return dp[n]

Summary and slides

The post 花花酱 LeetCode DP Summary 动态规划总结 appeared first on Huahua's Tech Road.

花花酱 Amortized Analysis 均摊分析 SP7

zxi — Tue, 18 Sep 2018 02:16:30 +0000

Amortized Analysis

Amortized analysis can help us understand the actual cost of n operations on a data structure. Since some operations can be really fast e.g. O(1), but some operations can be really slow e.g. O(n). We could say the time complexity of that operation is O(n). However, it does not reflect the actual performance. And turns out, we can prove that certain operations have an amortized cost of O(1) while they can take O(n) in the worst case.

均摊分析可以帮助我们了解对一个数据结构进行n次操作的真实代价。对于相同的操作，有时候可以非常快，例如在O(1)时间内完成，而有时候则需要O(n)。我们当然可以说这个操作最坏情况下的时间复杂度是O(n)，但是这并不能真实反映它的实际复杂度。通过均摊分析，我们可以证明，尽管有些操作在最坏情况下是O(n)的时间复杂度，但是均摊下来只需要O(1)。

Dynamic Array

dynamic array doubles its size when it’s full which could take O(i) time where i is the number of elements in the array. Otherwise just store the element which only cost O(1). We can use aggregate method to compute the amortized cost of dynamic array.

动态数组在容量满时将容量翻翻，这一步需要O(i)时间，i是当前数组中的元素个数。如果没有满，只需要将元素存储下来即可，只需要花费O(1)时间。我们可以使用聚合法来计算均摊成本。

((1 + 1) + (1 + 2) + (1) + (1 + 4) + (1) + (1) + (1) + (1+8) + … + (1+n)) / n, assuming n is 2^k.

= (1 * n + (1 + 2 + 4 + 8 + … + n)) / n = (n + 2n – 1) / n = 3. O(1)

C++

#include 
#include 
using namespace std;

class DynamicArray {
public:
  DynamicArray() {
    data_ = new int[1];
    capcity_ = 1;
  }
  void add(int x) {
    data_[size_++] = x;
    ++total_cost_;
    if (size_ == capcity_) {
      capcity_ *= 2;
      total_cost_ += size_;
      int* new_data = new int[capcity_];
      copy(data_, data_ + size_, new_data);
      swap(new_data, data_);
      delete [] new_data;
    }
  }
  int totalCost() const { return total_cost_; }
private:
  int total_cost_ = 0;
  int size_ = 0;
  int capcity_;
  int* data_;
};

int main() {
  DynamicArray arr;
  for (int i = 1; i <= 16; ++i) {
    arr.add(i);
    cout << i << " average cost: " << arr.totalCost() / static_cast(i) << endl;
  }
}

Output

1 average cost: 2
2 average cost: 2.5
3 average cost: 2
4 average cost: 2.75
5 average cost: 2.4
6 average cost: 2.16667
7 average cost: 2
8 average cost: 2.875
9 average cost: 2.66667
10 average cost: 2.5
11 average cost: 2.36364
12 average cost: 2.25
13 average cost: 2.15385
14 average cost: 2.07143
15 average cost: 2
16 average cost: 2.9375
[Finished in 0.4s]

Monotonic Stack

例子2: 单调栈

往单调栈push一个元素的时候，会删除上所有小于等于它的元素。这步操作在最优情况下是O(1)时间，如果它比栈顶元素要小。在最坏情况下是O(i)时间，栈上有i个元素，它比这i个元素都要大，所以一共要pop i次。

聚合法：

由于每个元素都会被push到栈上去1次，最多会被pop1次，所以总的操作数 <= 2n。 2n / n = 2 O(1)。

会计法：

每次push之前先存k块钱，k=2, 一块钱用于push自己，一块钱留着用于pop自己。

push的时候扣除1块钱，pop的时候再扣除1块钱。但不管怎样，我的账户上的钱永远>=0。这样我们可以说push的均摊成本是k=2。同样是O(1)，尽管它的worst case是O(n)。

C++

#include 
#include 
#include 
using namespace std;

class MonotonicStack {
public:
  void push(int x) {
    while (!data_.empty() && x > data_.top()) {
      this->pop();
    }
    ++total_cost_;
    data_.push(x);
  }

  int pop() {
    ++total_cost_;
    int t = data_.top();
    data_.pop();
    return t;
  }
  int totalCost() const { return total_cost_; }
private:
  int total_cost_ = 0;
  stack data_;
};

int main() {
  srand(1);
  MonotonicStack s;
  for (int i = 1; i <= 32; ++i) {
    s.push(rand());
    cout << i << " average cost: " << s.totalCost() / static_cast(i) << endl;
  }  
}

Output

1 average cost: 1
2 average cost: 1.5
3 average cost: 1.66667
4 average cost: 1.5
5 average cost: 1.6
6 average cost: 1.5
7 average cost: 1.42857
8 average cost: 1.75
9 average cost: 1.77778
10 average cost: 1.9
11 average cost: 1.81818
12 average cost: 1.83333
13 average cost: 1.84615
14 average cost: 1.78571
15 average cost: 1.8
16 average cost: 1.8125
17 average cost: 1.82353
18 average cost: 1.77778
19 average cost: 1.78947
20 average cost: 1.75
21 average cost: 1.80952
22 average cost: 1.86364
23 average cost: 1.82609
24 average cost: 1.91667
25 average cost: 1.88
26 average cost: 1.84615
27 average cost: 1.81481
28 average cost: 1.85714
29 average cost: 1.82759
30 average cost: 1.86667
31 average cost: 1.90323
32 average cost: 1.875
[Finished in 0.5s]

花花酱 SP5 Binary Search

zxi — Mon, 13 Aug 2018 06:41:04 +0000

Template:

Time complexity: O(log(r-l)) * O(f(m) + g(m))

Space complexity: O(1)

"""
Returns the smallest number m such that g(m) is true.
"""
def binary_search(l, r):
  while l < r:
    m = l + (r - l) // 2
    if f(m): return m    # if m is the answer
    if g(m):
      r = m              # new range [l, m)
    else
      l = m + 1          # new range [m+1, r)
  return l               # or not found

Slides:

Lower Bound / Upper Bound

#include 
#include 
using namespace std;

int upper_bound(const vector& A, int val, int l, int r) {
  while (l < r) {
    int m = l + (r - l) / 2;
    if (A[m] > val)
      r = m;
    else      
      l = m + 1;
  }
  return l;
}

int lower_bound(const vector& A, int val, int l, int r) {
  while (l < r) {
    int m = l + (r - l) / 2;
    if (A[m] >= val)
      r = m;
    else
      l = m + 1;
  }
  return l;
}

int main() {
  vector A{1, 2, 2, 2, 4, 4, 5};
  cout << lower_bound(A, 0, 0, A.size()) << endl; // 0
  cout << lower_bound(A, 2, 0, A.size()) << endl; // 1
  cout << lower_bound(A, 3, 0, A.size()) << endl; // 4
  cout << upper_bound(A, 2, 0, A.size()) << endl; // 4
  cout << upper_bound(A, 4, 0, A.size()) << endl; // 6
  cout << upper_bound(A, 5, 0, A.size()) << endl; // 7
}

Mentioned Problems

The post 花花酱 SP5 Binary Search appeared first on Huahua's Tech Road.

花花酱 Time/Space Complexity of Recursion Functions SP4

zxi — Thu, 08 Feb 2018 04:48:37 +0000

How to analyze the time and space complexity of a recursion function?

如何分析一个递归函数的时间/空间复杂度？

We can answer that using master theorem or induction in most of the cases.

在大部分时候我们可以使用主方法和数学归纳法来进行解答。

First of all, we need to write down the recursion relation of a function.

首先我们要写出一个函数的递归表达式。

def func(n):
  if n < 0: return 1
  return func(n/2) + func(n/2)

Let’s use T(n) to denote the running time of func with input size of n.

让我们用T(n)来表示func函数在输入规模为n的运行时间。

Then we have：

那么我们有：

T(n) = 2*T(n/2) + O(1)

a = 2, b = 2, c_crit = logb(a) = 1, f(n) = n^c, c = 0.

c < c_crit, apply master theorem case 1:

根据主方法第一条我们得到

T(n) = Θ(n^c_crit) = Θ(n)

Let’s look at another example:

def func(n):
  if n < 0: return 1
  s = 0
  for i in range(n):
    s += i
  return s + func(n/2) + func(n/2)

T(n) = 2*T(n/2) + O(n)

a = 2, b = 2, c_crit = logb(a) = 1, f(n) = n^c, c = 1,

c = c_crit, apply master theorem case 2:

根据主方法第二条我们得到

T(n) =Θ(n^c_crit * (logn)^1)) = Θ(nlogn)

Cheatsheet

Equation	Time	Space	Examples
T(n) = 2*T(n/2) + O(n)	O(nlogn)	O(logn)	quick_sort
T(n) = 2*T(n/2) + O(n)	O(nlogn)	O(n + logn)	merge_sort
T(n) = T(n/2) + O(1)	O(logn)	O(logn)	Binary search
T(n) = 2*T(n/2) + O(1)	O(n)	O(logn)	Binary tree traversal
T(n) = T(n-1) + O(1)	O(n)	O(n)	Binary tree traversal
T(n) = T(n-1) + O(n)	O(n^2)	O(n)	quick_sort(worst case)
T(n) = n * T(n-1)	O(n!)	O(n)	permutation
T(n) = T(n-1)+T(n-2)+…+T(1)	O(2^n)	O(n)	combination

For recursion with memorization:

Time complexity: |# of subproblems| * |exclusive running time of a subproblem|

Example 1:

def fib(n):
  if n < 1: return 1
  if m[n]: return m[n]
  m[n] = fib(n - 1) + fib(n - 2)
  return m[n]

To solve fib(n), there are n subproblems fib(0), fib(1), …, fib(n)

each sub problem takes O(1) to solve

Time complexity: O(n)

Space complexity: O(n) + O(n) * O(1) = O(n)

Example 2:

LC 741 Cherry Pickup

dp(x1, y1, x2):
 if min(x1, y1, x2) < 0: return 0
 if m[x1][y1][x2]: return m[x1][y1][x2]
 ans = max(dp(x1 - 1, y1, x2 - 1), 
           dp(x1, y1 - 1, x2),
           dp(x1, y1 - 1, x2 - 1), 
           dp(x1 - 1, y1, x2))
 m[x1][y1][x2] = ans
 return m[x1][y1][x2]

To solve dp(n, n, n), there are n^3 subproblems

each subproblem takes O(1) to solve

Max recursion depth O(n)

Time complexity: O(n^3) * O(1) = O(n^3)

Space complexity: O(n^3) + O(n) * O(1) = O(n^3)

Example 3:

LC 312: Burst Balloon

dp(i, j):
 if m[i][j]: return m[i][j]
 for k in range(i, j + 1):
   ans = max(ans, dp(i, k - 1) + C + dp(k + 1, j))
 m[i][j] = ans
 return m[i][j]

To solve dp(0, n), there are n^2 subproblems dp(0, 0), dp(0, 1), …, dp(n-1, n)

each subproblem takes O(n) to solve

Max recursion depth O(n)

Time complexity: O(n^2) * O(n) = O(n^3)

Space complexity: O(n^2) + O(n) * O(1) = O(n^2)

Slides:

The post 花花酱 Time/Space Complexity of Recursion Functions SP4 appeared first on Huahua's Tech Road.

花花酱 Fenwick Tree / Binary Indexed Tree / 树状数组 SP3

zxi — Thu, 04 Jan 2018 07:09:20 +0000

本期节目中我们介绍了Fenwick Tree/Binary Indexed Tree/树状数组的原理和实现以及它在leetcode中的应用。
In this episode, we will introduce Fenwick Tree/Binary Indexed Tree, its idea and implementation and show its applications in leetcode.

Fenwick Tree is mainly designed for solving the single point update range sum problems. e.g. what’s the sum between i-th and j-th element while the values of the elements are mutable.

Init the tree (include building all prefix sums) takes O(nlogn)

Update the value of an element takes O(logn)

Query the range sum takes O(logn)

Space complexity: O(n)

Applications:

Implementation:

C++

class FenwickTree {    
public:
    FenwickTree(int n): sums_(n + 1, 0) {}
    
    void update(int i, int delta) {
        while (i < sums_.size()) {
            sums_[i] += delta;
            i += lowbit(i);
        }
    }
    
    int query(int i) const {        
        int sum = 0;
        while (i > 0) {
            sum += sums_[i];
            i -= lowbit(i);
        }
        return sum;
    }
private:
    static inline int lowbit(int x) { 
        return x & (-x); 
    }
    vector sums_;
};

Java

class FenwickTree {
    int sums_[];
    public FenwickTree(int n) {
        sums_ = new int[n + 1];
    }
    
    public void update(int i, int delta) {
        while (i < sums_.length) {
            sums_[i] += delta;
            i += i & -i;
        }
    }
    
    public int query(int i) {
        int sum = 0;
        while (i > 0) {
            sum += sums_[i];
            i -= i & -i;
        }
        return sum;
    }
}

Python3

class FenwickTree:
    def __init__(self, n):
        self._sums = [0 for _ in range(n + 1)]
        
    def update(self, i, delta):
        while i < len(self._sums):
            self._sums[i] += delta
            i += i & -i
    
    def query(self, i):
        s = 0
        while i > 0:
            s += self._sums[i]
            i -= i & -i
        return s

Applications

The post 花花酱 Fenwick Tree / Binary Indexed Tree / 树状数组 SP3 appeared first on Huahua's Tech Road.

花花酱 LeetCode Input Size V.S. Time Complexity SP2

zxi — Fri, 29 Dec 2017 02:52:44 +0000

本期节目介绍了输入数据规模和时间复杂度上限的关系，可以通过数据规模推算使用算法的类型。

< 10: O(n!) permutation
< 15: O(2^n) combination
< 50: O(n^4) DP
< 200: O(n^3) DP, all pairs shortest path
< 1,000: O(n^2) DP, all pairs, dense graph
< 1,000,000: O(nlogn), sorting-based (greedy), heap, divide & conquer
< 1,000,000: O(n), DP, graph traversal / topological sorting (V+E), tree traversal
< INT_MAX: O(sqrt(n)), prime, square sum
< INT_MAX: O(logn), binary search
< INT_MAX: O(1) Math

The post 花花酱 LeetCode Input Size V.S. Time Complexity SP2 appeared first on Huahua's Tech Road.

SP Archives - Huahua's Tech Road

花花酱 Min Heap SP21

C++

Python3

Fast Power for DP SP20

KMP Algorithm SP19

Implementation

C++

Python3

Applications

C++

C++

C++

花花酱 Minimum Spanning Tree (MST) 最小生成树 SP18

Prim’s Algorithm

C++

Python

Kruskal’s Algorithm

C++

Python

花花酱 Binary Search II SP17

LeetCode 进入千题时代该如何刷题？

花花酱 Segment Tree 线段树 SP14

Applications

C++

Python3

花花酱 LeetCode Binary Trees 二叉树 SP12

Knapsack Problem 背包问题

Videos

0-1 Knapsack Problem 0-1背包问题

Problem

Solutions

Search

DP2

DP1/tmp

DP1/push

DP1/pull

Unbounded Knapsack Problem 完全背包

Bounded Knapsack Problem 多重背包

花花酱 LeetCode DP Summary 动态规划总结

Category 1.1

Template

花花酱 Amortized Analysis 均摊分析 SP7

Amortized Analysis

Dynamic Array

C++

Output

Monotonic Stack

C++

Output

Related Problem

花花酱 SP5 Binary Search

Mentioned Problems

花花酱 Time/Space Complexity of Recursion Functions SP4

花花酱 Fenwick Tree / Binary Indexed Tree / 树状数组 SP3

C++

Java

Python3

Applications

花花酱 LeetCode Input Size V.S. Time Complexity SP2