From 6e2610c882e3266740a4519768a6c62693d0df3f Mon Sep 17 00:00:00 2001
From: li-chx <lchx751176501@gmail.com>
Date: Fri, 26 Sep 2025 16:51:23 +0800
Subject: [PATCH] =?UTF-8?q?611.=20=E6=9C=89=E6=95=88=E4=B8=89=E8=A7=92?=
 =?UTF-8?q?=E5=BD=A2=E7=9A=84=E4=B8=AA=E6=95=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main.rs | 150 +++++++---------------------------------------------
 1 file changed, 18 insertions(+), 132 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index caff5d8..458dfb5 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,143 +1,29 @@
-use std::cmp::max;
-use std::collections::{HashMap, HashSet};
-
 mod arr;
+struct Solution {}
 
-#[derive(Hash, Eq, PartialEq, Clone)]
-struct Node {
-    source: i32,
-    destination: i32,
-    timestamp: i32
-}
-struct MpNode {
-    nodes: Vec<i32>,
-    start: usize
-}
-struct Router {
-    set : HashSet<Node>,
-    arr : Vec<Node>,
-    start: usize,
-    limit: i32,
-    mp : HashMap<i32, MpNode>
-}
-
-
-/**
- * `&self` means the method takes an immutable reference.
- * If you need a mutable reference, change it to `&mut self` instead.
- */
-// source 开始 destination 结束 timestamp 时间戳
-// memoryLimit 内存限制
-impl Router {
-
-    fn new(memory_limit: i32) -> Self {
-        let router = Router {
-            set: HashSet::new(),
-            arr: vec![],
-            start: 0,
-            limit: memory_limit,
-            mp: HashMap::new()
-        };
-        router
-    }
-
-    fn add_packet(&mut self, source: i32, destination: i32, timestamp: i32) -> bool {
-        let node = Node {
-            source,
-            destination,
-            timestamp
-        };
-        if self.set.contains(&node) {
-            false
-        } else {
-            self.set.insert(node.clone());
-            self.arr.push(node.clone());
-            if let Some(mp_node) = self.mp.get_mut(&destination) {
-                mp_node.nodes.push(timestamp);
-            }else {
-                let mp_node = MpNode {
-                    nodes: vec![timestamp],
-                    start: 0
-                };
-                self.mp.insert(destination, mp_node);
-            }
-            if self.arr.len() - self.start > self.limit as usize {
-                let remove_node = &self.arr[self.start];
-                self.set.remove(remove_node);
-                let destination = remove_node.destination;
-                self.start += 1;
-                if let Some(mp_node) = self.mp.get_mut(&destination) {
-                    mp_node.start += 1;
-                }else {
-                    print!("error occur {source} {destination} {timestamp}");
+impl Solution {
+    pub fn triangle_number(nums: Vec<i32>) -> i32 {
+        if nums.len() < 3 {
+            return 0;
+        }
+        let mut nums = nums;
+        nums.sort();
+        let mut ans = 0;
+        for i in 0..nums.len() - 2 {
+            let mut r = i + 2;
+            for l in i + 1..nums.len() - 1 {
+                while r < nums.len() && nums[i] + nums[l] > nums[r] {
+                    r += 1;
                 }
-            }
-            true
-        }
-    }
 
-    fn forward_packet(&mut self) -> Vec<i32> {
-        if self.arr.len() == self.start {
-            return vec![];
-        }
-        let mut ans = vec![];
-        let node = &self.arr[self.start];
-        ans.push(node.source);
-        ans.push(node.destination);
-        ans.push(node.timestamp);
-        self.set.remove(&self.arr[self.start]);
-        self.start += 1;
-        if let Some(node_mp) = self.mp.get_mut(&node.destination) {
-            node_mp.start += 1;
+                ans += ((r - l) as i32 - 1).max(0);
+            }
         }
         ans
     }
-
-    fn get_count(&self, destination: i32, start_time: i32, end_time: i32) -> i32 {
-        let mut mp_node = match self.mp.get(&destination) {
-            Some(v) => v,
-            None => return 0
-        };
-        let mut l: i32 = 0;
-        let mut r: i32 = 0;
-        match mp_node.nodes.binary_search(&(start_time - 1)) {
-            Ok(mut v) => {
-                while v < mp_node.nodes.len() && mp_node.nodes[v] == start_time - 1 {
-                    v+=1;
-                }
-                l = v as i32;
-            }
-            Err(v) => l = v as i32
-        }
-        match mp_node.nodes.binary_search(&(end_time+1)) {
-            Ok(v) => {
-                let mut v = v as i32;
-                while v >= 0 && mp_node.nodes[v as usize] == end_time + 1 {
-                    v-=1;
-                }
-                r = v + 1;
-            }
-            Err(v) => r = v as i32
-        }
-        l = max(l , mp_node.start as i32);
-        max(r - l, 0)
-    }
 }
 
 fn main() {
-    let data =  vec![vec![4], vec![2,3,1], vec![5,3,2],vec![3,1,1],vec![3,1,1],vec![2,4,2],vec![4,3,2],vec![]];
-    let methods = vec!["Router","addPacket","addPacket","getCount","getCount","addPacket","addPacket","forwardPacket"];
-    let mut obj = Router::new(data[0][0]);
-    for i in 1..methods.len() {
-        if methods[i] == "addPacket" {
-            let ret: bool = obj.add_packet(data[i][0], data[i][1], data[i][2]);
-            println!("{:?}", ret);
-        } else if methods[i] == "forwardPacket" {
-            let ret: Vec<i32> = obj.forward_packet();
-            println!("{:?}", ret);
-        } else if methods[i] == "getCount" {
-            let ret: i32 = obj.get_count(data[i][0], data[i][1], data[i][2]);
-            println!("{:?}", ret);
-        }
-    }
+    let arr = vec![7, 0, 0, 0];
+    println!("{}", Solution::triangle_number(arr));
 }