add 975

Author: luliyucoordinate

src/0975-Odd-Even-Jump/0975.cpp

@@ -0,0 +1,43 @@
+class Solution 
+{
+public:
+    int oddEvenJumps(vector<int>& A) 
+    {
+        int n = A.size();
+        vector<int> d(n);
+        for (int i = 0; i < n; i++) d[i] = i;
+        stable_sort(d.begin(), d.end(), [&](const int i, const int j){
+            return A[i] < A[j];
+        });
+        vector<int> n1 = st(d);
+        stable_sort(d.begin(), d.end(), [&](const int i, const int j){
+            return A[i] > A[j];
+        });
+        vector<int> n2 = st(d);
+        
+        vector<int> h(n), l(n);
+        h[n-1] = l[n-1] = 1;
+        for (int i = n - 2; i >= 0; i--)
+        {
+            h[i] = l[n1[i]];
+            l[i] = h[n2[i]];
+        }
+        return accumulate(h.begin(), h.end(), 0);
+    }
+private:
+    vector<int> st(vector<int>& data)
+    {
+        int n = data.size();
+        vector<int> s, res(n);
+        for (int i : data)
+        {
+            while (!s.empty() and s.back() < i)
+            {
+                res[s.back()] = i;
+                s.pop_back();
+            }
+            s.push_back(i);
+        }
+        return res;
+    }
+};

src/0975-Odd-Even-Jump/0975.go

@@ -0,0 +1,44 @@
+func oddEvenJumps(A []int) int {
+    n := len(A)
+    d := make([]int, n)
+    for i := 0; i < n; i++ {
+        d[i] = i
+    }
+    sort.SliceStable(d, func(i, j int) bool {
+        return A[d[i]] < A[d[j]]
+    })
+    n1 := st(d)
+    sort.SliceStable(d, func(i, j int) bool {
+        return A[d[i]] > A[d[j]]
+    })
+    n2 := st(d)
+    
+    h := make([]int, n)
+    l := make([]int, n)
+    h[n - 1], l[n - 1] = 1, 1
+    for i := n - 2; i >= 0; i-- {
+        h[i] = l[n1[i]]
+        l[i] = h[n2[i]]
+    }
+    res := 0
+    for i := 0; i < n; i++ {
+        if h[i] > 0 {
+            res++
+        }
+    }
+    return res
+}
+
+func st(data []int) []int {
+    n := len(data)
+    s := make([]int, 0)
+    res := make([]int, n)
+    for _, i := range data {
+        for len(s) > 0 && s[len(s) - 1] < i {
+            res[s[len(s) - 1]] = i
+            s = s[:len(s) - 1]
+        }
+        s = append(s, i)
+    }
+    return res
+}

src/0975-Odd-Even-Jump/0975.js

@@ -0,0 +1,39 @@
+var oddEvenJumps = function(A) {
+    let n = A.length, d = new Array(n);
+    for (let i = 0; i < n; i++) d[i] = i;
+    
+    let st = function(data) {
+        let s = [], res = new Array(n);
+        res.fill(0);
+        for (let i of data) {
+            while (s.length && s[s.length - 1] < i) {
+                res[s.pop()] = i;
+            }
+            s.push(i);
+        }
+        return res;
+    }
+    d.sort(function(i, j) {
+        if(A[i] == A[j]) return i - j;
+        else return A[i] - A[j];
+    });
+    let n1 = st(d);
+    d.sort(function(i, j) {
+        if(A[i] == A[j]) return i - j;
+        else return A[j] - A[i];
+    });
+    let n2 = st(d);
+    
+    let h = new Array(n), l = new Array(n);
+    h.fill(0); l.fill(0);
+    h[n - 1] = l[n - 1] = 1;
+    for (let i = n - 2; i >= 0; i--) {
+        h[i] = l[n1[i]]
+        l[i] = h[n2[i]]
+    }
+    let res = 0;
+    for (let i of h) {
+        if (i) res++;
+    }
+    return res;
+};

src/0975-Odd-Even-Jump/0975.py

@@ -0,0 +1,19 @@
+class Solution:
+    def oddEvenJumps(self, A: List[int]) -> int:
+        n = len(A)
+        def st(data):
+            s, res = [], [0]*n
+            for i in data:
+                while s and s[-1] < i:
+                    res[s.pop()] = i
+                s.append(i)
+            return res
+        
+        d = sorted(range(n), key=lambda i: A[i])
+        n1, n2 = st(d), st(sorted(d, key=lambda i: -A[i]))
+        h, l = [0] * n, [0] * n
+        h[-1] = l[-1] = 1
+        for i in range(n - 2, -1, -1):
+            h[i] = l[n1[i]]
+            l[i] = h[n2[i]]
+        return sum(h)