Rust works!

pub fn brace(exp: String) -> Vec<String> {
        let mut group : Vec<Vec<Vec<String>>> = Vec::new();
        group.push(Vec::new());
        let mut res = Vec::new();
        let mut level = 0;
        let mut start = 0;
        for (i,c) in exp.chars().enumerate() {
            if c=='{' {
                if level == 0 {
                   start = i+1;
                }
                level = level + 1;
            } else if c=='}' {
                level = level -1;
                if level == 0 {
                    let last = group.len()-1;
                    group[last].push(Solution::brace(exp[start..i].to_string()));
                }
            } else if level == 0 && c == ',' {
                let last = group.len()-1;
                group.push(Vec::new());
            } else if level == 0 {
                let last = group.len()-1;
                let mut v = String::new();
                let mut vv = Vec::new();
                v.push(c);
                vv.push(v);
                group[last].push(vv);
            }
        }
        let mut result_set = HashSet::new();
        for item in group {  //item is vec<vec<string>>> 
            let mut cur = item[0].clone();
            let mut prev = item[0].clone();
            for thing in item[1..].iter() {
               cur = Vec::new(); 
               for p in prev {
                   for q in thing {
                        let r = p.clone()+&q.clone();
                        cur.push(r);
                   }
               }
               prev = cur;
            }
            for ss in prev {
                result_set.insert(ss);
            }
        }
        for ele in result_set {
            res.push(ele);
        }
        res.sort();
	res
}

pub fn car_pooling(trips: Vec<Vec<i32>>, capacity: i32) -> bool {
        #[derive(Debug)]
        struct loc {
            location: i32,
            np: i32,
            pick: i32,
        }
        let mut data = Vec::new();
        for pass in trips {
            data.push(loc{location: pass[1],np: pass[0],pick: 1});
            data.push(loc{location: pass[2],np: pass[0],pick: 0});
        }
        data.sort_by(|a,b| a.location.cmp(&b.location));
        let mut np = 0;
        let mut prev = -1;
        for item in &data {
            if item.location != prev {
                prev = item.location;
                if np > capacity {
                    return false;
                }
            }
            if item.pick == 1 {
                np += item.np;
            } else {
                np -= item.np;
            }
        }
        true
    }

pub fn num_is_islands(grid: Vec<Vec<char>>) -> i32 {
        let mut visited = grid.clone();
        let mut res = 0;
        let height = grid.len();
        let width = grid[0].len();
        for row in &mut visited {
            for c in row {
                *c = 0 as char;
            } 
        }

        fn dfs(grid: &Vec<Vec<char>>, visited: &mut Vec<Vec<char>>, i: usize, j: usize, height: usize, width: usize) {
            visited[i][j] = 1 as char;
            if i>0 && visited[i-1][j] == 0 as char && grid[i-1][j] == '1' { dfs(grid,visited,i-1,j,height,width); }
            if j>0 && visited[i][j-1] == 0 as char && grid[i][j-1] == '1' { dfs(grid,visited,i,j-1,height,width); }
            if i<height-1 && visited[i+1][j] == 0 as char && grid[i+1][j] == '1' { dfs(grid,visited,i+1,j,height,width); }
            if j<width-1 && visited[i][j+1] == 0 as char && grid[i][j+1] == '1' { dfs(grid,visited,i,j+1,height,width); }
        }

        for (i,row) in grid.iter().enumerate() {
            for (j,c) in row.iter().enumerate() {
                if *c == '1' && visited[i][j] == 0 as char {
                    res += 1;
                    dfs(&grid,&mut visited,i,j, height, width);
                }
            }
        }
    
        res
    }

pub fn num_is_islands_improved(grid: Vec<Vec<char>>) -> i32 {
        let mut visited = grid.clone();
        let mut res = 0;
        if grid.len() == 0 || grid[0].len() == 0 {return 0 as i32;}
        let height = grid.len();
        let width = grid[0].len();

        fn dfs(grid: &Vec<Vec<char>>, visited: &mut Vec<Vec<char>>, i: usize, j: usize, height: usize, width: usize) -> i32{
            if (i<0 || i == height || j<0 || j == width || visited[i][j] == '0') {
                return 0 as i32;
            }
            visited[i][j] = '0';
            dfs(grid,visited,i-1,j,height,width);
            dfs(grid,visited,i,j-1,height,width);
            dfs(grid,visited,i+1,j,height,width);
            dfs(grid,visited,i,j+1,height,width);
            return 1 as i32;
        }

        for (i,row) in grid.iter().enumerate() {
            for (j,c) in row.iter().enumerate() {
                    res += dfs(&grid,&mut visited,i,j, height, width);
            }
        }
        res
    }

pub fn max_area_of_island(grid: Vec<Vec<i32>>) -> i32 {
        let mut visited = grid.clone();
        let mut res = 0;
        if grid.len() == 0 || grid[0].len() == 0 {return 0 as i32;}
        let height = grid.len();
        let width = grid[0].len();

        fn dfs(visited: &mut Vec<Vec<i32>>, i: i32, j: i32, height: i32, width: i32) -> i32{
            if (i<0 || i == height || j<0 || j == width || visited[i as usize][j as usize] == 0) {
                return 0 as i32;
            }
            visited[i as usize][j as usize] = 0;
            let mut res = 1;
            res += dfs(visited,i-1,j,height,width);
            res += dfs(visited,i,j-1,height,width);
            res += dfs(visited,i+1,j,height,width);
            res += dfs(visited,i,j+1,height,width);
            res
        }

        for (i,row) in grid.iter().enumerate() {
            for (j,c) in row.iter().enumerate() {
                    let t = dfs(&mut visited,i as i32,j as i32, height as i32, width as i32);
		    if (t>res) {res=t;}
            }
        }
        res
    }