一只不断成长的藏獒

解决本题时本地测试通过，但在提交代码时出现memory limit exceed。原因是并未考虑输入numRows为小于等于1的情况。#include#includeusing namespace std;class Solution {public: string convert(string s, int numRows) { if(numRows <= 1) re

对于有符号int类型的整数，其取值范围为-2^31~2^31-1，即-2147483648~2147483647，所以当输入为-2147483648时并不能这样做：int a; a = -x;即不能像其他负数那样直接取反，需要单独处理。#includeusing namespace std;class Solution {public: int reverse(int

首先根据位数初步判断待转换的数是否超过int数据类型的表示范围，接着用long long类型承载待转换的数，判断是否超过int数据类型的范围，最后将long long类型变量承载的数赋值给int类型的变量。这里编译器会发出警告，数据丢失。暂时忽略，以后继续研究。#include#include#includeusing namespace std;class Solution {pub

今天编写代码超没有感觉，本道题并不难，但在编写的过程中每敲一个字符，都感觉到违和感。路漫漫其修远兮，淡定，要坐得住。#includeusing namespace std;class Solution {public: bool isPalindrome(int x) { if(x < 0) return false; int tmp = x; if(tm

本题并没有太大的难度，有两点值得记忆：其一：由于用到vector容器，所以应包含头文件vector；其二：vector不支持初始化列表方式初始化，即vector strs = {"abcdef", "abcdrgh", "abcthu"}会导致编译出错。#include#include#includeusing namespace std;class Solution {publi

由于一般的链表不包含表头，所以使得处理第一个节点相较于其他节点具有特殊性，所以我的思路是先转化为含表头的的链表，再进行操作，最后还原成没有表头的链表，并返回。#includeusing namespace std;struct ListNode { int val; ListNode *next; ListNode(int x): val(x), next(NULL) {}};c

减治法算法设计技术的应用。#include<iostream>#include<string>using namespace std;class Solution {public: string countAndSay(int n) { if(n == 1) return "1"; string decreOne = count

#include<iostream>#include<string>using namespace std;class Solution {public: int lengthOfLastWord(string s) { if(s.size() == 0) return 0; string::iterator iter = s.e

为了在运行中避免可能出现的危险，即当string emuStack为空，emuStack.begin()和emuStack.end()是什么。采取的策略是先将emuStack重置为非空，再进行其他操作，这样就永远不可能碰到底部。#include#includeusing namespace std;class Solution {public: bool isValid(st

建议：在对指针*或->之前一定考虑是否为空指针或未初始化指针。#includeusing namespace std;struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {}};class Solution {public: ListNode* mergeTw

解决这个问题的很长时间用在了理解题意的阶段，本题的题意就是用一个数组表示一个很大的数，比如对于98，9存储于array[0]，8存储于array[1]。然后对这个数加1，返回表示新数的一个数组。class Solution {public: vector<int> plusOne(vector<int>& digits) { int length = digits.size

在设计算法的必要条件的理解题目中并没有很好的理解题目，没有利用已经排序这个重要的信息。#include#includeusing namespace std;class Solution {public: int removeDuplicates(vector& nums) { if(0 == nums.size()) return 0; if(1 == num

没有什么需要提及的，比较轻松的搞定。#include#includeusing namespace std;class Solution {public: int removeElement(vector& nums, int val) { vector::iterator iter1; iter1 = nums.begin(); int length; fo

没有考虑针对大海大的情况，哈哈。#include#includeusing namespace std;class Solution {public: int strStr(string haystack, string needle) { if(haystack.size() < needle.size()) return -1; string::iterat

解决问题的思路：用两个栈，其中一个栈只是用来作缓存，每次操作结束都为空栈。代码如下：class Queue {private: stack<int> stack1; stack<int> buf;public: // Push element x to the back of queue. void push(int x) { for(; !sta

解题思路：三指针，跟踪算法的过程如下： 代码如下：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {

/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class

class Solution {public: bool containsNearbyDuplicate(vector<int>& nums, int k) { map<int, int> hashRecord; int length = nums.size(); for(int i = 0; i < length; i++) {

class Solution {public: int computeArea(int A, int B, int C, int D, int E, int F, int G, int H) { int s1 = (C - A) * (D - B); int s2 = (G - E) * (H - F); if(G <= A || E >=

解决问题的思路：用两个队列实现栈。算法保证了两个队列至少有一个为空。代码如下：class Stack {private: queue<int> queue1; queue<int> queue2;public: // Push element x onto stack. void push(int x) { if(queue1.empty() &&

位操作算法代码如下：class Solution {public: bool isPowerOfTwo(int n) { if(n <= 0) return false; int fence = 1; int counter = 0; for(; n > 0; ) { if(fen

爬楼梯的递归版本（在leetcode上超时，在本地测试通过）：class Solution {public: int climbStairs(int n) { if(n == 1) return 1; if(n == 2) return 2; return climbStairs(n - 1)

/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class

class Solution {public: int lengthOfLongestSubstring(string s) { if(s.size() == 0) return 0; if(s.size() == 1) return 1; int hashTable[256];

有三点收获： 第一：string类型的变量可以直接相互赋值。 第二：begin()-1在本地VS2012会出现运行时错误迭代器错误，而在leetcode在先提交时并没有出现错误。 第三：反转string类型变量，直接如下使用即可： reverse(reversedResult.begin(), reversedResult.end());头文件并不需要添加。 下面是程序代码#include

步进电机思想的应用：可以一次走一步，也可以一次走多步(一次跨过多个具有相同属性的事物）。代码如下：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} *

/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class

在解决本道题时，最先想到的思路是用两个指针，一个在前，一个紧随其后。然后后面的指针的不断向后移动直到找到匹配的元素或者到达数组的末端。再不断进行下次迭代。代码如下：#include<iostream>#include<vector>using namespace std;class Solution {public: vector<int> twoSum(vector<int>& nu

class Solution {public: void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) { int sortedLength = m + n; m--; n--; sortedLength--; while(0 <= m

废话不多说，直接上代码，哈哈，痛快：/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL)

/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class

运行时间为40ms的代码如下（时间有点长）：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {pub

/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class

栈class Solution {public: int evalRPN(vector<string>& tokens) { stack<string> stringStack; int xiaoshu; int dashu; for(int i = 0; i < tokens.size(); i++) {

相似的题目及其题解报告class Solution {public: bool canJump(vector<int>& nums) { reverse(nums.begin(), nums.end()); int length = nums.size(); bool *arr = new bool[length]; arr[0] =

一开始我是整体思考如何打印一个环，后来继续参考这篇文章，发现可以将顺时针打印一个环分解成打印上，结束，打印右，结束，打印下，结束，打印左，结束。这些操作的分解的基础基于一个事实：每个环的开头都是matrix[cycleNumber][cycleNumber]所以在打印“右”的时候不必再考虑“上”，减少动作之间的耦合可以使得思考更加容易。代码如下：class Solution {public:

经典的动态规划问题，Unique Paths I按如下方式填表，Unique Paths II稍微变化即可。Unique Paths I 代码如下class Solution {public: int uniquePaths(int m, int n) { vector<vector<int>> matrix(m, vector<int>(n)); for(in

先将单向链表转换成首尾相连的循环链表，最后再转换成单向链表。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Soluti

class Solution {public: int mySqrt(int x) { if(x <= 0) return 0; long long left = 1; long long right = x; while(left <= right) { long long mid =

/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class