LeetCode第一天

今天是第一天在LeetCode上进行刷题，发现这里的题目很基础。并且其提供了在线的编译器，可以直接写代码和测试用例并进行调试，很方便。做了几道难度系数为Easy的题，总结如下：

一、1. Two Sum

题目要求是给定一组数和一个目标数，返回这组数中加和为目标数的那两个数在这组数中的索引。

我的解法是用一个双层的循环，让第一个数与其他的数依次进行加和运算，判断和是否为目标数，如果是则循环结束，返回索引值；否则再让第二个数与其他的数（不包括第一个数，因为前一层循环已经计算过了）依次进行加和运算...。一直这样做直到找到索引为止。用C++进行实现后，发现时间为二百多毫秒，很慢。代码如下：

class Solution {public:    vector<int> twoSum(vector<int>& nums, int target) {        vector<int> result ;        for(int i=0; i<nums.size(); ++i) {            for(int j=i+1; j<nums.size(); ++j) {                if((nums[i] + nums[j]) == target) {                    result.push_back(i) ;                    result.push_back(j) ;                    break ;                }            }        }        return result ;    }};

leetcode上这道题的两种优秀解法如下：

解法一：利用C++中的map集合类型，它是一个<key,value>集合。首先将这组数的值(key)和索引位置(vlaue)添加到map当中。然后遍历map，在其中查找（目标数-当前数），如果找到了，则直接取出该（目标数-当前数）所对应的value（即其索引位置），然后返回当前数的索引和取出的value。在这种解法下，通过使用map，加快了程序的速度。

解法二：解法二是对解法一的进一步改进。首先遍历这组数，直接map中进行查找（目标数-当前数），如果找到则返回然后返回当前数的索引和取出的value；否则将当前数添加到map中。此时只需要一层循环即可完成程序所需功能。进一步提高了程序的运行效率。

二、7. Reverse Integer

题目要求是给定一个整型数，逆序输出该整型数。同时假定该整型数是32位的，逆序后如果数溢出了，输出值为0。

我的解法是对负数进行了处理，将其转换为整数后再逆序输出。同时32位整型的范围是-2^31~2^31（不包括2^31），对于溢出的判断，使用了double。代码如下：

class Solution {public:    int reverse(int x) {        double r = 0;        int flag = 0 ;        int i=0 ;        if(x < 0) {            x = -x ;            flag = 1 ;        }        if(flag == 1 && x<0) {            return 0 ;        }        while(x!=0) {            r = r*10 + (x%10) ;            x = x/10 ;        }        return (r > pow(2,31)) ? 0 : (flag==1) ?  (int)-r : (int)r ;    }};

后来参考了优秀的解法，发现可以使用long long并且对于负数不用做特殊的处理，相比之前的程序，这样做代码变短了，时间也加快了。代码如下：

class Solution {public:    int reverse(int x) {        long long r = 0 ;        while(x!=0) {            r = r*10 + (x%10) ;            x = x/10 ;        }        return (r > pow(2,31) || r < -pow(2,31)) ? 0 : r ;    }};

leetcode上这道题的优秀解法是：

由于每次进行逆序变换时都要进行对10的整除和取模运算，因此在每一次计算得到逆序值之后，判断该逆序值对10整除的结果与上一次循环得到的逆序值是否相同，如果不相同则发生了溢出，否则最后可以得到逆序结果。这种解法不用进行特意溢出的判断，利用在逆序计算过程中中间值之间的关系来间接判断数据是否溢出，很巧妙。

三、9. Palindrome Number

题目要求是判断一个整型数是否为回文字符串，不能使用额外的空间。

我的解法是先计算出该整型数的首尾数字，如果相等，则计算出这个数去掉首尾数字得到的整型数，再次判断该整型数的首尾是否相等，依次类推...；如果不相等则说明该整型不是回文字符串。在循环过程中有一个计数的变量，如果这个变量最后的值为0（整型数是奇数位）或-1（整型数是偶数位），则说明该整型数是回文数，否则如果最后的数变为了0，则该整型数是回文数，否则不是回文数，这一判断是对类似100001这样的数进行的。代码如下：

class Solution {public:    bool isPalindrome(int x) {        if(x<0) {            return false ;        }        // 判断x由几位数字        int len = 0;        int k = x ;        while(k) {            k = k/10 ;            ++ len ;        }        int j = len-1 ;        while(x/10 != 0) {            if((x%10) != (x/mi(j))) {                return false ;            }            x = x/10 - (x%10)*mi(j-1) ;            j = j-2 ;        }        return (j==0 || j==-1) ? true : (x==0) ? true : false ;    }    int mi(int k) {        int res = 1 ;        for(int i=1; i<=k; ++i) {            res = res * 10 ;        }        return res ;    }};

leetcode上的优秀解法是：将这个数逆序输出，如果逆序之后的数与原来的数相同或者逆序之后的数整除10得到的数与原来的数相同（针对100001这样的数），则这个数是回文数，否则不是回文数。

四、13. Roman to Integer

题目要求是将罗马数装换为整型数。

罗马数到整型的转换规则为：

'I' = 1 ; 'V' = 5 ; 'X' = 10 ; 'L' = 50 ; 'C' = 100 ; 'D' = 500 ; 'M' = 1000 ;

在进行计算时从右向左计算，如果小数（I，C，X）在大数左面，则用该大数减去小数；其余情况进行加法运算。

我的解法是按照上面的规则从右向左依次进行计算，代码参考了网上的代码。

class Solution {public:    int romanToInt(string s) {        if(s.length() == 0) return 0 ;                map<char,int> m ;        m['I'] = 1 ;        m['V'] = 5 ;        m['X'] = 10 ;        m['L'] = 50 ;        m['C'] = 100 ;        m['D'] = 500 ;        m['M'] = 1000 ;                int sum = m[s[s.length()-1]] ;        for(int i=s.length()-1; i>=0; --i) {            if(m[s[i-1]] >= m[s[i]]) {                sum += m[s[i-1]] ;            } else {                sum -= m[s[i-1]] ;            }        }        return sum ;    }};

五、14. Longest Common Prefix

题目要求是求出一组字符串中的最长公共子串。

我的解法是取出第一个字符串，依次判断其每一个字母是否在其他字符串的对应位置，如果不是则循环结束；否则一直进行下去直到达到循环终止条件。代码如下：

class Solution {public:    string longestCommonPrefix(vector<string>& strs) {        if(strs.size() == 0)            return "" ;        string pre = "";        int f = 0 ;        for(int k=0; k<strs[0].length(); ++k) {            //cout << strs[0][k] << endl ;            for(int j=1; j<strs.size(); ++j) {                //cout << strs[j][k] << endl ;                if(strs[0][k] != strs[j][k]) {                    f = 1 ;                    break ;                }             }            if(f == 1)                 break ;            pre += strs[0][k] ;        }        return pre ;        }};

六、20. Valid Parentheses

题目要求相当于是判断给定括号() {} []序列，判断括号是否匹配。

我的解法是使用栈结构进行判断，栈是一种先进后出的结构，很适合该题的形式。代码如下：

class Solution {public:    bool isValid(string s) {                if(s.length()%2 !=0)            return false ;                    char c[s.length()] ;        int top = 0 ;        int flag = 0 ;        for(int i=0; i<s.length(); ++i) {            if(s[i]!=')' && s[i]!='}' && s[i]!=']') {                c[top] = s[i];                ++ top ;            } else {                if(top > 0) {                    switch(s[i]) {                        case ')' :                             if(c[top-1]!='(')                                return false ;                            else                                --top ;                            break ;                        case '}' :                             if(c[top-1]!='{')                                return false ;                            else                                --top ;                            break ;                        case ']' :                             if(c[top-1]!='[')                                return false ;                            else                                --top ;                            break ;                    }                } else {                    return false ;                }                            }        }                if(top == 0)            return true ;        else             return false ;    }};

leetcode上的优秀解法使用了C++中的stack来进行操作。

做了这些题之后，对比自己的解法与优秀的解法，找到了自己的不足的同时也拓宽了思路。