diff --git a/src/main.rs b/src/main.rs
index e62155f..9f6e35a 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,40 +1,39 @@
-use std::cmp::max;
+mod arr;
 struct Solution;
 impl Solution {
-    pub fn number_of_substrings(s: String) -> i32 {
-        let s = s.chars().collect::<Vec<char>>();
-        let mut ans = 0;
-        let mut zeros: Vec<usize> = Vec::new();
-
-        for i in 0..s.len() {
-            if s[i] == '0' {
-                zeros.push(i);
+    pub fn find_minimum_time(tasks: Vec<Vec<i32>>) -> i32 {
+        let mut tasks = tasks;
+        tasks.sort_by_key(|task| task[1]);
+        let mut stack:Vec<Vec<i32>> = Vec::new();
+        stack.push(vec![-2,-2,0]);
+        for task in tasks.iter() {
+            let start = task[0];
+            let end = task[1];
+            let mut d = task[2];
+            let pos = stack.partition_point(|x| x[0] < start) - 1;
+            d -= stack[stack.len() - 1][2] - stack[pos][2];
+            if start <= stack[pos][1] {
+                d -= stack[pos][1] - start + 1;
             }
-            let mut local_ans =( if zeros.len() == 0 {
-                i + 1
-            } else {
-                i - zeros[zeros.len() - 1]
-            }) as i32;
-            let mut ones = local_ans;
-            let zeros_len = zeros.len()as i32;
-            for l in (max(0, zeros_len - 200) ..zeros_len).rev() {
-                let l_index = l as usize;
-                let zeros_l_index = zeros[l_index] as i32;
-                let zero_start_index = if l == 0 { -1 } else { zeros[l_index - 1] as i32 };
-                let need_ones = max(0, (zeros_len - l) * (zeros_len - l) - ones);
-                let max_index = zeros_l_index - need_ones;
-                ones += zeros_l_index - zero_start_index - 1;
-                if max_index < zero_start_index {
-                    continue;
-                }
-                local_ans += max_index - zero_start_index;
+            if d <= 0{
+                continue;
             }
-            ans += local_ans;
+            while end - stack[stack.len() - 1][1] <= d {
+                let end = stack.pop().unwrap();
+                d += end[1] - end[0] + 1;
+            }
+            stack.push(vec![end - d + 1, end,stack[stack.len() - 1][2] + d]);
         }
-        ans
+        stack[stack.len() - 1][2]
     }
 }
+/*
+思路来自：
+只是一定程度上理解了思路 但是没有学会这个思路
+作者：灵茶山艾府
+链接：https://leetcode.cn/problems/minimum-time-to-complete-all-tasks/solutions/2163130/tan-xin-pythonjavacgo-by-endlesscheng-w3k3/
+*/
 fn main() {
-    let result = Solution::number_of_substrings("0001000011011010010011000100110100110101111111010011000101010110101000".to_string());
+    let result = Solution::find_minimum_time(arr::make_matrix("[[1,3,2],[2,5,3],[5,6,2]]"));
     println!("{:?}", result);
 }