From a2f7ac206ae196a92077c7e6756b6655ed324bfd Mon Sep 17 00:00:00 2001
From: li-chx <li_chx@qq.com>
Date: Tue, 29 Sep 2026 15:09:06 +0800
Subject: [PATCH] =?UTF-8?q?2267.=20=E6=A3=80=E6=9F=A5=E6=98=AF=E5=90=A6?=
 =?UTF-8?q?=E6=9C=89=E5=90=88=E6=B3=95=E6=8B=AC=E5=8F=B7=E5=AD=97=E7=AC=A6?=
 =?UTF-8?q?=E4=B8=B2=E8=B7=AF=E5=BE=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main.rs | 83 ++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 53 insertions(+), 30 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index d1bb881..01ec1bd 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,43 +1,66 @@
-use std::cell::RefCell;
+use crate::arr::make_char_matrix;
+use std::collections::HashSet;
 
 mod arr;
 mod list;
 
 struct Solution {}
 impl Solution {
-    pub fn number_of_sets(n: i32, k: i32) -> i32 {
-        let mut mem = vec![vec![vec![-1; n as usize]; n as usize]; 2];
-        let rc = RefCell::new(&mut mem);
-        Self::dfs(&rc, n as usize - 1, k as usize, false) as i32
-    }
-    pub fn dfs(rc: &RefCell<&mut Vec<Vec<Vec<i32>>>>, n: usize, k: usize, is_empty: bool) -> i64 {
-        if k == 0 || n == k {
-            return 1;
+    pub fn has_valid_path(grid: Vec<Vec<char>>) -> bool {
+        if grid[0][0] == ')'
+            || grid[grid.len() - 1][grid[0].len() - 1] == '('
+            || (grid.len() + grid[0].len()) % 2 == 0
+        {
+            return false;
         }
-        if n == 0 || n < k {
-            return 0;
+        let mut matrix = vec![vec![Option::<HashSet<i32>>::None; grid[0].len()]; grid.len()];
+        matrix[0][0] = Some(HashSet::from_iter([10000]));
+        for i in 0..=(grid.len() - 1 + grid[0].len() - 1) {
+            for j in 0..=i {
+                if grid.len() > j && grid[0].len() > i - j {
+                    if grid.len() > j + 1 {
+                        let (rsrc, rdst) = matrix.split_at_mut(j + 1);
+                        let dst = rdst[0][i - j].get_or_insert_with(HashSet::new);
+                        let src = rsrc[j][i - j].as_ref().unwrap();
+                        if grid[j + 1][i - j] == '(' {
+                            dst.extend(src.iter().map(|&x| x + 10000));
+                        } else {
+                            dst.extend(
+                                src.iter()
+                                    .filter(|&x| x / 10000 > x % 10000)
+                                    .map(|&x| x + 1),
+                            );
+                        }
+                    }
+                    if grid[0].len() > i - j + 1 {
+                        let (rsrc, rdst) = matrix[j].split_at_mut(i - j + 1);
+                        let dst = rdst[0].get_or_insert_with(HashSet::new);
+                        let src = rsrc[i - j].as_ref().unwrap();
+                        if grid[j][i - j + 1] == '(' {
+                            dst.extend(src.iter().map(|&x| x + 10000));
+                        } else {
+                            dst.extend(
+                                src.iter()
+                                    .filter(|&x| x / 10000 > x % 10000)
+                                    .map(|&x| x + 1),
+                            );
+                        }
+                    }
+                }
+            }
         }
-        let matrix_idx = if is_empty { 1 } else { 0 };
-        if rc.borrow()[matrix_idx][n][k] != -1 {
-            return rc.borrow()[matrix_idx][n][k] as i64;
-        }
-        let r#mod = 1e9 as i64 + 7;
-        let mut ans = 0;
-        if !is_empty {
-            ans += Self::dfs(rc, n - 1, k, false) + Self::dfs(rc, n - 1, k, true)
-                - Self::dfs(rc, n - 2, k, true)
-                - Self::dfs(rc, n - 2, k - 1, false);
-            ans = (ans + r#mod) % r#mod;
-        }
-
-        ans += Self::dfs(rc, n - 1, k, true) + Self::dfs(rc, n - 1, k - 1, false);
-        ans = ans % r#mod;
-        rc.borrow_mut()[matrix_idx][n][k] = ans as i32;
-        ans
+        matrix[grid.len() - 1][grid[0].len() - 1].as_ref()
+            .unwrap()
+            .iter()
+            .any(|&x| x / 10000 == x % 10000)
     }
 }
 
 fn main() {
-    println!("{:?}", Solution::number_of_sets(1000, 500));
-    //70047606
+    println!(
+        "{:?}",
+        Solution::has_valid_path(make_char_matrix(
+            r#"[["(","(","("],[")","(",")"],["(","(",")"],["(","(",")"]]"#
+        ))
+    );
 }