LeetCode日记2

2019独角兽企业重金招聘Python工程师标准>>>

LeetCode-5

思路：

（1）最后用子字符串操作返回string。

    return s.substr(startpos, maxlength)；

（2）回文串的判断：

1）首先找出回文串中间连续的重复的字符。

2）再向两边进行判断

（3）优化：

1）若i的位置使后面可能的回文串的最大长度不可能超出maxlength，则直接退出循环。

2）i = k + 1；//此句可防止在同一个回文串中进行多次判断。

参考：

https://leetcode.com/discuss/32204/simple-c-solution-8ms-13-lines

---

LeetCode-6

（1）string的操作。

---

LeetCode-7

（1）

to_string函数将int转换为string

reverse函数对string反转

stoll函数将string转换为long long

（2）判断溢出，溢出时返回0

if (tmp > INT_MAX || tmp < INT_MIN) return 0;

---

LeetCode-8 把string转换为int型，需要考虑string的所有可能

先得到一个string，再转换为__int64x，再转换为int。

（1）去掉前缀空格。

（2）读取符号位。

（3）去掉前缀0。

（4）读取数字，处理溢出的情况。 

DISCUSS中简短的代码学习：

int atoi(const char *str) {
	int sign = 1, base = 0, i = 0;
	while (str[i] == ' ') { i++; }
	if (str[i] == '-' || str[i] == '+') {
		sign = 1 - 2 * (str[i++] == '-');
	}
	while (str[i] >= '0' && str[i] <= '9') {
		if (base >  INT_MAX / 10 || (base == INT_MAX / 10 && str[i] - '0' > 7)) {
			if (sign == 1) return INT_MAX;
			else return INT_MIN;
		}
		base = 10 * base + (str[i++] - '0');
	}
	return base * sign;
}

 （1）while去掉空格；if读取符号；while读取数字（不用去0，因为通过计算得到最后的整数）；判断溢出。

---

(2015/10/21)

LeetCode-9 Palindrome Number ：速度需要改进

LeetCode-13 Roman to Integer：从高位开始，把一个字符和它后一个字符比较，若大于等于则加上其代表的数字，若小于则减，最后一个字符直接加上。

---

(2015/10/22)

LeetCode-11 Container With Most Water：

画一个矩阵，行表示左边的垂线，列表示右边的垂线。

矩阵的对角线，以及左下三角不用计算。（对角线上体积为0，左下三角与右上三角对称）

1）当左垂线的高小于右垂线时，剩下的行不用计算。

2）当有垂线的高小于左垂线时，剩下的列不用计算。

参考：

https://leetcode.com/discuss/11482/yet-another-way-to-see-what-happens-in-the-o-n-algorithm

---

(2015/10/23)

LeetCode-12 Integer to Roman：

罗马数字与整数的对应关系：

M            D             C             L             X             V             I

1000        500        100          50          10            5            1

从大往小，把整数表示成罗马数字。每次分两种情况：

1）插入n个相同的字母。

2）把小的数字放大的数字左边表示减法。

LeetCode-14 Longest Common Prefix：（easy）找出vector<string> strs中string的公共最长前缀。

LeetCode-15 3Sum：（cant）

参考：

https://leetcode.com/discuss/23595/share-my-solution-around-50ms-with-explanation-and-comments

1）确定第一个数。（忽略重复的情况）

2）剩下两个数的确定，相当于LeetCode-1 TwoSum的情况。（忽略重复的情况）

（先确定起点（front）和终点（rear），下标是否越界通过判断front < rear即可）

---

(2015/10/24)

LeetCode-16 3Sum Closest：（cant）

要学会举一反三，其实和LeetCode-15是一样的，不同之处只是下标移动的条件不同。

参考：

https://leetcode.com/discuss/42432/c-solution-o-n-2-using-sort

LeetCode-17 Letter Combinations of a Phone Number：（easy）

1）建立一个map数组，表示键盘上每一个数字对应的可能的字母。

2）建立两个数组，一个表示 digits字符串中字符所对应的数字，这个数字在 map中的下标；另一个数组表示对每一个map中的string遍历的下标。

3）可以通过计算一共有多少种可能的string来控制循环的次数。

class Solution {
public:
    vector<string> letterCombinations(string digits) {
        vector<string> map = \
        {"abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
        vector<int> index, scan;
        vector<string> ans;
        
        if(digits.size() == 0) return ans;
        for(string::size_type i = 0; i < digits.size(); i++){
            int tmp = digits[i] - '0';
            if(tmp >= 2 && tmp <= 9){
                index.push_back(tmp - 2);
                scan.push_back(0);
            }
            else return ans;
        }
        
        int nums = 1;
        for(vector<int>::size_type i = 0; i < index.size(); i++)
            nums *= map[index[i]].size();

        for(int i = 0; i < nums; i++){
            string tmp;
            for(vector<int>::size_type i = 0; i < index.size(); i++)
                tmp += map[index[i]][scan[i]];
            ans.push_back(tmp);
            scan[scan.size() - 1]++;
            for(vector<int>::size_type i = index.size() - 1; i > 0; i--){
                if(scan[i] >= map[index[i]].size()) {
                    scan[i] = 0;
                    scan[i - 1]++;
                }
                else break;
            }
        }
        return ans;
    }
};

---

(2015/10/27)

LeetCode-17 4Sum：（cant）

用到的C++知识：

1）unordered_map：用哈希函数组织的无序、关键字不可重复的map。c.count(k)，返回关键字等于k的元素数量。

2）pair类型、make_pair操作

3）vector容器的back操作，返回尾元素的引用。

C++中一个易错的地方，不好的编程习惯？

1）for(vector<int>::size_type i = 0; i < nums.size(); i++)，中间的条件判断语句最好不要写i < nums.size() - (一个数)。可能会溢出。

算法参考：https://leetcode.com/discuss/12358/my-c-solution-using-hashtable

1）根据nums的大小判断是否直接返回。

2）排序。

3）建立哈希表，关键字是两个数的和。

4）寻找另外两个数，（跳过重复的数），（得到一个answer时判断是否等于上一个answer（通过容器的back操作）（产生重复的原因：两组下标不同，但值完全相同的两组数，会产生相同的关键字））。

LeetCode-19 Remove Nth Node From End of List：（easy）

1）计算节点总数，算出要删除的是第几个节点。

2）分情况：1）删除的是头结点。2）删除的是中间的节点、尾节点。

LeetCode-20 Valid Parentheses：（easy）堆栈stack。

LeetCode-21 Merge Two Sorted Lists : （easy）

正确的链表构造方式：分别用两个指针指向下面两个需要比较的节点，用一个指针指向新链表的最后一个节点。

LeetCode-26 Remove Duplicates from Sorted Array：（easy）

两个下标：一个表示当前的最后一个非重复元素的下标，另一个扫描容器（扫描时跳过重复的元素）。

---

(2015/10/28)

LeetCode-27 Remove Element：（easy）

LeetCode-28 Implement strStr()：（easy）

注意：

1）要充分考虑到什么时候是不可能（或已不可能）找到needle。

2）正确找到needle的判断条件。

转载于:https://my.oschina.net/u/2463708/blog/519056