Beendless ~ 快节奏,慢生活,无止境

Build Your Own Video Compression Service with Rust WASM

2024-08-02T10:15:24.000Z

Yesterday I explained how to use FFMPEG to compress video efficiently. How to deploy a video compression service? Here we can try to leverage the existing technologies like Rust, Wasm.

To create a Rust application that compiles to WebAssembly (WASM) and runs the ffmpeg command to convert an MP4 file, you will need to use a few crates and tools:

FFmpeg: To manipulate video files.
Wasm-pack: To build the Rust code into WebAssembly.
wasm-bindgen: To interact between Rust and JavaScript.
WebAssembly System Interface (WASI): To enable system calls from WebAssembly.

However, directly running ffmpeg from within WASM is quite complex due to the nature of WASM and the need for system calls. Instead, it’s more common to call out to an existing ffmpeg WebAssembly port or use an appropriate WebAssembly-compatible library.

For this example, we’ll use the ffmpeg.wasm project, which provides FFmpeg compiled to WebAssembly. The Rust part will focus on preparing the environment and handling the necessary JavaScript interop.

First, let’s create a Rust project:

Create a new Rust project:

1 2	cargo new wasm_ffmpeg cd wasm_ffmpeg

Add the necessary dependencies to your Cargo.toml:

1 2	[dependencies] wasm-bindgen = "0.2"

Install wasm-pack if you haven’t already:

1	cargo install wasm-pack

Update src/lib.rs to define a function that will be called from JavaScript:

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn process_video(input_file: &str, output_file: &str) -> String {
    format!(
        "ffmpeg -i {} -c:v libx264 -tag:v avc1 -movflags faststart -crf 30 -preset superfast {}",
        input_file, output_file
    )
}

Build the project using wasm-pack:

1	wasm-pack build --target web

Set up html to consume the js above

html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>WASM FFmpeg Exampletitle>
  head>
  <body>
    <h1>WASM FFmpeg Exampleh1>
    <input type="file" id="inputFile" accept="video/mp4" />
    <button id="convertButton">Convertbutton>
    <script src="https://cdn.jsdelivr.net/npm/@ffmpeg/ffmpeg@0.10.0/dist/ffmpeg.min.js">script>
    <script type="module">
      import init, { process_video } from "./pkg/wasm_ffmpeg.js";

      const { createFFmpeg, fetchFile } = FFmpeg;
      const ffmpeg = createFFmpeg({ log: true });

      async function main() {
        await init();

        document
          .getElementById("convertButton")
          .addEventListener("click", async () => {
            const inputFileElement = document.getElementById("inputFile");
            const inputFile = inputFileElement.files[0];
            if (inputFile) {
              const inputFilePath = URL.createObjectURL(inputFile);

              await ffmpeg.load();
              ffmpeg.FS(
                "writeFile",
                "input.mp4",
                await fetchFile(inputFilePath)
              );

              const ffmpegCommand = process_video("input.mp4", "output.mp4");
              console.log(`Running command: ${ffmpegCommand}`);

              await ffmpeg.run(
                "-i",
                "input.mp4",
                "-c:v",
                "libx264",
                "-tag:v",
                "avc1",
                "-movflags",
                "faststart",
                "-crf",
                "30",
                "-preset",
                "superfast",
                "output.mp4"
              );

              const data = ffmpeg.FS("readFile", "output.mp4");
              const video = document.createElement("video");
              video.src = URL.createObjectURL(
                new Blob([data.buffer], { type: "video/mp4" })
              );
              video.controls = true;
              document.body.appendChild(video);
            } else {
              alert("Please select an input file.");
            }
          });
      }

      main();
    script>
  body>
html>

We also need to set up a server to serve this html file. Let’s try express.

const express = require('express');
const path = require('path');
const app = express();

const PORT = 8080;

app.use((req, res, next) => {
    res.setHeader('Cross-Origin-Opener-Policy', 'same-origin');
    res.setHeader('Cross-Origin-Embedder-Policy', 'require-corp');
    next();
});

app.use(express.static(path.join(__dirname, './dist')));

app.listen(PORT, () => {
    console.log(`Server is running on http://localhost:${PORT}`);
});

We just need to copy the js and html files under dist folder.

Here is the code base https://github.com/blessdyb/video-compression-wasm-app

The Secret of Video Compression with FFMPEG

2024-08-02T06:15:24.000Z

Recently there’s a hot tweet talking about video compression (https://x.com/mortenjust/status/1817991110544744764). The author shows that how he could compress most of the MP4 videos down to 10% of the original size.

If you check the site https://tools.rotato.app/compress, actually he didn’t invent anything new. It’s a WASM version of ffmpeg which is using command

1	ffmpeg -i "input.mp4" -c:v libx264 -tag:v avc1 -movflags faststart -crf 30 -preset superfast "output.mp4"

The FFmpeg command above is used to transcode a video file (input.mp4) into another video file (output.mp4) using specific encoding settings. Here’s a breakdown of what each part of the command does:

Command Breakdown

ffmpeg:
- This is the command-line tool used for processing video and audio files.
-i "input.mp4":
- -i specifies the input file. In this case, it is "input.mp4". This is the video file you want to convert or process.
-c:v libx264:
- -c:v specifies the video codec to use for the output. libx264 is a widely used library for encoding H.264 video, which is known for its good compression and quality.
-tag:v avc1:
- This sets the codec tag for the video stream to avc1, which is the identifier used in MP4 containers for H.264 video. It ensures compatibility with certain players and devices that require this tag.
-movflags faststart:
- This option moves some metadata to the beginning of the output file. This makes the video start playing faster when streamed over the internet because the metadata needed to start playback is located at the start of the file, rather than at the end.
-crf 30:
- -crf stands for Constant Rate Factor. This option controls the quality of the output video when using the x264 encoder. The CRF value ranges from 0 to 51, where lower values result in better quality at the cost of larger file sizes, and higher values result in worse quality and smaller file sizes. A CRF value of 30 is relatively high, indicating a moderate quality level, resulting in a smaller file size.
-preset superfast:
- -preset determines the speed of the encoding process and the compression efficiency. The superfast preset prioritizes speed over compression efficiency, resulting in faster encoding times at the expense of a larger file size. This is useful if you need a quick encoding process and are not as concerned about file size.
"output.mp4":
- This specifies the name of the output file. In this case, the processed video will be saved as "output.mp4".

Summary

This command takes an input video file and transcodes it to H.264 format using the libx264 encoder. It sets the video stream tag for compatibility, optimizes the file for streaming, and uses a preset that balances speed and quality. The output will be a moderately compressed video suitable for streaming or uploading where file size and encoding speed are more important than the highest possible quality.

NodeJS Http-Proxy with WebSocket

2023-07-18T06:15:24.000Z

WebSocket has been supported widely in the past few years. More and more applications are embracing this and using it to replace AJAX / Commit / LongPooling. Set up a NodeJS server with WebSocket is easier, but how to do it correctly especially when your application is behind web proxies? Here I’m going to use a simple http server and websocket native implementaion ws, a http proxy based on http-proxy .

Run below commands to start a small project

1 2	mkdir nodejs-proxy-websocket && cd nodejs-proxy-websocket && npm init -y npm i --save ws http-proxy

Create a file index.html with code below. So we set up a websocket connection which will display the message pushed from server and send it back

Create a file server.js with code below. We share the same server between websocket server and http application server.

const http = require("http");
const fs = require("fs");
const ws = require("ws");

// Render index.html as content for all requests
const server = http.createServer((req, res) => {
  fs.readFile("index.html", "utf8", (err, data) => {
    if (err) {
      res.statusCode = 500;
      res.end("Internal Server Error");
      return;
    }

    res.statusCode = 200;
    res.setHeader("Content-Type", "text/html");
    res.end(data);
  });
});

// Handle websocket requests
const wss = new ws.WebSocketServer({ noServer: true });
wss.on("connection", (websocket, req) => {
  setInterval(
    () => websocket.send(+new Date()),
    1000
  );
  websocket.on("message", (data) => {
    console.log(data.toString());
  });
});

server.on("upgrade", (req, socket, head) => {
  wss.handleUpgrade(req, socket, head, (websocket) => {
    wss.emit("connection", websocket, req);
  });
});

server.listen(3001);

Now if you run node server.js and open http://localhost:3001 you will see a clock string displaying on the page and refreshing every second
Let’s continue our journey, create a file named proxy.js with content below

const http = require("http");
const httpProxy = require('http-proxy');
// Set up a proxy
var proxy = new httpProxy.createProxyServer({
  target: {
    host: 'localhost',
    port: 3001
  }
});

// Create a proxy server
var proxyServer = http.createServer(function (req, res) {
  proxy.web(req, res);
});

proxyServer.on('upgrade', function (req, socket, head) {
  proxy.ws(req, socket, head);
});

proxyServer.listen(8001)

Here we use http-proxy to set up a simple proxy server which proxying all requests (including websocket) to our application server (server.js http://localhost:3001).

Now if you open http://localhost:8001 you will see the same page as #4. We successfully make websocket requests pass through a proxy in nodejs.

Set up Kubeadm on MacOS with Vagrant and VirtualBox

2021-11-15T08:45:23.000Z

Based on kubeadm installation instructions, we can’t directly install it on MacOS. But with the help of Vagrant and VirtualBox, we can quickly create a local kubenetes cluster.

Install VirtualBox and Vagrant(https://www.vagrantup.com)
Create three virtualbox instances, one as a master node and the other two as workder nodes. You can use this Vagrantfile. Basically we will:
a. Use ubuntu/bionic64 as the OS
b. Set up a private network and use IP subnet “192.168.5.X” (master nodes will use 192.168.5.1X, worker nodes will use 192.168.5.2X)
c. Update /etc/hosts to set up the host record to all nodes
d. Add Google’s open dns to /etc/resolver.conf file
e. Once you finish the above process, you can run vagrant status, you will get something like below
1
2
3
kubemaster running (virtualbox)
kubenode01 running (virtualbox)
kubenode02 running (virtualbox)
Install Docker runtime on all three instances by following https://docs.docker.com/engine/install/ubuntu/
Follow https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/install-kubeadm/ to install the kubeadm.
a. Letting iptables see bridged traffic
b. Installing kubeadm/kubelet and kubectl
Follow https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/create-cluster-kubeadm/ to create a cluster.
a. Initializing a control-plane node kubeadm init --pod-network-cid=10.244.0.0/16 --apiserver-advertise-address=192.1168.5.11 . Here 10.244.0.0/16 specifies the subnet for pods on worker nodes. You can give a different one. Once it’s installed successfully, you can run kubectl get nodes and the master nodes will be displayed as NotReady as expected
b. Installing a Pod network add-on by following https://kubernetes.io/docs/concepts/cluster-administration/networking/#how-to-implement-the-kubernetes-networking-model. Here we choose WeaveNet which doesn’t need any additional configuration.
c. Join the worker nodes to the cluster. If you forget the tokens, you can run kubeadm token create --print-join-command and run the kubeadm join command in all worker nodes.

Now if you run kubectl get nodes, you can get a result as below.

NAME         STATUS   ROLES                  AGE   VERSION
kubemaster   Ready    control-plane,master   9h    v1.22.3
kubenode01   Ready                     9h    v1.22.3
kubenode02   Ready                     9h    v1.22.3

MMM, Ma-Po Tofu !

2021-10-26T07:00:24.000Z

It might be a dish foreign for you; in fact, it was foreign to me too. Ma-Po tofu originates from a region in China but far away from my hometown. The first time that I had it was in my first year of college. It and me, both had left home, just met in a small restaurant next to our campus. Gladly, I was not alone, neither was the dish. There were new friends of mine sitting around a table, and Ma-Po Tofu took the center, having always had the charm to attract people from all over the country. It may be welcomed by people from all over the world one day.

On a simple plate with certain depth was Ma-Po tofu resting. The white plate made a perfect extension of the dish as the tofu was white itself yet the sauce all over it was flame red. The depth of the plate had to be perfect too as the sauce could be a little glutinous and soupy at the same time. A flat plate too shallow would not match the thickness of Ma-Po tofu. The tofu was cut into small cubes like dice and partly immersed in spicy vegetable oil. Red chili powder and green onion bits decorated the tofu cubes, like sprinkles, adding not only rich flavors but also festivity to the dish. Chopped garlic and ginger pieces may be easily ignored at the first glance, but they were still easier to detect than tiny, ground meat. The meat had been crisped in hot oil, being prepared to support the main role of tofu. Yes, the meat had to surrender and obey the spicy and fragrant of the rest of ingredients. The only purpose for all the ingredients was to give a wondrous taste for tofu that is usually considered the least tasty bean-based curd. While the original flavor of tofu retained, a variety of spices that marked the Sichuan region, from which the Ma-Po tofu originated, wrapped each piece of tofu. Aha! The wondrous taste had its most contribution from a special spice, Chinese pepper, the kind that numbs my tongue! It was ground and dredged on the ready dish at last. The brown powder camouflaged itself until my first bite. Anyone can recognize its distinctiveness.

The most recommended way to take Ma-Po tofu is to dip the tofu in the sauce a bit or to just use a spoon to take one piece of tofu and the sauce together. The essence in the taste was an incredible integration of different types of spicy tastes at different layers. The numbing sense gave it special magic to level up that mixed taste. Several small pieces of meat occasionally clung to the tofu or garlic. Although very small, the meat was crispy outside and tender inside, adding a playful element to other ingredients. Besides the dynamic flavors, tofu was still being itself: it was tender, smooth, pleasantly chewy, soft yet firm, just as it was before it was cooked. The texture of the tofu for this dish was something in-between of marshmallows and cheese. The tenderness and firmness remained; yet another level of slipperiness was built upon it because now the tofu was made hot, not only hot as spicy but also hot in temperature. At least it was warm enough that I wanted to take my time before taking anything from it. While the rich taste fills every corner of my mouth at once the first bite that I just had would smoothly slide to reach my throat and esophagus. Usually, eaters could not resist the fragrant warmth as soon as the dish was served, so they jumped into it. Just like taking an adventure in a wonder land of spices, you might want to do it slowly before suddenly getting your tongue, throat, and esophagus numbed or burned. Don’t ask me how I know it!

I remembered my lesson ever since but not always successful in applying it; my husband knows that because I sometimes make it at home now. Ma-Po tofu is a test even for masters as making tofu colorful and tasty is inherently a difficult task. But you do not have to make it as stylish as a chef’s signature, it is a treat itself. As a classic in the region where it originates, Ma-Po tofu is an easy, simple, low-key dish that everyone can make very home. It is popular but also homey. Its warmth and amora reminds eaters everything about home. This might have been the reason that we ordered a Ma-Po tofu at the dinner table when a bunch of first-year college students became friends and shared meals together.

Multi-Stage Golang Docker Image Build and Kubernetes Deployment

2021-10-19T18:15:24.000Z

If we have a tiny web service which return the host name as below. We can use golang image and build the executable package, then move it into a basic linux container like alpine.

package main

import (
    "fmt"
    "log"
    "net/http"
    "os"
    "time"

    "github.com/gorilla/mux"
)

func handler(w http.ResponseWriter, r *http.Request) {
    name, err := os.Hostname()
    if err != nil {
        fmt.Fprintf(w, "Can't get hostname")
    } else {
        fmt.Fprintf(w, "Go Hostname: %s\n", name)
    }
}

func main() {
    r := mux.NewRouter()
    r.PathPrefix("/").HandlerFunc(handler)
    srv := &http.Server{
        Handler: r,
        Addr:    ":8000",
        // Good practice: enforce timeouts for servers you create!
        WriteTimeout: 15 * time.Second,
        ReadTimeout:  15 * time.Second,
    }

    log.Fatal(srv.ListenAndServe())
}

FROM golang:1.17 AS builder
# https://stackoverflow.com/questions/61515186/when-using-cgo-enabled-is-must-and-what-happens
# https://gist.github.com/blessdyb/ebe59987e4a4632b28c10ec74a1eda0c
ENV CGO_ENABLED=0
WORKDIR /build
COPY .  .
RUN go mod download
RUN go build -o app

FROM alpine:latest  
WORKDIR /app
COPY --from=builder /build/app .
EXPOSE 8000
CMD ["./app"]

Once we have the docker file, we can build an image with command docker build -t whoami-web . . Now, we can use Kubernetes to deploy it

apiVersion: apps/v1
kind: Deployment
metadata:
  name: whoami
  labels:
    app: whoami
    version: v1
spec:
  selector:
    matchLabels:
      app: whoami
      version: v1
  template:
    metadata:
      labels:
        app: whoami
        version: v1
    spec:
      containers:
        - name: whoami-web
          image: whoami-web
          imagePullPolicy: Never

Run kubectl apply -f deployment.yml we will have the deployment running.

Run kubectl port-forward deploy/whoami 8001:8000 , then we can check localhost:8001 in our browser.

You can compare the result of the real container name by running below commands:

kubectl get pods -o custom-columns=NAME:metadata.name
kubectl exec deploy/whoami -- sh -c 'hostname'

Mastering Go Notes

2021-10-18T18:15:24.000Z

If you have to check godoc offline, you could install gdoc go get golang.org/x/tools/cmd/godoc and then run godoc -http :8001 in termilal.
Go consider the main() function the entry point to the application and begins the execution of the applicaiton with the code found in the main() function of the main package.
Everything that begins with a lowercase letter is considered private and is accessible in the current package only.
If no initial value is given to a variable, the Go compiler will automatically initialize that variable to the zero value of its data type.
The var keyword is mostly used for declaring global or local variables without an initial value. Since every statement that exists outside of the code of a function must begin with a keywoprd such as func, const or var, you can’t use short assignment statement := outside of the function.
The os.Args string slice is properly initialized by Go and is available to the program when referenced.

Monotonic Stack

2021-10-16T18:15:24.000Z

Monotonic Stack is the best time complexity solution for many “range queries in an array” problems. Because every element in the array could only enter the monotonic stack once, the time complexity is O(N). (N represents the length of the array).

739. Daily Temperatures

Since we want to get the first larger element after the current element, we can consider using the monotonic stack.

func dailyTemperatures(temperatures []int) []int {
    n := len(temperatures)
    result := make([]int, n)
    stack := []int{}
    for i := 0; i < n; i++ {
        for len(stack) > 0 && temperatures[i] > temperatures[stack[len(stack) - 1]]{
            last := stack[len(stack) - 1]
            result[last] = i - last
            stack = stack[:len(stack) - 1]
        }
        stack = append(stack, i)
    }
    return result
}

496. Next Greater Element I

We use a monotonic stack to iterate over the nums2 array. During the iteration, if we find that the top stack value is lower than the current value and the top stack value exist in nums1, it means we get the one result in nums1. Since all elements are unique, we don’t need to worry about the override risk.

func nextGreaterElement(nums1 []int, nums2 []int) []int {
    result := make([]int, len(nums1))   
    hash := make(map[int]int)
    for i := 0; i < len(nums1); i++ {
        result[i] = -1
        hash[nums1[i]] = i
    }
    stack := []int{0}
    for i := 1; i < len(nums2); i++ {
        if nums2[i] <= nums2[stack[len(stack) - 1]] { 
            stack = append(stack, i)
        } else {
            for len(stack) > 0 && nums2[i] > nums2[stack[len(stack) - 1]] { // unique values in both nums1 and nums2
                if index, ok := hash[nums2[stack[len(stack) - 1]]] {
                    result[index] = nums2[i]
                }
                stack = stack[:len(stack) - 1]
            }
            stack = append(stack, i)
        }
    }
    return result
}

503. Next Greater Element II

We can concat two nums2 to one and get a longer list of result, then reduce the result size to half. It will be a same problem as the above one. We can also use mod operator to get the correct index

func nextGreaterElements(nums []int) []int {
    n := len(nums)
    stack := []int{0}
    result := make([]int, n)
    for i := 0; i < n; i++ {
        result[i] = -1
    }
    for i := 1; i < 2 * n; i++ {
        for len(stack) > 0 && nums[i % n] > nums[stack[len(stack) - 1]] {
            result[stack[len(stack) - 1]] = nums[i % n]
            stack = stack[:len(stack) - 1]
        }
        stack = append(stack, i % n)
    }
    return result
}

42. Trapping Rain Water

Based on the requirment, for each column, we will need to get the highest value on its left and right and then get the smaller one.

a. Dynamic Programming

func trap(height []int) int {
    n := len(height)   
    left := make([]int, n)
    right := make([]int, n)
    left[0] = height[0]
    right[n - 1] = height[n - 1]
    max := func(a, b int) int {
        if a > b {
            return a
        }
        return b
    }
    min := func(a, b int) int {
        if a > b {
            return b
        }
        return a
    }
    for i := 1; i < n; i++ {
        left[i] = max(height[i], left[i - 1])
    }
    for i := n - 2; i >= 0; i-- {
        right[i] = max(height[i], right[i + 1])
    }
    result := 0
    for i := 0; i < n; i++ {
        diff := min(left[i], right[i]) - height[i]
        if diff > 0 {
            result += diff
        }
    }
    return result
}

b. Monotonic Stack

We will get the water layer by layer vertically for each item. [https://leetcode.wang/leetCode-42-Trapping-Rain-Water.html]. Basically, the idea is we have at least two items in the stack, if the stack top is smaller than the current one, it means the stack top is the bottom of the rain trapper, and the second top one in stack is the left bounary and the current one is the right boundary.

 ___
5| |
4| |     ___ 
3| |     | |
2| |__   | |
1|____|__|_|
 a b  c  d e

so result = (min(d, c) - 0) * (d - c) + (min(d, b) - c ) * (d - b)

func trap(height []int) int {
    result := 0
    n := len(height)
    stack := []int{}
    min := func(a, b int) int {
        if a > b {
            return b
        }
        return a
    }
    for i := 0; i < n; i++ {
        for len(stack) > 0 && height[i] > height[stack[len(stack) - 1]] {
            bottom := height[stack[len(stack) - 1]]
            stack = stack[:len(stack) - 1]
            if len(stack) > 0 {
                w := i - stack[len(stack) - 1] - 1;
                h := min(height[stack[len(stack) - 1]], height[i])
                result += w * (h - bottom)
            }
        }
        stack = append(stack, i)
    }
    return result
}

c. Two pointers

func trap(height []int) int {
    result := 0
    n := len(height)
    max := func(a, b int) int {
        if a > b {
            return a
        }
        return b
    }
    min := func(a, b int) int {
        if a > b {
            return b
        }
        return a
    }
    for i := 1; i < n - 1; i++ {
        left := height[i]
        for l := i - 1; l >= 0; l-- {
            left = max(left, height[l])
        }
        right := height[i]
        for r := i + 1; r < len(height); r++ {
            right = max(right, height[r])
        }
        amount := min(left, right) - height[i]
        if amount > 0 {
            result += amount
        }
    }
    return result
}

84. Largest Rectangle in Histogram

For each item, we need to get the first lower value than the current one on it’s left and right. With this we can get the width of the rectangle.

a. Dynamic Programming

func largestRectangleArea(heights []int) int {
    n := len(heights)
    left := make([]int, n)
    left[0] = -1
    right := make([]int, n)
    right[n - 1] = n
    for i := 1; i < n; i++ {
        t := i - 1
        for t >= 0 && heights[t] >= heights[i] {
            t = left[t]
        }
        left[i] = t
    }
    for i := n - 2; i >= 0; i-- {
        t := i + 1
        for t < n && heights[t] >= heights[i] {
            t = right[t]
        }
        right[i] = t
    }
    result := 0
    for i := 0; i < n; i++ {
        area := heights[i] * (right[i] - left[i] - 1)
        if result < area {
            result = area
        }
    }
    return result
}

b. Monotonic Stack solution

We can use a monotonic stack to maintain the higher bars’s indices in ascending order. When encounter a lower bar, pop the tallest bar and use it as the bottleneck to compute the area.

func largestRectangleArea(heights []int) int {
    // The reason we have a 0 at the end is if the given heights is a sorted ascending array, we will push everything to the stack without doing anything.
    heights := append(heights, 0)
    n := len(heights)
    result := 0
    stack := []int{}
    for i := 0; i < n; i++ {
        for len(stack) > 0 && height[i] < height[stack[len(stack) - 1]] {
            h := heights[stack[len(stack) - 1]]
            stack = stack[:len(stack) - 1]
            w := i
            if len(stack) > 0 {
                w = i - stack[len(stack) - 1] - 1
            }
            area := h * w
            if result < area {
                result = area
            }
        }
        stack = append(stack, i)
    }
}

Indoor bluetooth location

2021-10-15T20:54:33.000Z

Indoor positioning technology is more and more widely used in daily life, such as indoor navigation, smart home, shopping mall advertisement, etc. This article will detail the principles of this technique and its advantages in practical applications.

principle

The basic principle is to obtain the distance between the device and the beacon in the indoor environment by deploying several Bluetooth beacons, and then combine the current location information of the device collected by the built-in sensors (such as accelerometers, gyroscopes, etc.) of the mobile phone, and input these data into It is processed in the Kalman filter algorithm, and finally the optimized device location information is output to improve positioning accuracy and real-time performance.

Deploy Bluetooth Beacons

Deploy several Bluetooth beacons indoors, and record the location coordinates and signal strength values of each beacon. Because the signal penetration ability of Bluetooth is strong and can pass through obstacles, Bluetooth positioning is widely used in indoor environments.

Data collection by mobile phone hardware

Use hardware devices such as built-in sensors (such as accelerometers, gyroscopes, etc.) in the mobile phone to collect the current location information of the device, such as direction, moving speed, angle, etc.

Bluetooth positioning to obtain data

Use the Bluetooth module of the mobile phone to scan the surrounding Bluetooth beacons and obtain their signal strength values. Based on the signal strength value, the distance between the device and the beacon is calculated, and then the location of the device is determined.

Kalman filter algorithm to process data

The collected location information and signal strength values are input into the Kalman filter algorithm for processing, and the location information of the device is optimized by means of weighted average and sliding window to improve the positioning accuracy and real-time performance. The Kalman filter algorithm is a commonly used data prediction and processing algorithm, which can effectively deal with the noise and errors existing in sensor data.

Data Fusion

The position information output by the Kalman filter algorithm is fused with other positioning technologies (such as WiFi positioning) to further improve the positioning accuracy and accuracy. The fusion of multiple positioning technologies can eliminate the disadvantages of a single technology while making full use of their respective advantages.

The indoor positioning technology based on Bluetooth positioning, mobile phone sensors and Kalman filter has the characteristics of high positioning accuracy, good real-time performance and low cost. This technology has important application value in smart home, shopping mall advertising, indoor navigation and other fields. However, in the application process, there are also many challenges, such as the noise interference of sensor data and the uncertainty of position information, etc., which need to be further studied and solved.

Dynamic Programming IV

2021-10-14T18:14:24.000Z

115. Distinct Subsequences

Let’s denote dp[i][j] as the amount of distinct subsequences in s[:i] which can construct t[:j]. So we can get the state transition function dp[i][j] = s[i - 1] == t[i - 1] ? (dp[i - 1][j - 1] + dp[i - 1][j] : dp[i-1][j]. Also for the initial value, dp[i][0] needs to be 0 (it means there’s one way we can construct empty string from s[:i]).

func numDistinct(s string, t string) int {
    m := len(s)
    n := len(t)
    dp := make([][]int, m + 1)
    for i := 0; i <= m; i++ {
        dp[i] = make([]int, n + 1)
        dp[i][0] = 1
    }
    for i := 1; i <= m; i++ {
        for j := 1; j <= n; j++ {
            if s[i - 1] == t[j - 1] {
                dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1]
            } else {
                dp[i][j] = dp[i - 1][j]
            }
        }
    }
    return dp[m][n]
}

583. Delete Operation for Two Strings

a. LCS solution.

Delete characters to make two strings match, in another word, it means we need to find the longest common sequence.

func minDistance(word1 string, word2 string) int {
    m := len(word1)
    n := len(word2)
    dp := make([][]int, m + 1)
    lcs := 0
    max := func(a, b int) int {
        if a > b {
            return a
        }
        return b
    }
    for i := 0; i <= m; i++ {
        dp[i] = make([]int, n + 1)
        for j := 0; j <= n; j++ {
            if i == 0 || j == 0 {
                continue
            } else if word1[i - 1] == word2[j - 1] {
                dp[i][j] = 1 + dp[i-1][j-1]
            } else {
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
            }
            lcs = max(lcs, dp[i][j])
        }
    }
    return m + n - 2 * lcs
}

b. Intuitive dynamic programming solution.

Let’s denote dp[i][j] as the minimum delete operation to match word1[:i] and word2[:j]. So the state transition function is dp[i][j] = word1[i-1] == word2[j-1] ? dp[i-1][j-1] : max(dp[i - 1][j] + 1, dp[i][j-1] + 1, dp[i-1][j-1] + 2).

func minDistance(word1 string, word2 string) int {
    m := len(word1)
    n := len(word2)
    dp := make([][]int, m + 1)
    min := func(a, b int) int {
        if a > b {
            return a
        }
        return b
    }
    for i := 0; i <= m; i++ {
        dp[i] = make([]int, n + 1)
        for j := 0; j <= n; j++ {
            if i == 0 {
                dp[i][j] = j
            } else if j == 0 {
                dp[i][j] = i
            } else if word1[i - 1] == word2[j - 1] {
                dp[i][j] = dp[i - 1][j - 1]
            } else {
                dp[i][j] = min(dp[i][j - 1] + 1, min(dp[i - 1][j] + 1, dp[i - 1][j - 1] + 2))
            }
        }
    }
    return dp[m][n]
}

We can also reduce the space complexity to O(n)

func minDistance(word1 string, word2 string) int {
    m := len(word1)
    n := len(word2)
    min := func(a, b int) int {
        if a > b {
            return b
        }
        return a
    }
    dp := make([]int, n + 1)
    for i := 0; i <= m; i++ {
        temp := make([]int, n + 1)
        for j := 0; j <= n; j++ {
            if i == 0 {
                temp[j] = j
            } else if j == 0 {
                temp[j] = i
            } else if word1[i - 1] == word2[j - 1] {
                temp[j] = dp[j - 1]
            } else {
                //temp[j] = min(temp[j - 1] + 1, min(dp[j] + 1, temp[j - 1] + 2))
                temp[j] = 1 + min(temp[j - 1], dp[j])
            }
        }
        dp = temp
    }
    return dp[n]
}

72. Edit Distance

This one is similar as the above one. Let’s denote dp[i][j] as the edit distance between word1[:i] and word2[:j]. So if word1[i] == word2[j], we get dp[i][j] = dp[i - 1][j-1]. Otherwise, there will be three cases:

add/delete one from word1, so dp[i-1][j] + 1 or dp[i][j-1] + 1
add/delete one from word2, so dp[i-1][j] + 1 or dp[i][j-1] + 1
replace one from either word1 or word2, so dp[i-1][j-1] + 1

So dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])

func minDistance(word1 string, word2 string) int {
    m := len(word1)
    n := len(word2)
    dp := make([][]int, m + 1)
    min := func(a, b int) int {
        if a > b {
            return b
        }
        return a
    }
    for i := 0; i <= m; i++ {
        dp[i] = make([]int, n + 1)
        for j := 0; j <= n; j++ {
            if i == 0 {
                dp[i][j] = j
            } else if j == 0 {
                dp[i][j] = i
            } else if word1[i - 1] == word2[j - 1] {
                dp[i][j] = dp[i - 1][j - 1]
            } else {
                dp[i][j] = 1 + min(dp[i - 1][j - 1], min(dp[i - 1][j], dp[i][j - 1]))
            }
        }
    }
    return dp[m][n]
}

we can also reduce the space complexity to O(n)

func minDistance(word1 string, word2 string) int {
    m := len(word1)
    n := len(word2)
    dp := make([]int, n + 1)
    min := func(a, b int) int {
        if a > b {
            return b
        }
        return a
    }
    for i := 0; i <= m; i++ {
        temp := make([]int, n + 1)
        for j := 0; j <= n; j++ {
            if i == 0 || j == 0 {
                temp[j] = i + j
            } else if word1[i - 1] == word2[j - 1] {
                temp[j] = dp[j - 1]
            } else {
                temp[j] = 1 + min(dp[j - 1], min(dp[j], temp[j - 1]))
            }
        }
        dp = temp
    }
    return dp[n]
}

647. Palindromic Substrings

a. Dynamic Programming

Let’s denote dp[i][j] as a boolean value to identify if substring s[j:i] is a parlindrom or not. So if s[j] != s[i], then dp[i][j] is false. Otherwise, there are three cases:

i - j <= 1, so dp[i][j] = true
i - j > 1, so dp[i][j] = dp[i - 1][j + 1]

func countSubstrings(s string) int {
    n := len(s)
    dp := make([][]bool, n + 1)
    result := 0
    for i := 0; i <= n; i++ {
        dp[i] = make([]bool, n + 1)
        for j := 0; j <= i; j++ {
            if i == 0 || j == 0 {
                continue
            } else if s[j - 1] == s[i - 1] {
                if i - j <= 1 || dp[i - 1][j + 1] {
                    dp[i][j] = true
                    result++
                }
            }
        }
    }
    return result
}

b. Two pointers expand from center solution

All parlindrom related problems, we can try to use two pointers solution, we selecte the middle point (it could be only one pointer or two pointers), then we expand to left and right.

func countSubstrings(s string) int {
    n := len(s)
    expanding := func(l, r int) int { // return the numbers of parlindrom substrings the given string contains
        result := 0
        for l >= 0 && r < n && s[l] == s[r] {
            result++
            l--
            r++
        }
        return result
    }
    result := 0
    for i := 0; i < n; i++ {
        result += expanding(i, i)
        result += expanding(i, i + 1)
    }
    return result
}

516. Longest Palindromic Subsequence

Denote dp[i][j] as the longest palindromic sequence in s[i:j], so if s[i] == s[j], dp[i][j] = 2 + dp[i + 1][j - 1]. Otherwise dp[i][j] = max(dp[i][j - 1], dp[i + 1][j]). Since dp[i][j] depends on dp[i+1][?] value, we should reverse the for loop

func longestPalindromeSubseq(s string) int {
    n := len(s)
    dp := make([][]int, n)
    for i := 0; i < n; i++ {
        dp[i] = make([]int, n)
        dp[i][i] = 1
    }
    for i := n - 1; i >= 0; i-- {
        for j = i + 1; j < n; j++ {
            if s[i] == s[j] {
                dp[i][j] = dp[i + 1][j - 1] + 2
            } else {
                dp[i][j] = max(dp[i + 1][j], dp[i][j - 1])
            }
        }
    }
    return dp[0][n - 1]
}

5. Longest Palindromic Substring

a. Dynamic Programming

Same as above, let’s denote dp[i][j] to flag if s[i:j] is a parlindrom. So we know if s[i] == s[j], dp[i][j] = dp[i + 1][j - 1]. and dp[i][i] = true.

func longestPalindrome(s string) string {
    n := len(s)
    dp := make([][]bool, n)
    for i := 0; i < n; i++ {
        dp[i] = make([]bool, n)
        dp[i][i] = true
    }
    max := 1
    result = string(s[0])
    for i := n - 1; i >= 0; i-- {
        for j := i + 1; j < n; j++ {
            if s[i] == s[j] {
                if j - i <= 1 {
                    dp[i][j] = true
                } else {
                    dp[i][j] = dp[i + 1][j - 1]
                }
                if dp[i][j] && max < j - i + 1 {
                    max = j - i + 1
                    result = s[i:j + 1]
                }
            }
        }
    }
    return result
}

b. Two pointers expand from center solution

func longestPalindrome(s string) string {
    n := len(s)
    expanding := func(l, r int) int { // return the longest length of the parlindrom in the given substring
        for l >= 0 && r < n && s[l] == s[r] {
            l--
            r++
        }
        return r - l - 1
    }
    max := 0
    start := 0
    for i := 0; i < n; i++ {
        p1 := expanding(i, i)
        p2 := expanding(i, i + 1)
        if p1 > p2 && max < p1 {
            start = i - (p1 - 1) / 2
            max = p1
        } else if max < p2 && p1 < p2 {
            start = i -  (p2 - 2) / 2
            max = p2
        }
    }
    return s[start:start + max]
}

Dynamic Programming III

2021-10-13T18:08:24.000Z

300. Longest Increasing Subsequence

If we define dp[i] as the longest increasing subsequence of [0, i]. Then dp[i] >= 1. And the state transition function is dp[i] = max(dp[i], dp[j] + 1) here j ∈ [0, i).

func lengthOfLIS(nums []int) int {
    n := len(nums)
    dp := make([]int, n)
    dp[0] = 1
    result = 1
    for i := 1; i < n; i++ {
        dp[i] = 1
        for j := 0; j < i; j++ {
            if nums[i] > nums[j] {
                dp[i] = max(dp[i], dp[j] + 1)
            }
        }
        result = max(result, dp[i])
    }
    return result
}

674. Longest Continuous Increasing Subsequence

func findLengthOfLCIS(nums []int) int {
    n := len(nums)
    dp := make([]int, n)
    dp[0] = 1
    result := 1
    for i := 1; i < n; i++ {
        if nums[i] > nums[i - 1] {
            dp[i] = dp[i - 1] + 1
        } else {
            dp[i] = 1
        }
        if result < dp[i] {
            result = dp[i]
        }
    }
    return result
}

We can reduce the space complexity to O(1)

func findLengthOfLCIS(nums []int) int {
    n := len(nums)
    count := 1
    result := 1
    for i := 1; i < n; i++ {
        if nums[i] > nums[i - 1] {
            count++
        } else {
            count = 1
        }
        if count > result {
            result = count
        }
    }
    return result
}

718. Maximum Length of Repeated Subarray

Let’s denote dp[i][j] as the maximum length of repeated subarray which ends with i and j. So we know that dp[i][j] = nums1[i] == nums[j] ? (dp[i-1][j-1] + 1) : 0

func findLength(nums1 []int, nums2 []int) int {
    m := len(nums1)
    n := len(nums2)
    dp := make([][]int, m + 1)
    for i := 0; i <= m; i++ {
        dp[i] = make([]int, n + 1)
    }
    result := 0
    for i := 1; i <= m; i++ {
        for j := 1; j <= n; j++ {
            if nums[i - 1] == nums2[j - 1] {
                dp[i][j] = dp[i - 1][j - 1] + 1
            }
            if dp[i][j] > result {
                result = dp[i][j]
            }
        }
    }
    return result
}

1143. Longest Common Subsequence

Similar like above, if we denote dp[i][j] as the maximum number commen sequence which ends with i and j. So we know dp[i][j] == text1[i] == text2[j] ? dp[i-1][j-1] + 1 : max(dp[i-1][j], dp[i][j-1]).

func longestCommonSubsequence(text1 string, text2 string) int {
    m := len(text1)
    n := len(text2)
    dp := make([][]int, m + 1)
    for i := 0; i <= m; i++ {
        dp[i] = make([]int, n + 1)
    }
    max := func(a, b int) int {
        if a > b {
            return a
        }
        return b
    }
    for i := 1; i <= m; i++ {
        for j := 1; j <= n; j++ {
            if text[i - 1] == text2[j - 1] {
                dp[i][j] = 1 + dp[i - 1][j - 1]
            } else {
                dp[i][j] = max(dp[i][j - 1], dp[i - 1][j])
            }
        }
    }
    return dp[m][n]
}

1035. Uncrossed Lines

If you compare this one wtih LCS problem above, actually they are exactly the same. The connection lines doesn’t have intersections means the we just need to get the LCS.

func maxUncrossedLines(nums1 []int, nums2 []int) int {
    m := len(nums1)
    n := len(nums2)
    dp := make([][]int, m + 1)
    for i := 0; i <= m; i++ {
        dp[i] = make([]int, n + 1)
    }
    max := func(a, b int) int {
        if a > b {
            return a
        }
        return b
    }
    for i := 1; i <= m; i++ {
        for j := 1; j <= n; j++ {
            if nums1[i - 1] == nums2[j - 1] {
                dp[i][j] = 1 + dp[i - 1][j - 1]
            } else {
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
            }
        }
    }
    return dp[m][n]
}

392. Is Subsequence

a. Naive two pointers

func isSubsequence(s string, t string) bool {
    if len(s) > len(t) {
        return false
    }
    i := 0
    for j := 0; i < len(s) && j < len(t); j++ {
        if s[i] == t[j] {
            i++
        }
    }
    return i == len(s)
}

b. Dynamic Programming

Let’s use dp[i][j] to denote the subsequence length ends with i and j. So the state transition function is dp[i][j] = s[i] == s[j] ? dp[i - 1][j - 1] + 1 : dp[i-1][j - 1]

func isSubsequence(s string, t string) bool {
    m := len(s)
    n := len(t)
    if m > n {
        return false
    }
    dp := make([][]int, m + 1)
    for i := 0; i <= m; i++ {
        dp[i] = make([]int, n + 1)
    }
    for i := 1; i <= m; i++ {
        for j := 1; j <= n; j++ {
            dp[i][j] = dp[i - 1][j - 1]
            if s[i - 1] == t[j - 1] {
                dp[i][j]++
            }
        }
    }
    return dp[m][n] == m
}

Stock Exchange Problems

2021-10-13T01:30:24.000Z

121. Best Time to Buy and Sell Stock

a. Two pointers greedy solution.

Since the profit is defined by the current price and the minimum price before today. So we can have one pointer holds the minimum price so far, and another pointer holds the max price so far, with the lowerest peak from the left and highest peak from the right, we can get the maximum profit.

func maxProfit(prices []int) int {
    profit := 0
    for min, i := 100001, 0; i < len(prices); i++ {
        if min > prices[i] {
            min = prices[i]
        }
        if prices[i] - min > profit {
            profit = prices[i] - min
        }
    }
    return profit
}

b. Dynamic programming

Let’s denote dp[i] as the profit we have so far, it can be two cases:

dp[i][0] We have stock so the profit we have for the first day if we buy stock is dp[0][0] = -prices[0]
dp[i][1] We don’t have stock

so the state transition function will be :

dp[i][0] = max(dp[i - 1][0], -prices[i]) the maximum value if we bought the stock in the previous day of we buy the stock on day i
dp[i][1] = max(dp[i - 1][0] + prices[i], dp[i-1][1]) the maximum value if we bought the stock before and sell it today, or we don’t have stock before and won’t buy today

func maxProfit(prices []int) int {
    n := len(prices)
    dp := make([][2]int, n)
    dp[0][0] = -prices[0]
    dp[0][1] = 0
    max := func(a, b int) int {
        if a > b {
            return a
        }
        return b
    }
    for i := 1; i < n; i++ {
        dp[i][0] = max(dp[i - 1][0], -prices[i])
        dp[i][1] = max(dp[i - 1][0] + prices[i], dp[i - 1][1])
    }
    return dp[n - 1][1]
}

122. Best Time to Buy and Sell Stock II

a. Greedy solution

To gian the maximum amount of profit, we just need to accumulate the position profits if we buy it on the previous day and sell it on the next day.

func maxProfit(prices []int) int {
    result := 0
    for i := 1; i < len(prices); i++ {
        profit := prices[i] - prices[i - 1]
        if profit > 0 {
            result += profit
        }
    }
    return result
}

b. Peak & Valley solution

A naive approach is find the local lowest price (valley price) and sell it at the next local highest price (peak price). Then we accumulate all of those local profits.

func maxProfit(prices []int) int {
    result := 0
    peak := prices[0]
    valley := prices[0]
    length := len(prices)
    for i := 0; i < length - 1; {
        for i < length - 1 && prices[i] >= prices[i + 1] {
            i++
        }
        valley = prices[i]
        for i < length - 1 && prices[i] <= prices[i + 1] {
            i++
        }
        peak = prices[i]
        result += peak - valley
    }
    return result
}

c. Dynamic programming

func maxProfit(prices []int) int {
    length := len(prices)
    dp := make([][2]int, length)
    // dp[i][0] on day i we are holding stock
    // dp[i][1] on day i we don't have stock
    dp[0] = [2]int{-prices[0], 0}
    max := func(a, b int) int {
        if a > b {
            return a
        }
        return b
    }
    for i := 1; i < length; i++ {
        // stock we got from day i - 1, or stock we are going to buy on day i
        dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i])
        // we don't have stock from day i - 1, or we are going to sell stock we got from day i - 1
        dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i])
    }
    return max(dp[length - 1][0], dp[length - 1][1])
}

123. Best Time to Buy and Sell Stock III

Since we can make two transactions at most, so there will be 5 status for a given day dp[i]

dp[i][0] We have made 0 transaction so far
dp[i][1] We bought the stock once so far
dp[i][2] We have made 1 full transaction once (bought/sold the stock once so far)
dp[i][3] We bought the stock twice and sold once so far
dp[i][4] We have made 2 full transaction once (bought/sold the stock twice so far)

func maxProfit(prices []int) int {
    n := len(prices)
    dp := make([][5]int, n)
    dp[0] = [5]int{0, -prices[0], 0, -prices[0], 0}  // dp[0][1] = dp[0][0] - prices[0], dp[0][2] = dp[0][1] + prices[0], dp[0][3] = dp[0][2] - prices[0], dp[0][4] = dp[0][3] + prices[0], 
    max := func(a, b int) int {
        if a > b {
            return a
        }
        return b
    }
    for i := 1; i < n; i++ {
        dp[i][0] = dp[i - 1][0]
        dp[i][1] = max(dp[i - 1][0] - prices[i], dp[i - 1][1])
        dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])
        dp[i][3] = max(dp[i - 1][2] - prices[i], dp[i - 1][3])
        dp[i][4] = max(dp[i - 1][3] + prices[i], dp[i - 1][4])
    }
    return dp[n-1][4]
}

We can also optimize the space complexity.

func maxProfit(prices []int) int {
    n := len(prices)
    dp := [5]int{0, -prices[0], 0, -prices[0], 0} 
    max := func(a, b int) int {
        if a > b {
            return a
        }
        return b
    }
    for i := 1; i < n; i++ {
        dp[1] = max(dp[0] - prices[i], dp[1])
        dp[2] = max(dp[1] + prices[i], dp[2])
        dp[3] = max(dp[2] - prices[i], dp[3])
        dp[4] = max(dp[3] + prices[i], dp[4])
    }
    return dp[4]
}

188. Best Time to Buy and Sell Stock IV

Same as the above solution, here each day will won 2 * k + 1 states.

func maxProfit(k int, prices []int) int {
    n := len(prices)
    if n == 0 {
        return 0
    }
    dp := make([][]int, n)
    max := func(a, b int) int {
        if a > b {
            return a
        }
        return b
    }
    for i := 0; i < n; i++ {
        dp[i] = make([]int, 2 * k + 1)
    }
    for i := 1; i < 2 * k + 1; i+=2 {
        dp[0][i] = -prices[0]
    }
    for i := 1; i < n; i++ {
        for j := 1; j < 2 * k + 1; j++ {
            if j % 2 == 1 {
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - 1] - prices[i])   
            } else {
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - 1] + prices[i])   
            }
        }
    }
    return dp[n - 1][2 * k]
}

We can reduce the space complexity to O(n)

func maxProfit(k int, prices []int) int {
    n := len(prices)
    if n == 0 {
        return 0
    }
    dp := make([]int, 2 * k + 1)
    max := func(a, b int) int {
        if a > b {
            return a
        }
        return b
    }
    for i := 1; i < 2 * k + 1; i+=2 {
        dp[i] = -prices[0]
    }
    for i := 1; i < n; i++ {
        for j := 1; j < 2 * k + 1; j++ {
            if j % 2 == 1 {
                dp[j] = max(dp[j], dp[j - 1] - prices[i])   
            } else {
                dp[j] = max(dp[j], dp[j - 1] + prices[i])   
            }
        }
    }
    return dp[2 * k]
}

309. Best Time to Buy and Sell Stock with Cooldown

Similar like the above problems, we need to define the states of i^th day based on the state machine diagram.

               -----
               |   |
               ⌄   |
          ------------
          | Cooldown | 
          ------------
            /        ^
   __      /          \
   | |    /            \
   ⌄ |   ⌄              \                              
------------         ------------
| Buy      |------- >| Sold     | 
------------         ------------

dp[i][0] we are holding the stock, so dp[i][0] = max(dp[i-1][0], dp[i-1][2] - prices[i])
dp[i][1] we are selling the stock, so dp[i][1] = dp[i - 1][0] + prices[i]
dp[i][2] we are in the cooldown period, so dp[i][2] = max(dp[i-1][2], dp[i-1][1])

func maxProfit(prices []int) int {
    n := len(prices)
    dp := make([][3]int, n)
    max := func(a, b int) int {
        if a > b {
            return a
        }
        return b
    }
    dp[0] = [3]int{-prices[0], 0, 0}
    for i := 1; i < n; i++ {
        dp[i][0] = max(dp[i-1][0], dp[i-1][2] - prices[i])
        dp[i][1] = dp[i-1][0] + prices[i]
        dp[i][2] = max(dp[i-1][2], dp[i-1][1])
    }
    return max(dp[n-1][1], dp[n-1][2])
}

We can also reduce the space complexity to O(n)

func maxProfit(prices []int) int {
    n := len(prices)
    max := func(a, b int) int {
        if a > b {
            return a
        }
        return b
    }
    hold := -prices[0]
    cooldown := 0
    sold := 0
    for i := 1; i < n; i++ {
        previousSold := sold
        sold = hold + prices[i]
        hold = max(hold, cooldown - prices[i])
        cooldown = max(cooldown, previousSold)
    }
    return max(cooldown, sold)
}

714. Best Time to Buy and Sell Stock with Transaction Fee

Same like #122, we just need to process the transaction fee when buying a new stock

func maxProfit(prices []int, fee int) int {
    n := len(prices)
    dp := make([][2]int, n)
    dp[0] = [2]int{-prices[0]-fee, 0}
    max := func(a, b int) int {
        if a > b {
            return a
        }
        return b
    }
    for i := 1; i < n; i++ {
        dp[i][0] = max(dp[i-1][0], dp[i-1][1] - prices[i] - fee)
        dp[i][1] = max(dp[i-1][1], dp[i-1][0] + prices[i])
    }
    return dp[n-1][1]
}

Bluetooth navigation code analysis

2021-10-10T20:54:33.000Z

Recently, I found a source code about Bluetooth positioning and navigation. Through its analysis and research, I have a deep understanding of the positioning and navigation process of the entire Bluetooth algorithm. Learn about Bluetooth signal acquisition, distance estimation, positioning calculation, Kalman model and other aspects.

structure

LocationEngine core modules include: model manager, Bluetooth locator, geo-locator, motion detector, area monitor and other modules.

i.modelManager = new T.ModelManager(t), 
i.roadNetData = new d.RoadNetData(t),  
i.navProcessor = new g.NavigationProcessor(t), 
i.bluetoothLocator = new l.BluetoothLocator(t), 
i.geoLocator = new c.GeoLocator(t), 
i.motionDetector = new u.MotionDetector(t), 
i.areaChecker = new f.AreaChecker(t),

ModelManager: Model manager.
RoadNetData: configuration-based road network data.
NavigationProcessor: Navigation processor.
BluetoothLocator: Bluetooth locator.
MotionDetector: Motion detector.

Bluetooth Locator

Locator initialization, default parameter settings and Bluetooth configuration information settings.

set default parameters.

value: function(t) {
    t || (t = {}),
    this.REC_INTERVAL = t.RecInterval ? t.RecInterval : 5e3,
    this.QUERY_INTERVAL = t.QueryInterval ? t.QueryInterval : 2e3,
    this.Z_CHECK_INTERVAL = t.ZCheckInterval ? t.ZCheckInterval : 3e3,
    this.ZInitTimeout = t.ZInitTimeout ? t.ZInitTimeout : 3e3,
    this.deviceType = void 0 !== t.deviceType ? t.deviceType : s.CONSTANTS.DEVICE.ANDROID
}

Configure Bluetooth beacons.

key: "addAps",
value: function(t) {
    t && (t.forEach(function(t) {
        void 0 === t.z && (t.z = t.re),
        t.rssiList = []
    }),
    this._aps = this._aps.concat(t))
}

By obtaining the Bluetooth signal data, LocationEngine calls the bluetoothLocator.updateBeacons() method to calculate the location.

1	var n = this.bluetoothLocator.updateBeacons(i, t.value, this.posMode, this.isIndoor, this.kfPos)

Filter non-Bluetooth configuration beacons and invalid rssi signals, and update the Bluetooth beacon signal queue.

key: "updateApsByReceivedBeacons",
 value: function(t, e) {
     var i = this;
     e.forEach(function(e) {
         var n = i._matchAp(e.major, e.minor); 
         if (n && "-100" !== e.rssi && "0" !== e.rssi && 0 !== e.rssi && -100 !== e.rssi) {
             var r = n.rssiList.push({
                 timestamp: t, 
                 rssi: parseInt(e.rssi)
             });
             n.status = 1,
             r > 15 && n.rssiList.shift()
         }
     })
 }

Get the current Bluetooth beacon, sort according to the signal strength, and set the Bluetooth beacon information strength.

for (var d, v = l.rssiList[Symbol.iterator](); !(c = (d = v.next()).done); c = !0) { 
           var p = d.value;
           i - p.timestamp < this.REC_INTERVAL && n.push({
               major: l.ma,
               minor: l.mi,
               x: l.x,
               y: l.y,
               region: l.re,
               timestamp: p.timestamp,
               rssi: p.rssi,
               z: l.z
           })  
 }

Filter the beacons whose distance between the beacon position and the last beacon position is greater than 100, and the time is greater than 2s.

h = (a = a.filter(function(t) {
               return !s || r.LocationUtils.distance(s, t) <= 100 
           })).filter(function(e) {
               return t - e.timestamp < o.QUERY_INTERVAL
           })

The filtered Bluetooth signals are sorted, and the first 5 are selected for weight and calculation, and the x and y position information is calculated according to the weight of the Bluetooth beacon.

key: "calBtPos",  
            value: function(e, i, n, r, s) {
                if (0 === e.length) 
                    return null;
                e.sort(function(t, e) { 
                    return e.rssi - t.rssi
                });
                var o = e[0].rssi  
                  , a = e.slice(0, 5); 
                t.calGradientWeight(a, o);  
                var h = a.reduce(function(t, e) {
                    return t + e.weight
                }, 0) 
                  , l = t.calConfidence(a) 
                  , c = t.calNearAPCount(a, o, r, s
                  , u = t.checkBoundaryState(a, n) 
                  , f = a.reduce(function(t, e) {   
                    return t + e.rssi
                }, 0) / a.length;
                return {
                    x: a.reduce(function(t, e) {  
                        return t + e.x * e.weight
                    }, 0) / h,
                    y: a.reduce(function(t, e) { 
                        return t + e.y * e.weight
                    }, 0) / h,
                    z: parseFloat(i), //
                    c: l, 
                    p: c, 
                    s: u, 
                    m: f 
                }
            }

Motion Detector

LocationEngine update accelerometer mode.

key: "updateAccSensorMode", 
value: function() {
    this.motionDetector ? this.accSensorStatus = this.motionDetector.getAccSensorStatus() : this.accSensorStatus = P.CONSTANTS.ACC_SENSOR_STATUS.EMPTY
}

Set accelerometer mode according to accelerometer frequency.

key: "checkAccSensorMode", 
value: function(t) {
    t - this.startTime < this.gravityTimeLen || (this.gravityList && 0 === this.gravityList.length && (this.accSensorStatus = o.CONSTANTS.ACC_SENSOR_STATUS.EMPTY),
    this.accCompBuffer.reduce(function(t, e) {
        return t + e
    }, 0) / this.accCompBufferLen > 9 && (this.accFreq = 1e3 * this.gravityList.length / this.gravityTimeLen,
    this.accFreq < 13 ? this.accSensorStatus = o.CONSTANTS.ACC_SENSOR_STATUS.LOW_FREQ : this.accFreq >= 22 && (this.accSensorStatus = o.CONSTANTS.ACC_SENSOR_STATUS.NORMAL)))
}

By obtaining the compass data, LocationEngine calls the motionDetector.updateHeading() method and passes in the angle value of the current device.

key: "updateHeading", 
             value: function(t) {
                 this.headingChange = this.headingFlag ? t.value.heading - this.headingDeg : 0,
                 this.headingDeg = t.value.heading, 
                 this.motionDetector.updateHeading(t.timestamp, t.value.heading),
                 this.headingFlag = !0
             }

LocationEngine calls the motionDetector.detectMotion() method to process the acceleration data.

1 2	key: "updateAcc", var n = this.motionDetector.detectMotion(t, e, i);

By analyzing and processing the motion state of the device, the number of steps, step length, mobile phone posture, motion state, etc. are obtained.

this.motionResult = Object.assign({
                       t: t,  
                       stepDetected: a, 
                       step: h,
                       phonePlacement: this.phonePlacement,
                       motionState: this.motionState 
                   }, l  )

step counting

key: "detectStep", 
              value: function(t, e, i) {
                  var n = !1; 
                  return 0 !== this.peakTime   
                              && this.peakValleyPair.pvDiff > this.PeakValleyTh 
                              && t - this.peakTime > this.MinPeakInterval 
                              && this.peakTime - this.stepTime > this.MinStepInterval 
                              && (this.stepTime = this.peakTime,
                                     this.stepCount += 1,
                                     this.saver && 
                                     this.saver.saveStepResult(this.stepTime, this.peakValleyPair.peak, this.peakValleyPair.valley, this.PeakValleyTh),
                                     n = !0),
                              e < this.valleyValue 
                              && (this.valleyValue = e,this.valleyTime = t),
                             this.validValleyValue = t - this.lastValleyVTime < 2 * this.MinStepInterval 
                                  && this.lastValleyVTime > this.stepTime 
                                  && this.lastValleyValue < this.valleyValue ? this.lastValleyValue : this.valleyValue,
                             0 !== i && 1 === this.detectPeak(t, e, i)  
                                   && i - this.validValleyValue > 1.3 
                                   && (this.saver && this.saver.savePeakResult(t, i, this.validValleyValue, i - this.validValleyValue), //
                             t - this.peakTime > this.MinPeakInterval && (this.PeakValleyTh = this.peakValleyThresholdUpdate(i - this.validValleyValue),
                            this.lastValleyValue = this.valleyValue,
                            this.lastValleyVTime = this.valleyTime,
                            this.valleyValue = 100,
                            this.peakTime = t,
                            this.peakValleyPair = {
                                   peak: i,
                                   valley: this.validValleyValue,
                                  pvDiff: i - this.validValleyValue
                                  }),
                            t - this.peakTime <= this.MinPeakInterval 
                               && i > this.peakValleyPair.peak && (this.peakTime = t,
                                      this.validValleyValue = this.validValleyValue < this.peakValleyPair.valley ? this.validValleyValue : this.peakValleyPair.valley,
                                      this.peakValleyPair = {
                                           peak: i,
                                           valley: this.validValleyValue,
                                           pvDiff: i - this.validValleyValue
                              })),
                           n
              }

Model Manager

Kalman filter model setting parameters。

i.pdrKf = new o.KalmanFilterPDR(i.t,a.KF_TYPE.PDR_WLK,t.deviceType,t.params),
i.diffKf = new s.KalmanFilterDiffHeading(i.t,a.KF_TYPE.DIFF_WLK,t.deviceType,t.params),
i.baseKf = new s.KalmanFilterDiffHeading(i.t,a.KF_TYPE.DIFF_BASE,t.deviceType,t.params),
i.drvKf = new s.KalmanFilterDiffHeading(i.t,a.KF_TYPE.DIFF_DRV,t.deviceType,t.params),

When the location engine gets new location information, it will pass this information to the model manager for processing and analysis. The model manager updates the Kalman filter model based on the current location state and historical data.

key: "updateFusionModels", 
value: function(t, e, i, n, r, s, o, a, l, u) {
    if (this.started || this.checkInitSignal(t, n, r) && (this.t = t,
    this.started = !0,
    this.z = e,
    this.isARLast(this.arLastPos, n, r)),
    this.started) { 
        e !== this.z && (this.z = e,
        h.LocationUtils.distance(i, n) < h.LocationUtils.distance(i, r) && h.LocationUtils.distance(i, n) < 10 ? this.reStartModels(n, null) : this.reStartModels(n, r));
        this.t;
        this.t = t,
        this.pdrKf.update(t, n, r, s, o, a, l, u),
        this.diffKf.update(t, n, r, s, l, u),
        this.baseKf.update(t, n, r, void 0, u),
        this.drvKf.update(t, n, r, s, !1, u),
        this.drvOutKF.update(t, n, r, s, l),
        this.updateBaseKfInfos(c.Numerical.rad2deg(s))  
    }
}

Kafman filter direction angle。

key: "getHeadingDeg",
value: function() {
    if (this.kalmanModel)
        return h.Numerical.rad2deg(Math.atan2(this.kalmanModel.x_k.elements[1], this.kalmanModel.x_k.elements[3]))
}

Get Kalman filter position.

key: "getPosition",
value: function() {
    if (this.kalmanModel)
        return {
            x: this.kalmanModel.x_k.elements[0],
            y: this.kalmanModel.x_k.elements[2]
        }
}

Get the Kalman filter speed.

key: "getVelocity",
value: function() {
    if (this.kalmanModel)
        return {
            x: this.kalmanModel.x_k.elements[1],
            y: this.kalmanModel.x_k.elements[3]
        }
}

Knapsack Problems II

2021-10-10T05:14:24.000Z

377. Combination Sum IV

This is also a full knapsack problem. It looks similar to the coins change ii, but the difference here is that we need to get the permutation of the solutions instead of combination. So in this case we need to iterate the knapsack space first, then iterate the items.

func combinationSum4(nums []int, target int) int {
    dp := make([]int, target + 1)
    dp[0] = 1
    for i := 1; i <= target; i++ {
        for j := 0; j < len(nums); j++ {
            if i >= nums[j] {
                dp[i] += dp[i - nums[j]]
            }
        }
    }
    return dp[target]
}

279. Perfect Squares

This is also a full knapsack problem. We can consider all squares not greater than the given n as items, n as the knapsack total capacity, and we can reuse all items to fill the knapsack. To get the minimal items, the state transition function is dp[i] = min(dp[i], dp[i - j] + 1

func numSquares(n int) int {
    squares := []int{}
    for i := 1; i * i <= n; i++ {
        squares = append(squares, i * i)
    }
    dp := make([]int, n + 1)
    dp[1] = 1
    min := func(a, b int) int {
        if a < b {
            return a
        }
        return b
    }
    for i := 2; i <= n; i++ {
        for j := 0; j < len(squares); j++ {
            if i >= squares[j] {
                dp[i] = min(dp[i], dp[i - squares[j]] + 1) // here we are counting the number, so we increase the items count.
            }
        }
    }
    return dp[n]
}

We can also try to use backtracking to resolve this problem.

func numSquares(n int) int {
    squares := []int{}
    for i := 1; i * i <= n; i++ {
        squares = append(squares, i * i)
    }
    hash := make(map[int]int)
    min := func(a, b int) int {
        if a < b {
            return a
        }
        return b
    }
    var backtracking func(int) int
    backtracking = func(index int) int {
        if v, ok := hash[index]; ok {
            return v
        }
        if index == 0 {
            return 0
        }
        count := n + 1
        for j := 0; j < len(squares); j++ {
            if index >= squares[j] {
                count = min(count, backtracking(index - squares[j]) + 1)   
            }
        }
        hash[index] = count
        return count
    }
    return backtracking(n)
}

139. Word Break

Obviously, an empty string can be part of any string. So if we denote dp[i] as s[:i] which can be constructed by the worddict, dp[0] is true. And the state transition function can be dp[i] = dp[i - len(words[j]] && words[j] == s[i - len(words[j]):i]. We can consider this as a full knapsack problem. Words can be consider as items, and the s can be considered as a special knapsack.

func wordBreak(s string, wordDict []string) bool {
    dp := make([]bool, len(s) + 1)
    dp[0] = true
    for i := 1; i <= len(s); i++ {
        for j := 0; j < len(wordDict); j++ {
            if i >= wordDict[j] {
                dp[i] = dp[i] || (dp[i - len(wordDict[j])] && wordDict[j] == s[i - len(wordDict[j]):i])
            }
        }
    }
    return dp[len(s)]
}

We can also optimize it with a hashmap to store all words

func wordBreak(s string, wordDict []string) bool {
    dp := make([]bool, len(s) + 1)
    hash := make(map[string]bool)
    for _, word := range wordDict {
        hash[word] = true
    }
    dp[0] = true
    for i := 1; i <= len(s); i++ {
        for j := 0; j < i; j++ {
            dp[i] = dp[i] || (dp[j] && hash[s[j:i]])
        }
    }
    return dp[len(s)]
}

Dynamic Programming II

2021-10-08T18:04:24.000Z

494. Target Sum

a. Brute-force DFS recursive solution

func findTargetSumWays(nums []int, target int) int {
    count := 0
    var dfs func(int ,int)
    dfs = func(index, left int) {
        if index == len(nums) {
            if left == 0 {
                count++
            }
        } else {
            dfs(index + 1, left + nums[index])
            dfs(index + 1, left - nums[index])
        }
    }
    dfs(0, target)
    return count
}

b. Dynamic Programming

dp[i][j] refers to the number of assignments which can lead to a sum of j up to the ith items in the Array. We can get the state transition function: dp[i][j] = dp[i - 1][j + nums[i]] + dp[i - 1][j - nums[i]]

func findTargetSumWays(nums []int, target int) int {
    sum := 0
    for _, num := range nums {
        sum += num
    }
    if sum < target || -sum > target || (sum + target) % 2 != 0 {
        return 0
    }
    n := len(nums)
    dp := make([][]int, n)
    for i := 0; i < n; i++ {
        dp[i] = make([]int, 2 * sum + 1)
    }
    dp[0][sum + nums[0]] = 1
    dp[0][sum - nums[0]] += 1
    for i := 1; i < n; i++ {
        for j := -sum; j <= sum; j++ {
            if j + nums[i] < sum + 1 {
                dp[i][j + sum + nums[i]] += dp[i - 1][j + sum]
            }   
            if j + sum - nums[i] >= 0 {
                dp[i][j + sum - nums[i]] += dp[i - 1][j + sum]   
            }
        }
    }
    return dp[n - 1][sum + target]
}

c. Knapsack solution (subset sum)

Based on the problem description, we will have two subsets. One with positive symbol (s1) and another one with negative symbol (s2). So s1 + s2 = sum and s1 - s2 = target. We can convert this problem to a 0-1 knapsack problem — find a subset which subtotal is s1 = (sum + target) / 2.

func findTargetSumWays(nums []int, target int) int {
    sum := 0
    zero := 0
    sort.Ints(nums)  // to make sure we can handle cases contains 0
    for _, num := range nums {
        if num == 0 {
            zero++
        }
        sum += num
    }
    if sum < target || -sum > target || (sum + target) % 2 != 0 {
        return 0
    }
    n := len(nums)
    target = (sum + target) / 2
    dp := make([][]int, n + 1)
    for i := 0; i <= n; i++ {
        dp[i] = make([]int, target + 1)
        dp[i][0] = 1
    }
    for i := 1; i <= n; i++ {
        for j := 1; j <= target; j++ {
            dp[i][j] = dp[i-1][j]
            if j >= nums[i - 1] {
                dp[i][j] += dp[i-1][j - nums[i - 1]]
            }
        }
    }
    return dp[n][target] * int(math.Pow(float64(2), float64(zero)))
}

We can use 1D rolling array to reduce the space complexity.

func findTargetSumWays(nums []int, target int) int {
    sum := 0
    zeros := 0
    sort.Ints(nums)
    for _, num := range nums {
        sum += num
        if num == 0 {
            zeros++
        }
    }
    if sum < target || -sum > target || (sum + target) % 2 == 1 {
        return 0
    }
    n := len(nums)
    target = (sum + target) / 2
    dp := make([]int, target + 1)
    dp[0] = 1
    for i := 0; i < n; i++ {
        for j := target; j >= nums[i]; j-- {
            dp[j] += dp[j - nums[i]]
        }
    }
    return dp[target] * int(math.Pow(float64(2), float64(zeros)))
}

198. House Robber

State transition function: dp[i] = max(dp[i - 1], dp[i - 2] + value[i]

func rob(nums []int) int {
    n := len(nums)
    dp := make([]int, n + 1)
    dp[1] = nums[0]
    max := func(a, b int) int {
        if a > b {
            return a
        }
        return b
    }
    for i := 2; i <= n; i++ {
        dp[i] = max(dp[i - 1], dp[i - 2] + nums[i - 1])
    }
    return dp[n]
}

213. House Robber II

Since we only need to compare [0, n-1] and [1, n] cases, and those two can be resolved with the solution we have above.

func rob(nums []int) int {
    max := func(a, b int) int {
        if a > b {
            return a
        }
        return b
    }
    if len(nums) == 1 {
        return nums[0]
    }
    basicRobber := func(nums []int) int{
        n := len(nums)
        dp := make([]int, n + 1)
        dp[1] = nums[0]
        for i := 2; i <= n; i++ {
            dp[i] = max(dp[i - 1], dp[i - 2] + nums[i - 1])
        }
        return dp[n]
    }
    return max(basicRobber(nums[:len(nums) - 1]), basicRobber(nums[1:len(nums)]))
}

337. House Robber III

a. DFS + memorized result

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func rob(root *TreeNode) int {
    cache := make(map[*TreeNode]int)
    var dfs func(*TreeNode) int
    dfs = func(root *TreeNode) int {
        if root == nil {
            return 0
        }
        if value, ok := cache[root]; ok {
            return value
        }
        rootValue := root.Val
        if root.Left != nil {
            rootValue += dfs(root.Left.Left) + dfs(root.Left.Right)
        }
        if root.Right != nil {
            rootValue += dfs(root.Right.Left) + dfs(root.Right.Right)
        }
        childValue := dfs(root.Left) + dfs(root.Right)
        maxValue := childValue
        if rootValue > childValue {
            maxValue = rootValue
        }
        cache[root] = maxValue
        return maxValue
    }
    return dfs(root)
}

b. Dynamic Programming to cache more calculation results.

Since each node has two values, with or without its own value. The above one only caches the maxValue, if we cache both of those in an array, it will speed up the calculating.

func rob(root *TreeNode) int {
    cache := make(map[*TreeNode][2]int)
    var dfs func(*TreeNode) [2]int
    max := func(a, b int) int {
        if a > b {
            return a
        }
        return b
    }
    dfs = func(root *TreeNode) [2]int {
        if root == nil {
            return [2]int{0, 0}
        }
        if value, ok := cache[root]; ok {
            return value
        }
        rootValue := root.Val
        leftValue := dfs(root.Left)
        rightValue := dfs(root.Right)
        childValue := max(leftValue[0], leftValue[1]) + max(rightValue[0], rightValue[1])
        cache[root] = [2]int{rootValue + leftValue[1] + rightValue[1], childValue}
        return cache[root]
    }
    value := dfs(root)
    return max(value[0], value[1])
}

Knapsack Problems I

2021-10-08T05:12:24.000Z

The knapsack problem is a problem in combinatorial optimization: Given a set of items, each with a weight and a value, determine the number of each item to include in a collection so that the total weight is less than or equal to a given limit and the total value is as large as possible.

416. Partition Equal Subset Sum

We can quickly get the result if the sum is an odd number. If the sum is an even number s, it means we need to find some items in the slice which can get a sum to s / 2. Now the problem becomes a classical 0-1 knapsack problem.

a. Classical 0-1 knapsack solution

Denote dp[i][j] as if we can construct a sum j from the first i items. So the state transition function is dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i]]. The value is determined by:

If we don’t use the current item, we need to check if we can construct the target j by the first i - 1 items: dp[i-1][j]
If we use the current item, we need to check if we can construct the target j - nums[i] by the first i - 1 items: dp[i - 1][j - nums[i]]

func canPartition(nums []int) bool {
    sum := 0
    for _, num := range nums {
        sum += num
    }
    if sum % 2 == 1 {
        return false
    }
    target := sum / 2
    n := len(nums)
    dp := make([][]bool, n + 1)
    for i := 0; i <= n; i++ {
        dp[i] = make([]bool, target + 1)
        dp[i][0] = true
    }
    for i := 1; i <= n; i++ {
        for j := 1; j <= target; j++ {
            if j >= nums[i - 1] {
                dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i - 1]]
            } else {
                dp[i][j] = dp[i - 1][j]
            }
        }
    }
    return dp[n][target]
}

b. Rolling array solution

Based on the state transition function above, we can simplifiy it by using a 1D array. dp[i] = dp[i] || dp[i - nums[i]]. Note since this time in the 1D array, the left part has side effect to the right side, so we need to iterate the array from right to left.

func canPartition(nums []int) bool {
    sum := 0
    for _, num := range nums {
        sum += num
    }
    if sum % 2 == 1 {
        return false
    }
    target := sum / 2
    n := len(nums)
    dp := make([]bool, target + 1)
    dp[0] = true
    for i := 0; i < n; i++ {
        for j := target; j >= nums[i]; j-- {
            dp[j] = dp[j] || dp[j - nums[i]]
        }
    }
    return dp[target]
}

Note: the two solutions above are using bool value as dp array value type, we can also use int to store the sum we can get. So the state transition function will be dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]). At the end, we just need to veryfy dp[target] == target.

1049. Last Stone Weight II

a. Dynamic programming

To get the minimum result, we need to try our best to split the stones into two similar weight subsets. Let’s denote the sum as the total weight of all stones, so we need to find target = sum/2 to get the minimum sum - 2 * target

func lastStoneWeightII(stones []int) int {
    sum := 0
    for _, stone := range stones {
        sum += stone
    }
    target := sum / 2
    n := len(stones)
    dp := make([][]int, n + 1)
    for i := 0; i <= n; i++ {
        dp[i] = make([]int, target + 1)
    }
    for i := 1; i <= n; i++ {
        for j := 0; j <= target; j++ {
            if j >= stones[i - 1] && dp[i - 1][j] < dp[i - 1][j - stones[i - 1]] + stones[i - 1] {
                dp[i][j] = dp[i - 1][j - stones[i - 1]] + stones[i - 1]
            } else {
                dp[i][j] = dp[i - 1][j]
            }
        }
    }
    return sum - 2 * dp[n][target]
}

We can use 1D rolling array

func lastStoneWeightII(stones []int) int {
    sum := 0
    for _, stone := range stones {
        sum += stone
    }
    target := sum / 2
    n := len(stones)
    dp := make([]int, target + 1)
    for i := 0; i < n; i++ {
        for j := target; j >= stones[i]; j-- {
            if dp[j] < dp[j - stones[i]] + stones[i] {
                dp[j] = dp[j - stones[i]] + stones[i]
            }
        }
    }
    return sum - 2 * dp[target]
}

b. Brute-force Set

We can get all possible combinations of the sum and find the minimum absolute value.

func lastStoneWeightII(stones []int) int {
    sum := stones[0]
    hash := make(map[int]bool)
    hash[stones[0]] = true
    hash[-stones[0]] = true
    n := len(stones)
    for i := 1; i < n; i++ {
        sum += stones[i]
        temp := make(map[int]bool)
        for key, _ := range hash {
            temp[key + stones[i]] = true
            temp[key - stones[i]] = true
        }
        hash = temp
    }
    result := sum + 1
    for key, _ := range hash {
        if key >= 0 && key < result{
            result = key
        } else if key < 0 && -key < result {
            result = -key
        }
    }
    return result
}

474. Ones and Zeroes

Each items have two properties (1 amount and 0 amount) and we need to get the maximum sum of a subset based on the two dememsion restrictions (total 1 amount n and total 0 amount m). It can be considered as a classical two dememsion 0-1 knapsack problem. So the state transition function is dp[i][j] = max(dp[i][j], dp[i - zeros][j - ones] + 1) (Note, ideally we need 3D array to solve this problem, but based on the state transition function, we can reduce to a 2D rolling array with reverse for-loop).

func findMaxForm(strs []string, m int, n int) int {
    dp := make([][]int, m + 1)
    for i := 0; i <= m; i++ {
        dp[i] = make([]int, n + 1)
    }
    for _, str := range strs {
        ones := strings.Count("1")
        zeros := strings.Count("0")
        for i := m; i >= zeros; i-- {
            for j := n; j >= ones; j-- {
                pickme := dp[i - zeros][j - ones] + 1
                if dp[i][j] < pickme {
                    dp[i][j] = pickme
                }
            }
        }
    }
    return dp[m][j]
}

322. Coin Change

This is a classical full knapsack problem. The state transition function is dp[i] = min(dp[i], dp[i - coins[i]] + 1). Since we need to get the minimal number, so the initial value needs to be an integer which is out of the scope (except dp[0] which is 0). We can either use math.MaxInt32 or amount + 1

a. Traverse knapsack volume first.

func coinChange(coins []int, amount int) int {
    dp := make([]int, amount + 1)
    dp[0] = 0
    for i := 0; i <= amount; i++ {
        dp[i] = math.MaxInt32
    }
    min := func(a, b int) int {
        if a < b {
            return a
        }
        return b
    }
    for i := 1; i <= amount; i++ {
        for j := 0; j < len(coins); j++ {
            if i >= coins[j] && dp[i - coins[j]] != math.MaxInt32 { // If we pick one current coin and there's some calculated solution to the state dp[i - coins[j]] which is not the initial value, then we have a valid solution
                dp[i] = min(dp[i], dp[i - coins[j]] + 1)
            }
        }   
    }
    if dp[amount] == math.MaxInt32 {
        return -1
    }
    return dp[amount]
}

b. Traverse items first.

func coinChange(coins []int, amount int) int {
    dp := make([]int, amount + 1)
    dp[0] = 0
    for i := 1; i <= amount; i++ {
        dp[i] = math.MaxInt32
    }
    min := func(a, b int) int {
        if a < b {
            return a
        }
        return b
    }
    for i := 0; i < len(coins); i++ {
        for j := coins[i]; j <= amount; j++ {
            if dp[j - coins[i]] != math.MaxInt32 {
                dp[j] = min(dp[j], dp[j - coins[i]] + 1)   
            }
        }
    }
    if dp[amount] == math.MaxInt32 {
        return -1
    }
    return dp[amount]
}

518. Coin Change 2

This is is also a full knapsack problem. The difference between this and the above is that we need to get the amount of combinations. So the state transition function is dp[i] += dp[i - coins[j]]. Since here each coin change solution is a combination problem instead of permutation problem, we can only iterate the coins first. If we iterate the knapsack space first, we will get the duplicated result like [[coins[0], coins[1]], [coins[1], coins[0]]].

func change(amount int, coins []int) int {
    dp := make([]int, amount + 1)
    dp[0] = 1
    for i := 0; i < len(coins); i++ {
        for j := coins[i]; j <= amount; j++ {
            dp[j] += dp[j - coins[i]]
        }
    }
    return  dp[amount]
}

Based on the problems above, we can get a knapsack problem solution template

0-1 knapsack template

dp := make([]int, amount + 1)
dp[0] = // Initial value based on the problem
for i := 0; i <= len(nums); i++ {
    for j := amount; j >= nums[i]; j-- {
        // state transition function
        // dp[j] = dp[j] || dp[j - nums[i]]
        // dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])
    }
}

full knapsack template to get the combination of items

dp := make([]int, amount + 1)
dp[0] = // Initial value based on the problem
// dp[i] = // Initial value based on the problem, could be 0 for total solutions counting or min/max value to get the maximum/minimum expectation
for i := 0; i < len(nums); i++ {
    for j := nums[i]; j <= amount; j++ {
        // state transition function
        // dp[j] += dp[j - nums[i]]
        // dp[j] = min(dp[j], dp[j - nums[i]] + nums[i])
    }
}

full knapsack template to get the permutation of items

dp := make([]int, amount + 1)
dp[0] = // Initial value based on the problem
// dp[i] = // Initial value based on the problem, could be 0 for total solutions counting or min/max value to get the maximum/minimum expectation
for j := 0; j <= amount; j++ {
    for i := 0; i < len(nums); i++ {
        // state transition function
        // dp[j] += dp[j - nums[i]]
        // dp[j] = min(dp[j], dp[j - nums[i]] + nums[i])
    }
}

Dynamic Programming I

2021-10-07T05:00:25.000Z

Dynamic Programming (commonly referred to as DP) is an algorithmic technique for solving a problem by recursively breaking it down into simpler subproblems and using the fact that the optimal solution to the overall problem depends upon the optimal solution to it’s individual subproblems. Here is an interesting Quora question How should I explain dynamic programming to a 4-year-old?.

509. Fibonacci Number

a. Recursive solution

func fib(n int) int {
    if n < 2 {
        return n
    }
    fib0 := fib(n - 2)
    fib1 := fib(n - 1)
    return fib0 + fib1
}

b. Dynamic Programming

State transition function: dp[i] = dp[i - 1] + dp[i - 2]

func fib(n int) int {
    if n < 2 {
        return n
    }
    dp := make([]int, n + 1)
    dp[0] = 0
    dp[1] = 1
    for i := 2; i <= n; i++ {
        dp[i] = dp[i - 1] + dp[i - 2]
    }
    return dp[n]
}

70. Climbing Stairs

State transition function: dp[i] = dp[i - 1] + dp[i - 2]

func climbStairs(n int) int {
    if n < 3 {
        return n
    }
    dp := make([]int, n + 1)
    dp[0] = 0
    dp[1] = 1
    dp[2] = 2
    for i := 3; i <= n; i++ {
        dp[i] = dp[i - 1] + dp[i - 2]
    }
    return dp[n]
}

If given we can climb the stairs from 1 ~ m steps each time, how to solve this problem? It becomes a full knapsack problem now. And the state transition function is dp[i] += dp[i - j], here 2 is the special case.

func climbStairs(n int) int {
    steps := []int{1, 2}
    dp := make([]int, n + 1)
    dp[0] = 1
    for i := 1; i <= n; i++ {
        for j := 0; j < len(steps); j++ {
            if i >= steps[j] {
                dp[i] += dp[i - steps[j]]
            }
        }
    }
    return dp[n]
}

746. Min Cost Climbing Stairs

Denote dp[i] to the cost we want to step away from stair ith, so the state transition function: min(dp[i - 1], dp[i - 2]) + cost[i].

func minCostClimbingStairs(cost []int) int {
    n := len(cost)
    dp := make([]int, n)
    min := func(a, b int) int {
        if a < b {
            return a
        }
        return b
    }
    dp[0] = cost[0]
    dp[1] = cost[1]
    for i := 2; i < n; i++ {
        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]
    }
    return min(dp[n - 1], dp[n - 2]) // To reach to stair n, we can step away from n - 1 or n - 2
}

Another way to think about it. If we denote dp[i] as the cost to reach to ith stair, the state transition function is dp[n] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2])

func minCostClimbingStairs(cost []int) int {
    n := len(cost)
    dp := make([]int, n + 1)
    min := func(a, b int) int {
        if a < b {
            return a
        }
        return b
    }
    for i := 2; i <= n; i++ {
        dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2])
    }
    return dp[n]
}

62. Unique Paths

It’s easy to get the state transition function dp[i][j] = dp[i - 1][j] + dp[i][j - 1] . Note for the special case first line and first row, the value is 1.

func uniquePaths(m int, n int) int {
    dp := make([][]int, m)
    for i := 0; i < m; i++ {
        dp[i] = make([]int, n)
        dp[i][0] = 1
    }
    for i := 0; i < n; i++ {
        dp[0][i] = 1
    }
    for i := 1; i < m; i++ {
        for j := 1; j < n; j++ {
            dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
        }
    }
    return dp[m - 1][n - 1]
}

Based on the state transition function, dp[i][j] is defined only by two values, so we can optimize the space complexity from O(m * n) to O(n) by using a new state transition function dp[j] = dp[j] + dp[j - 1]

func uniquePaths(m int, n int) int {
    dp := make([]int, n)
    for i := 0; i < n; i++ {
        dp[i] = 1
    }
    for i := 1; i < m; i++ {
        for j := 1; j < n; j++ {
            dp[j] += dp[j - 1]
        }
    }
    return dp[n - 1]
}

63. Unique Paths II

This is a similar problem to #62. The only difference is that we need to reset the path sum to 0 if there’s an obstacle at the coordinate.

func uniquePathsWithObstacles(obstacleGrid [][]int) int {
    m := len(obstacleGrid)
    n := len(obstacleGrid[0])
    dp := make([]int, n)
    for i := 0; i < n; i++ {
        if obstacleGrid[0][i] = 1 {
            dp[i] = 0
        } else if i == 0 {
            dp[i] = 1
        } else {
            dp[i] = dp[i - 1]
        }
    }
    for i := 1; i < m; i++ {
        for j := 0; j < n; j++ {
            if obstacleGrid[i][j] == 1{
                dp[i] = 0
            } else if j > 0 {
                dp[i] += dp[i - 1]
            }
        }
    }
    return dp[n - 1]
}

343. Integer Break

The key point of solving this problem is to get the state transition function. There are two cases:

we can split the number i into two i - j and j
we can split the number into more than two, this case we can reuse the cached value from dp array. dp[i - j] * j

So the state transition function dp[i] = max(dp[i], dp[i - j] * j, (i - j) * j)

func integerBreak(n int) int {
    dp := make([]int, n + 1)
    dp[1] = 1
    dp[2] = 1
    max := func(a, b int) int {
        if a > b {
            return a
        }
        return b
    }
    for i := 3; i <= n; i++ {
        for j := 1; j < i; j++ {
            two := j * (i - j)
            twoMore := j * dp[i - j]
            dp[i] = max(dp[i], max(two, twoMore))
        }
    }
    return dp[n]
}

96. Unique Binary Search Trees

Based on the BST specs, we can get the state transition function dp[i] = dp[j] * dp[i - j - 1], here dp[i] denotes when i is set to the root node, we have j nodes on left child and i - j - 1 on right child. Note here the base case is 1. If there’s 0 nodes on left tree, it means we can construct the left tree in one uniq way.

func numTrees(n int) int {
    if n < 3 {
        return n
    }
    dp := make([]int, n + 1)
    dp[0] = 1
    dp[1] = 1
    dp[2] = 2
    for i := 3; i <= n; i++ {
        for j := 0; j < i; j++ {
            dp[i] += dp[j] & dp[i - j - 1]
        }
    }
    return dp[n]
}

Greedy Problems - III

2021-10-07T04:55:24.000Z

56. Merge Intervals

Similar to other sgement related problems. The first thing we need to do is to sort the slice. Once we have a sorted segment slice, we can iterate over all items and merge them. Note there is one edge case we need to cover after the iteration, either we merged all segments into one or the last one can’t be merged into the previous segment.

func merge(intervals [][]int) [][]int {
    sort.Slice(intervals, func(a, b int) bool {
        return intervals[a][0] < intervals[b][0]
    })
    result := []int{}
    start := intervals[0][0]
    end := intervals[0][1]
    for i := 0; i < len(intervals); i++ {
        if end < intervals[i][0] {
            result = append(result, []int{start, end})
            start = intervals[i][0]
            end = intervals[i][1]
        } else if end < intervals[i][1] {
            end = intervals[i][1]
        }
    }
    result = append(result, []int{start, end})
    return result
}

763. Partition Labels

738. Monotone Increasing Digits

968. Binary Tree Cameras

Greedy Problems - II

2021-10-05T17:25:24.000Z

1005. Maximize Sum Of Array After K Negations

To get a maximum sum, we need to convert as many negative numbers to positive ones. If there is still an odd times of converting number left, we just need to convert the smallest positive number to a negative one

func largestSumAfterKNegations(nums []int, k int) int {
    sort.Ints(nums)
    i := 0
    for i < k && i < len(nums) {
        if nums[i] < 0 {
            nums[i] = -nums[i]
            i++
        } else {
            break
        }
    }
    if i < k && (k - i) % 2 == 1 {
        sort.Ints(nums)
        nums[0] = -nums[0]
    }
    result := 0
    for _, num := range nums {
        result += num
    }
    return result
}

134. Gas Station

Several cases:
1) If the total amount of gas is less than the total amount of the cost, we can’t make a round trip
2) Given an arbitrary start point i, and at i we have gas[i] in the tank. Let’s start at this point and accumulate the gas we left in the tank. If at point i + k the acculation is negative, it means we can’t reach from any point in beteeen [i, i + k - 1) to point k. So we can quickly start from i + k + 1 instead of i + 1.

So the local optimal solution for a given start point is from this starting point, we are making a round trip, the debet won’t be negative. If it’s negative, we need to start after the negative point. This can lead to a global optimal solution.

func canCompleteCircuit(gas []int, cost []int) int {
    result := 0
    sum := 0
    debet := 0
    for i := 0; i < len(gas); i++ {
        sum += gas[i] - cost[i]
        debet += gas[i] - cost[i]
        if debet < 0 {
            debet = 0
            result = i + 1
        }
    }
    if sum < 0 {
        return -1
    }
    return result
}

135. Candy

Since the rating only have effect to neighbour candy distribution. We can start from one end to distribution the candy once, to make sure all children are happy when looking to their right. Then we make another round from the other end.

func candy(ratings []int) int {
    length := len(ratings)
    candies := make([]int, length)
    candies[0] = 1
    for i := 1; i < length; i++ {
        if ratings[i] > ratings[i - 1] {
            candies[i] = candies[i - 1] + 1
        } else {
            candies[i] = 1   
        }
    }
    for i := length - 2; i >= 0; i-- {
        if ratings[i] > ratings[i + 1] && candies[i] < candies[i + 1] + 1 {
            candies[i] = candies[i + 1] + 1
        }
    }
    result := 0
    for i := 0; i < length; i++ {
        result += candies[i]
    }
    return result
}

860. Lemonade Change

A greedy solution will be if we have ^{10, we provide}10 to customers who pay with $20.

func lemonadeChange(bills []int) bool {
    five := 0
    ten := 0
    for i := 0; i < len(bills); i++ {
        switch bills[i] {
        case 5:
            five++
        case 10:
            ten++
            if five >= 1 {
                five --
            } else {
                return false
            }
        case 20:
            if ten == 0 {
                if five < 3 {
                    return false
                }
                five -= 3
            } else if ten > 0 {
                ten--
                if five == 0 {
                    return false
                }
                five--
            }   
        }
    }
    return true
}

406. Queue Reconstruction by Height

Since there are to demensions, and the demension k depends on h, the idea is we sort the given slice by h as the primary order, k as the secondary order. After that, we use the insert sorting algorithm to insert all slice items one by one based on the k value to a new slice.

func reconstructQueue(people [][]int) [][]int {
    result := [][]int{}
    sort.Slice(people, func(a, b int) bool { // order by h desc, order by k asc
        if people[a][0] == people[b][0] {
            return people[a][1] < people[b][1]
        }
        return people[a][0] > people[b][0]
    })
    for _, p := range people {
        result = append(result, p)
        copy(result[p[1] + 1:], result[p[1]:])
        result[p[1]] = p
    }
    return result
}

452. Minimum Number of Arrows to Burst Balloons

A greedy solution is we choose the shoot point which is the most line segments overlaped as a local optimal, it also leads to a global optimal solution. For example, we have four segments as below. If we sort them by the start point, we can easily get a first point should be between e ~ b. It means we iterate all segments, if the current segment’s start point is no great than the previous one’s end point, we can merge those two by reseting the current one’s end point to the minimum number between itself and the previous one’s end point.

|--------------|
a              b
    |-----------------|
    c                 d
       |---------|
       e         f
                   |---------|
                   g         h

func findMinArrowShots(points [][]int) int {
    sort.Slice(points, func(a, b int) bool {
        return points[a][0] < points[b][0]
    })
    result := 1
    for i := 1; i < len(points); i++ {
        if points[i][0] > points[i - 1][1] {
            result++
        } else if points[i][1] > points[i - 1][1] {
            points[i][1] = points[i - 1][1]
        }
    }
    return result

}

435. Non-overlapping Intervals

This one is a similar problem as #452. An intuition to solve this kind of problem is sort if first. Since all line segments have two points, we have two choices to sort it. The local optimal to find the interval is the end of current segment should have a distance between the next one’s start point. With this in mind, we can quickly get the total of intervals. So if we sort by the end point, we can iterate from left to right. Otherwise, we need to reverse the iteration order.

func eraseOverlapIntervals(intervals [][]int) int {
    sort.Slice(intervals, func(a, b int) bool {
        return intervals[a][1] < intervals[b][1]
    })
    end := intervals[0][1]
    count := 1
    for i := 1; i < len(intervals); i++ {
        if end <= intervals[i][0] {
            count++
            end = intervals[i][1]
        }
    }
    return len(intervals) - count
}

JumpGame Problems

2021-10-04T05:05:24.000Z

55. Jump Game

a. Greedy solutions

At each step, a greedy jump can give us the local optimal furthest solution. Our global solution can be found in if we always take the greedy jump.

func canJump(nums []int) bool {
    distance := 0
    length := len(nums)
    for i := 0; i <= distance; i++ { // Note: here we use distance to control which items we can check
        if distance < i + nums[i] {
            distance = i + nums[i]
        }
        if distance >= length - 1 {
            return true
        }
    }
    return false
}

b. Dynamic programming

func canJump(nums []int) bool {
    length := len(nums)
    dp := make([]int, length)
    dp[0] = true
    for i := 0; i < length; i++ {
        if dp[i] {
            for j := 1; j <= nums[i] && i + j < length; j++ {
                dp[i + j] = true
            }
        }
    }
    return dp[length - 1]
}

45. Jump Game II

a. Greedy solution

Each time, we will jump to a position which can make us future jumping even further. And each jump will resolve to a coverage range as below, so the total jump steps will be the sum of times we reach to the edge of the coverge range.

| 2 | 3 | 1 | 1 | 4 | 5 | 1 | 2 |

|---------->|
    |-------------->|

                |-------------->|

func jump(nums []int) int {
    result := 0
    length := len(nums)
    end := 0
    max := 0
    for i := 0; i < length - 1; i++{
        if max < nums[i] + i {  // Get the next coverage edge
            max = nums[i] + i
        }
        if i == end {           // Switch to the next range with a jump
            end = max
            result++
        }
    }
    return result
}

b. Dynamic programming

func jump(nums []int) int {
    dp := make([]int, len(nums))
    dp[0] = 0
    for i := 1; i < len(nums); i++ {
        dp[i] = -1
    } 
    for i := 0; i < len(nums); i ++ {
        for j := 1; j <= nums[i] && i + j < len(nums); j++ {
            if dp[i + j] == -1 {
                dp[i + j] = dp[i] + 1   
            } else if dp[i + j] > dp[i] + 1 {
                dp[i + j] = dp[i] + 1
            }
        }
    }
    return dp[len(nums) - 1]
}

1306. Jump Game III

The keypoint here is during the traversal of the recursive, we don’t get lost in a infinite loop. So we need to remember all of the visted nodes in a hash.

a. Recursive solution

func canReach(arr []int, start int) bool {
    result := false
    reachedNodes := make(map[int]bool)
    var jump func(int)
    jump = func(index int) {
        if arr[index] == 0 {
            result = true
            return
        }
        if reachedNodes[index] {
            return
        }
        reachedNodes[index] = true
        if index - arr[index] >= 0 {
            jump(index - arr[index])
        }
        if index + arr[index] < len(arr) {
            jump(index + arr[index])
        }
    }
    jump(start)
    return result
}

b. Queue traversal solution.

func canReach(arr []int, start int) bool {
    reachedNodes := make(map[int]bool)
    queue := []int{start}
    length := len(arr)
    for len(queue) > 0 {
        index := queue[0]
        if arr[index] == 0 {
            return true
        }
        reachedNodes[index] = true
        queue = queue[1:]
        if index + arr[index] < length && !reachedNodes[index + arr[index]] {
            queue = append(queue, index + arr[index])
        }
        if index - arr[index] < length && !reachedNodes[index - arr[index]] {
            queue = append(queue, index - arr[index])
        }
    }
    return false
}

1345. Jump Game IV

This is a classical tree traversal with BFS problem. From each array index we can jump to multiple elements simoteniously, those nextstep elements can be consiered as the tree node’s child nodes. So we jump to all nodes’s children nodes at once which can be considered as one jump (BFS). Since the same value of the nodes can jump to each other, we have to mark the nodes values which have been pushed to the queue to make sure we don’t push the same nodes back to the queue (even we have a visited flag, we can easily run out of memory without another same number flag under this edge case if we have 1000 same value nodes in the slice).

func minJumps(arr []int) int {
    length := len(arr)
    if length < 3 {
        return length - 1
    }
    jumpIndexes := make(map[int][]int)
    for i, v := range arr {
        jumpIndexes[v] = append(jumpIndexes[v], i)
    }
    queue := make([]int, 1)
    queue[0] = 0
    result := 0
    visited := make([]bool, length)
    sameNumberVisited := make(map[int]bool) // Have a flag is one thing, another solution is to remove the sameNumber key from the jumpIndexes hashmap.
    n := len(queue)
    for n > 0 {
        for i := 0; i < n; i++ {
            index := queue[i]
            if index == length - 1 {
                return result
            }
            if !visited[index] {
                visited[index] = true
                if index - 1 >= 0 && !visited[index - 1]{
                    queue = append(queue, index - 1)
                }
                if index + 1 < length && !visited[index + 1] {
                    queue = append(queue, index + 1)
                }
                if !sameNumberVisited[arr[index]] {
                    sameNumberVisited[arr[index]] = true
                    for _, v := range jumpIndexes[arr[index]] {
                        if !visited[v] {
                            queue = append(queue, v)
                        }
                    }
                }
            }
        }
        queue = queue[n:]
        n = len(queue)
        result++
    }
    return result
}

1340. Jump Game V

To resolve this problem, we need to understand you can only jump from index i to index j if arr[i] > arr[j] and arr[i] > arr[k] for all indices k between i and j (More formally min(i, j) < k < max(i, j)).. Let’s say we stand at index i, and jumping from i - 1, i + 1 until i - d, i + d inside of for loops. We need to break the loop if we find a k between [i-d, i) or (i, i + d] which makes arr[k] >= arr[i].

func maxJumps(arr []int, d int) int {
    result := 0
    length := len(arr)
    dp := make([]int, length)
    max := func(a, b int) int {
        if a > b {
            return a
        }
        return b
    }
    min := func(a, b int) int {
        if a > b {
            return b
        }
        return a
    }
    var jump func(int) int
    jump = func(index int) int {
        if dp[index] == 0 {
            dp[index] = 1
            for i := index - 1; i >= max(0, index - d) && arr[i] < arr[index]; i-- {
                dp[index] = max(dp[index], jump(i) + 1)
            }
            for i := index + 1; i <= min(length - 1, index + d) && arr[i] < arr[index]; i++ {
                dp[index] = max(dp[index], jump(i) + 1)
            }
        }
        return dp[index]
    }
    for i := 0; i < length; i++ {
        dp[i] = jump(i)
        result = max(dp[i], result)
    }
    return result
}

1696. Jump Game VI

A naive idea is to iterate over all nodes, so the worse time complexity could be O(n * k) [K = maxJump - minJump] which most likely will cause a TLE issue. This one can be considered as a classic sliding window maximum problem. Since dp[i] = nums[i] + max(dp[i - k], … , dp[i - 1]). We just need to maintain the maximum dp value in the sliding window during the iteration.

01010101010101011111

|---------(i)------|
    |----->|
    i-k    i-1
|----------(i + 1)------|
     |----->|
     i-k+1  i

func maxResult(nums []int, k int) int {
    length := len(nums)
    queue := []int{0}      // stores the dp indexes of the sliding window items
    dp := make([]int, length)
    dp[0] = nums[0]
    for i := 1; i < length; i++ {
        maxSumIndex := queue[0]
        dp[i] = nums[i] + dp[maxSumIndex]
        for len(queue) > 0 && dp[queue[len(queue) - 1]] <= dp[i] { // sliding window queue contains all values in a desending order
            queue = queue[:len(queue) - 1]
        }
        for len(queue) > 0 && i - queue[0] >= k {  // remove the index which is going to out of the window
            queue = queue[1:]
        }
        queue = append(queue, dp[i])
    }
    return dp[length - 1]
}

1871. Jump Game VII

Same as the above one, a naive dp will get a TLE. A keypoint to solve this problem is we need to avoid the duplicated node visiting. One way is we can use a hashmap to note all visited elements. Another method is that we can bypass the overlap like below:

01010101010101011111
  |--------->|
  1          2
    |--------->|
    3          4

The first jump range is 1 ~ 2, the second is 3 ~ 4, here the range 3 ~ 2 doesn’t need to be visited again. With this in mind, we can use tree-like traversal solution with queue or two pointers sliding window to fix this issue.

a. Queue with traversal solution

func canReach(s string, minJump int, maxJump int) bool {
    queue := []int{0}
    length := len(s)
    visited := make(map[int]bool)
    visited[0] = true
    edge := 0
    min := func(a, b int) int {
        if a > b {
            return b
        }
        return a
    }
    max := func(a, b int) int {
        if a > b {
            return a
        }
        return b
    }
    for len(queue) > 0 {
        index := queue[0]
        if index == length - 1 {
            return true
        }
        queue = queue[1:]
        left := index + minJump
        right := min(length - 1, index + maxJump)
        for i := max(edge + 1, left); i <= right; i++ {
            if s[i] == '0' && !visited[i]{
                visited[i] = true
                queue = append(queue, i)
            }
        }
        edge = right
    }
    return false
}

b. Two pointers

func canReach(s string, minJump int, maxJump int) bool {
    length := len(s)
    if s[length - 1] == '0' {
        min := func(a, b int) int {
            if a > b {
                return b
            }
            return a
        }
        max := func(a, b int) int {
            if a > b {
                return a
            }
            return b
        }
        canVisit := make(map[int]bool)
        canVisit[0] = true
        edge := 0
        for i := 0; i <= edge && i < length; i++ {
            if canVisit[i] {
                left := i + minJump
                right := min(length - 1, i + maxJump)
                for j := max(left, edge + 1); j <= right; j++ {
                    if s[j] == '0' {
                        canVisit[j] = true
                        if j == length - 1 {
                            return true
                        }
                    }
                }
                edge = right
            }
        }
    }
    return false
}