misc

Author: MaskRay

binary-tree-maximum-path-sum.nim

@@ -0,0 +1,16 @@
+type
+  TreeNode {.importc: "struct TreeNode".} = object
+    val: cint
+    left, right: ptr TreeNode
+
+proc maxPathSum(root: ptr TreeNode): int {.exportc.} =
+  var res: int = root.val
+  proc dfs(x: ptr TreeNode): int =
+    if x == nil: return 0
+    let l = max(dfs(x.left), 0)
+    let r = max(dfs(x.right), 0)
+    res = max(res, l+x.val+r)
+    max(l, r)+x.val
+
+  discard dfs(root)
+  res

check-if-an-original-string-exists-given-two-encoded-strings.cc

@@ -1,11 +1,10 @@
 // Check if an Original String Exists Given Two Encoded Strings
-const int P = 200003;
-struct HNode {int key; bool val; HNode *next; } pool[P], *head[P], *pit;
+const int P = 32768;
+struct HNode {int key; bool val; HNode *next; } pool[P*2], *head[P], *allo;
 
 class Solution {
   static const int BASE = 999*10;
   string s1, s2;
-  unordered_map<unsigned, char> memo;
   bool f(int i, int j, int p) {
     int key = ((p+BASE)*41+i)*41+j, hash = key%P;
     for (HNode *x = head[hash]; x; x = x->next)
@@ -36,16 +35,16 @@ class Solution {
       } else if (s1[i] == s2[j])
         ret = f(i+1, j+1, p);
     }
-    HNode *x = pit == end(pool) ? new HNode : pit++;
+    HNode *x = allo == end(pool) ? new HNode : allo++;
     *x = {key, ret, head[hash]};
     head[hash] = x;
     return ret;
   }
 public:
   bool possiblyEquals(string s1, string s2) {
-    this->s1 = s1;
-    this->s2 = s2;
-    pit = pool;
+    this->s1 = move(s1);
+    this->s2 = move(s2);
+    allo = pool;
     fill_n(head, sizeof(head)/sizeof(*head), nullptr);
     return f(0, 0, 0);
   }

course-schedule-ii.nim

@@ -0,0 +1,27 @@
+type cintArray = ptr UncheckedArray[cint]
+
+proc malloc(size: csize_t): pointer {.importc.}
+
+proc findOrder(n: int, prereq: ptr UncheckedArray[cintArray], m: int, unused: pointer, returnSize: ptr cint): cintArray {.exportc.} =
+  var
+    d = newSeq[int](n)
+    e = newSeq[seq[int]](n)
+    fore = 0
+    rear = 0
+  result = cast[cintArray](malloc(cast[csize_t](cint.sizeof * n)))
+  for x in toOpenArray(prereq, 0, m-1):
+    inc d[x[0]]
+    e[x[1]].add x[0]
+  for i in 0..<n:
+    if d[i] == 0:
+      result[rear] = cast[cint](i)
+      inc rear
+  while fore < rear:
+    let x: int = result[fore]
+    inc fore
+    for y in e[x]:
+      dec d[y]
+      if d[y] == 0:
+        result[rear] = cast[cint](y)
+        inc rear
+  returnSize[] = if fore == n: cast[cint](n) else: 0

course-schedule.nim

@@ -0,0 +1,25 @@
+type cintArray = ptr UncheckedArray[cint]
+
+proc canFinish(n: int, prerequisites: ptr UncheckedArray[cintArray], m: int, unused: pointer): bool {.exportc.} =
+  var
+    d = newSeq[int](n)
+    e = newSeq[seq[int]](n)
+    top = -1
+    num = 0
+  for x in toOpenArray(prerequisites, 0, m-1):
+    inc d[x[0]]
+    e[x[1]].add x[0]
+  for i in 0..<n:
+    if d[i] == 0:
+      d[i] = top
+      top = i
+  while top >= 0:
+    let x = top
+    top = d[top]
+    inc num
+    for y in e[x]:
+      dec d[y]
+      if d[y] == 0:
+        d[y] = top
+        top = y
+  return num == n

diameter-of-binary-tree.nim

@@ -0,0 +1,16 @@
+# Diameter of Binary Tree
+type
+  TreeNode {.importc: "struct TreeNode".} = object
+    val: cint
+    left, right: ptr TreeNode
+
+proc diameterOfBinaryTree(root: ptr TreeNode): int {.exportc.} =
+  var res = 0
+  proc height(x: ptr TreeNode): int =
+    if x != nil:
+      let l = height(x.left)
+      let r = height(x.right)
+      res = max(res, l+r)
+      result = max(l, r) + 1
+  discard height root
+  res

maximum-earnings-from-taxi.nim

@@ -0,0 +1,20 @@
+# Maximum Earnings From Taxi
+import std/algorithm
+
+type cintA = ptr UncheckedArray[cint]
+
+proc maxTaxiEarnings(n: int, rides: ptr UncheckedArray[cintA], m: int, u: pointer): int {.exportc.} =
+  var
+    a = newSeq[(cint,cint,cint)](m)
+    dp = newSeq[int](n+1)
+    j = 0
+  for i in 0..<m:
+    a[i] = (rides[i][0], rides[i][1], rides[i][1]-rides[i][0]+rides[i][2])
+  a.sort proc (x, y: (cint,cint,cint)): int = x[1]-y[1]
+  for i in 1..n:
+    var t = dp[i-1]
+    while j < m and a[j][1] == i:
+      t = t.max dp[a[j][0]]+a[j][2]
+      inc j
+    dp[i] = t
+  dp[n]

maximum-profit-in-job-scheduling.nim

@@ -0,0 +1,21 @@
+import std/algorithm
+
+type cintA = ptr UncheckedArray[cint]
+
+proc jobScheduling(startTime: cintA, n: int, endTime: cintA, u0: cint, profit: cintA, u1: cint): cint {.exportc.} =
+  var
+    a = newSeq[(cint, cint, cint)](n)
+    dp = newSeq[cint](n)
+  for i in 0..<n:
+    a[i] = (startTime[i], endTime[i], profit[i])
+  a.sort proc (x, y: (cint, cint, cint)): int = x[1] - y[1]
+  dp[0] = a[0][2]
+  for i in 1..<n:
+    var l = 0
+    var h = i
+    while l < h:
+      let m = (l+h) shr 1
+      if a[m][1] <= a[i][0]: l = m+1
+      else: h = m
+    dp[i] = dp[i-1].max a[i][2] + (if l>0: dp[l-1] else: 0)
+  dp[n-1]

parallel-courses-iii.nim

@@ -0,0 +1,29 @@
+# Parallel Courses III
+import sequtils
+
+type cintArray = ptr UncheckedArray[cint]
+
+proc minimumTime(n: int, rels: ptr UncheckedArray[cintArray], m: int, unused: pointer, time: cintArray, unused1: cint): int {.exportc.} =
+  var
+    d = newSeq[int](n)
+    e = newSeq[seq[int]](n)
+    fin = newSeq[int](n)
+    top = -1
+  for x in toOpenArray(rels, 0, m-1):
+    inc d[x[1]-1]
+    e[x[0]-1].add x[1]-1
+  for i in 0..<n:
+    if d[i] == 0:
+      d[i] = top
+      top = i
+  while top >= 0:
+    let x = top
+    top = d[top]
+    fin[x] += time[x]
+    for y in e[x]:
+      fin[y] = max(fin[y], fin[x])
+      dec d[y]
+      if d[y] == 0:
+        d[y] = top
+        top = y
+  fin[maxIndex(fin)]

plates-between-candles.nim

@@ -0,0 +1,35 @@
+# Plates Between Candles
+import sequtils
+
+type cintA = ptr UncheckedArray[cint]
+proc malloc(size: csize_t): pointer {.importc.}
+
+proc platesBetweenCandles(s: cstring, q: ptr UncheckedArray[cintA], m: int, unused: pointer, returnSize: ptr cint): cintA {.exportc.} =
+  let n = s.len
+  var
+    pref = newSeq[int](n+1)
+    l = newSeqWith[int](n, -1)
+    r = newSeqWith[int](n, n)
+    c = 0
+    j = 0
+  for i in 0..<n:
+    if s[i] == '*':
+      inc c
+    else:
+      while j <= i:
+        r[j] = i
+        inc j
+    pref[i] = c
+  j = n-1
+  for i in countdown(n-1, 0):
+    if s[i] != '*':
+      while i <= j:
+        l[j] = i
+        dec j
+  result = cast[cintA](malloc(cast[csize_t](cint.sizeof * m)))
+  returnSize[] = cast[cint](m)
+  for i in 0..<m:
+    let
+      x = r[q[i][0]]
+      y = l[q[i][1]]
+    result[i] = if x >= y: 0 else: pref[y]-pref[x]

second-minimum-time-to-reach-destination.nim

@@ -0,0 +1,47 @@
+# Second Minimum Time to Reach Destination
+import std/sequtils
+
+type cintArray = ptr UncheckedArray[cint]
+
+proc secondMinimum(n: int, edges: ptr UncheckedArray[cintArray], edgesSize: int, _: cintArray, time: int, change: int): int {.exportc.} =
+  var
+    adj = newSeq[seq[cint]](n)
+    d = newSeqWith[int](n, n)
+    q = @[n-1]
+    qi = 0
+  for i in 0..<edgesSize:
+    let
+      u = edges[i][0]-1
+      v = edges[i][1]-1
+    adj[u].add v
+    adj[v].add u
+
+  d[n-1] = 0
+  while qi < q.len:
+    let u = q[qi]
+    inc qi
+    for v in adj[u]:
+      if d[v] == n:
+        d[v] = d[u]+1
+        q.add v
+
+  var length = d[0]+2 # A path of length d[0]+2 always exists
+  q.setLen 1
+  q[0] = 0
+  qi = 0
+  while qi < q.len:
+    let u = q[qi]
+    inc qi
+    for v in adj[u]:
+      if d[v] == d[u]:
+        dec length
+        qi = q.len
+        break
+      elif d[v] == d[u]-1:
+        q.add v
+
+  for i in 0..<length:
+    let t = result div change
+    if t mod 2 == 1:
+      result = (t+1) * change
+    result += time

two-best-non-overlapping-events.nim

@@ -0,0 +1,21 @@
+# Two Best Non-Overlapping Events
+import std/algorithm
+
+type cintA = ptr UncheckedArray[cint]
+
+proc maxTwoEvents(ev: ptr UncheckedArray[cintA], n: int, unused: pointer): cint {.exportc.} =
+  var
+    a = newSeq[(cint,cint)](n)
+    b = newSeq[(cint,cint)](n)
+    mx: cint = 0
+    j = 0
+  for i in 0..<n:
+    a[i] = (ev[i][1], ev[i][2])
+    b[i] = (ev[i][0], ev[i][2])
+  sort a
+  sort b
+  for i in 0..<n:
+    while j < n and a[j][0] < b[i][0]:
+      mx = mx.max a[j][1]
+      inc j
+    result = result.max mx+b[i][1]