天天一道Rust-LeetCode(2019-06-05)

天天一道Rust-LeetCode(2019-06-05) 最長迴文子串

堅持天天一道題,刷題學習Rust.
接續昨天,最長會問字符串的另外一種解法git

題目描述

解題過程

//leetcode最快解法
    //.0:該元素座標,.1 相同數值截止座標
    fn pre_prase(s: String) -> Vec<(usize, usize)> {
        let s = s.chars().into_iter().collect::<Vec<char>>(); //iter 轉vector
        let mut result = Vec::new();
        let mut l = 0_usize;
        let mut r = 0_usize;

        loop {
            while l < s.len() && r < s.len() && s[l] == s[r] {
                r += 1;
            }

            if l > s.len() || r > s.len() {
                break;
            }

            result.push((l, r - 1));
            l = r;
            r = l + 1;
        }

        result
    }

    pub fn longest_palindrome2(s: String) -> String {
        let chars = s.chars().into_iter().collect::<Vec<char>>();
        let length = chars.len();
        //        println!("{:?}",chars);

        // 邊界值的處理很垃圾。。。
        match length {
            0 => return String::from(""),
            1 => return s,
            2 => {
                if chars[0] == chars[1] {
                    return s;
                }
            }
            _ => (), //什麼都不作
        };

        let mut cur_pos = (0_usize, 0_usize);
        let mut cur_len = 0_usize;
        let mut max_pos = (0_usize, 0_usize);
        let mut max_len = 0_usize;
        let poses = Solution::pre_prase(s.clone()).into_iter();
        println!("poses:{:?}", poses);
        for pos in poses {
            // 1 2 3 4 5 6
            //            i+=1;

            cur_pos = pos;
            cur_len = 0;

            //從左右兩邊,選一個短的,這樣也保證了後面cur.pos.1+j,cur.pos.0-j都在有效範圍以內
            let ml = if cur_pos.0 < length - cur_pos.1 - 1 {
                cur_pos.0
            } else {
                length - cur_pos.1 - 1
            };
            let mut ml = ml + 1;
            //            println!("cur_pos {:?}, mml {}",cur_pos,ml);
            //這個思路好處就是他並非以字符爲單位向左右展開,而是以字符串爲單位向左右展開,節省了重複遍歷的時間
            //至關於一種改進的從中間向兩邊擴展的情形
            for j in 0..ml {
                if chars[cur_pos.1 + j] == chars[cur_pos.0 - j] {
                    cur_len += 1;
                } else {
                    break;
                }
            }
            if 2 * cur_len + cur_pos.1 - cur_pos.0 + 1 > 2 * max_len + max_pos.1 - max_pos.0 + 1 {
                max_len = cur_len;
                max_pos = cur_pos;
            }
            //            println!("grow pos? {:?} len {}  {} > {} ",max_pos,max_len,cur_len + cur_pos.1 - cur_pos.0 + 1, max_len + max_pos.1 - max_pos.0 + 1);
        }

        //        println!("res pos {:?} len {} ",max_pos,max_len);
        let mut v = Vec::new();
        let left = max_pos.0 + 1 - max_len;
        let right = max_pos.1 + max_len - 1;
        //        println!("left {} right {}",left,right);
        for i in left..right + 1 {
            v.push(chars[i]); //有沒有辦法不用push,直接用chars的slice方式呢?
        }
        v.into_iter().collect::<String>()
    }
}

一點感悟

這個解法是copy自leetcode別人的解法,
他並不以單個字符爲單位進行擴展,而是以字符串爲單位,省去了不少重複的工做.
這個複雜度低了不少,沒有明確的證實過程,可是感受應該是在O(N)複雜度,O(NlogN)最多github

其餘

歡迎關注個人github,本項目文章全部代碼均可以找到.oop

相關文章
相關標籤/搜索