feat: add solutions to lc problem: No.1649

No.1649.Create Sorted Array through Instructions

Author: yanglbme

solution/1600-1699/1649.Create Sorted Array through Instructions/README.md

@@ -114,34 +114,30 @@ class BinaryIndexedTree:
         self.n = n
         self.c = [0] * (n + 1)
 
-    @staticmethod
-    def lowbit(x):
-        return x & -x
-
-    def update(self, x, delta):
+    def update(self, x: int, v: int):
         while x <= self.n:
-            self.c[x] += delta
-            x += BinaryIndexedTree.lowbit(x)
+            self.c[x] += v
+            x += x & -x
 
-    def query(self, x):
+    def query(self, x: int) -> int:
         s = 0
-        while x > 0:
+        while x:
             s += self.c[x]
-            x -= BinaryIndexedTree.lowbit(x)
+            x -= x & -x
         return s
 
 
 class Solution:
     def createSortedArray(self, instructions: List[int]) -> int:
-        n = max(instructions)
-        tree = BinaryIndexedTree(n)
+        m = max(instructions)
+        tree = BinaryIndexedTree(m)
         ans = 0
-        for num in instructions:
-            a = tree.query(num - 1)
-            b = tree.query(n) - tree.query(num)
-            ans += min(a, b)
-            tree.update(num, 1)
-        return ans % int((1e9 + 7))
+        mod = 10 ** 9 + 7
+        for i, x in enumerate(instructions):
+            cost = min(tree.query(x - 1), i - tree.query(x))
+            ans += cost
+            tree.update(x, 1)
+        return ans % mod
 ```
 
 线段树：
@@ -212,50 +208,48 @@ class Solution:
 树状数组：
 
 ```java
-class Solution {
-    public int createSortedArray(int[] instructions) {
-        int n = 100010;
-        int mod = (int) 1e9 + 7;
-        BinaryIndexedTree tree = new BinaryIndexedTree(n);
-        int ans = 0;
-        for (int num : instructions) {
-            int a = tree.query(num - 1);
-            int b = tree.query(n) - tree.query(num);
-            ans += Math.min(a, b);
-            ans %= mod;
-            tree.update(num, 1);
-        }
-        return ans;
-    }
-}
-
 class BinaryIndexedTree {
     private int n;
     private int[] c;
 
     public BinaryIndexedTree(int n) {
         this.n = n;
-        c = new int[n + 1];
+        this.c = new int[n + 1];
     }
 
-    public void update(int x, int delta) {
+    public void update(int x, int v) {
         while (x <= n) {
-            c[x] += delta;
-            x += lowbit(x);
+            c[x] += v;
+            x += x & -x;
         }
     }
 
     public int query(int x) {
         int s = 0;
         while (x > 0) {
             s += c[x];
-            x -= lowbit(x);
+            x -= x & -x;
         }
         return s;
     }
+}
 
-    public static int lowbit(int x) {
-        return x & -x;
+class Solution {
+    public int createSortedArray(int[] instructions) {
+        int m = 0;
+        for (int x : instructions) {
+            m = Math.max(m, x);
+        }
+        BinaryIndexedTree tree = new BinaryIndexedTree(m);
+        int ans = 0;
+        final int mod = (int) 1e9 + 7;
+        for (int i = 0; i < instructions.length; ++i) {
+            int x = instructions[i];
+            int cost = Math.min(tree.query(x - 1), i - tree.query(x));
+            ans = (ans + cost) % mod;
+            tree.update(x, 1);
+        }
+        return ans;
     }
 }
 ```
@@ -350,47 +344,43 @@ class SegmentTree {
 ```cpp
 class BinaryIndexedTree {
 public:
-    int n;
-    vector<int> c;
-
     BinaryIndexedTree(int _n)
         : n(_n)
-        , c(_n + 1) { }
+        , c(_n + 1) {}
 
     void update(int x, int delta) {
         while (x <= n) {
             c[x] += delta;
-            x += lowbit(x);
+            x += x & -x;
         }
     }
 
     int query(int x) {
         int s = 0;
-        while (x > 0) {
+        while (x) {
             s += c[x];
-            x -= lowbit(x);
+            x -= x & -x;
         }
         return s;
     }
 
-    int lowbit(int x) {
-        return x & -x;
-    }
+private:
+    int n;
+    vector<int> c;
 };
 
 class Solution {
 public:
     int createSortedArray(vector<int>& instructions) {
-        int n = 100010;
-        int mod = 1e9 + 7;
-        BinaryIndexedTree* tree = new BinaryIndexedTree(n);
+        int m = *max_element(instructions.begin(), instructions.end());
+        BinaryIndexedTree tree(m);
+        const int mod = 1e9 + 7;
         int ans = 0;
-        for (int num : instructions) {
-            int a = tree->query(num - 1);
-            int b = tree->query(n) - tree->query(num);
-            ans += min(a, b);
-            ans %= mod;
-            tree->update(num, 1);
+        for (int i = 0; i < instructions.size(); ++i) {
+            int x = instructions[i];
+            int cost = min(tree.query(x - 1), i - tree.query(x));
+            ans = (ans + cost) % mod;
+            tree.update(x, 1);
         }
         return ans;
     }
@@ -487,38 +477,42 @@ func newBinaryIndexedTree(n int) *BinaryIndexedTree {
 	return &BinaryIndexedTree{n, c}
 }
 
-func (this *BinaryIndexedTree) lowbit(x int) int {
-	return x & -x
-}
-
 func (this *BinaryIndexedTree) update(x, delta int) {
 	for x <= this.n {
 		this.c[x] += delta
-		x += this.lowbit(x)
+		x += x & -x
 	}
 }
 
 func (this *BinaryIndexedTree) query(x int) int {
 	s := 0
 	for x > 0 {
 		s += this.c[x]
-		x -= this.lowbit(x)
+		x -= x & -x
 	}
 	return s
 }
 
-func createSortedArray(instructions []int) int {
-	n := 100010
-	mod := int(1e9 + 7)
-	tree := newBinaryIndexedTree(n)
-	ans := 0
-	for _, num := range instructions {
-		a, b := tree.query(num-1), tree.query(n)-tree.query(num)
-		ans += min(a, b)
-		ans %= mod
-		tree.update(num, 1)
+func createSortedArray(instructions []int) (ans int) {
+	m := 0
+	for _, x := range instructions {
+		m = max(m, x)
+	}
+	tree := newBinaryIndexedTree(m)
+	const mod = 1e9 + 7
+	for i, x := range instructions {
+		cost := min(tree.query(x-1), i-tree.query(x))
+		ans = (ans + cost) % mod
+		tree.update(x, 1)
+	}
+	return
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
 	}
-	return ans
+	return b
 }
 
 func min(a, b int) int {
@@ -529,6 +523,50 @@ func min(a, b int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+class BinaryIndexedTree {
+    private n: number;
+    private c: number[];
+
+    constructor(n: number) {
+        this.n = n;
+        this.c = new Array(n + 1).fill(0);
+    }
+
+    public update(x: number, v: number): void {
+        while (x <= this.n) {
+            this.c[x] += v;
+            x += x & -x;
+        }
+    }
+
+    public query(x: number): number {
+        let s = 0;
+        while (x > 0) {
+            s += this.c[x];
+            x -= x & -x;
+        }
+        return s;
+    }
+}
+
+function createSortedArray(instructions: number[]): number {
+    const m = Math.max(...instructions);
+    const tree = new BinaryIndexedTree(m);
+    let ans = 0;
+    const mod = 10 ** 9 + 7;
+    for (let i = 0; i < instructions.length; ++i) {
+        const x = instructions[i];
+        const cost = Math.min(tree.query(x - 1), i - tree.query(x));
+        ans = (ans + cost) % mod;
+        tree.update(x, 1);
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```