Simmu

求最后面的一个单词的长度。 感觉没有什么好说的。在为空格之前就是记录之前的长度就好。 class Solution { public: int lengthOfLastWord(string s) { if(s.size()==0)return 0; int ans=0; int get_ss=0; for(int ii=

寻找最长的回文串，如果暴力来写的话，那么会有O(n^3)的时间复杂度，会超时，所以想到通过枚举回文串的中间点来做，比如adcda，那么通过确定c是中间点，然后通过两边依次一步一步延长来判断回文串的长度，通过枚举每个点是否可以是中间点，还有为中间点的话，长度会是多少。这样做的时间复杂度为O（n^2）。class Solution { public: string longestPalindr

求每行或者每一列或者每个九宫格的数字都不重复且都为1到9之间的数字。而且不用考虑整体的合法性，虽然有空白的情况。 直接做就行了。 class Solution { public: bool isValidSudoku(vector>& board) { int s[9][9],check_num[10]; for(int ii=0;ii<9;ii++){

简单题，不过需要判断是否逆转后的数字超过int的范围，int的范围为-(1 class Solution { public: int reverse(int x) { int s[1000]; int cnt=0; int mark=1; long long sum=1; long long ans=0;

寻找字符串匹配，如果匹配就返回第一个匹配的位置，如果没有匹配就返回-1.直接用string的find()函数。 class Solution { public: int strStr(string haystack, string needle) { return haystack.find(needle); } }; string相关的查找函数： int f

删除vector中指定元素，并返回vector的长度。 class Solution { public: int removeElement(vector& nums, int val) { for(vector::iterator ii=nums.begin();ii!=nums.end();){ if(*ii==val){nums.erase(

删除vector中重复的元素并且返回vector的长度。使用vector中的erase后，迭代器会自动转移到下一个位置，所以在用i++的时候得注意分情况了。 class Solution { public: int removeDuplicates(vector& nums) { if(!nums.size())return 0; for(vector:

求手机上的数字所对应的字母之间的组合可能。用递归来做比较简单。 class Solution { public: int yy[10]={0,0,3,3,3,3,3,4,3,4};//对应每个数字所拥有的字母的个数 char str_ss[10000]; vector letterCombinations(string digits) { vectorre

求给你多少个左括号（相等的意思），多少种合法的括号匹配。将左括号看做是+1，右括号则为-1，那么合法的要求则是不能使得和小于0，如果和为0，则必须后面一个为左括号。结果的合法的操作为和为0 class Solution { public: char s[10000]; vector generateParenthesis(int n) { string ss;

连接两个从小到大的排序好的单向链表。通过依次比较来生成一个总的单向链表。 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ cla

括号匹配，通过用栈来存储，如果有栈顶和要输入的括号匹配，那么就将栈中的括号弹出，如果不匹配，那么将这个要输入的括号压入栈中。判断括号是不是匹配，通过判断栈是不是到最后为空，为空则说明匹配。 class Solution { public: bool isValid(string s) { stack temp; temp.push(s[0]);

求zigzag模式下的字符串。 图上为该种模式的说明 1    1     1 1 1 1  1 1     1 首先我是对numRows=1和=2的情况单独处理的，因为这两种情况比较特殊，其他的情况看做是一种。 class Solution { public: string convert(string s, int numRows) { st

求给定一个升序的序列，求出给定的target数字的位置，包括第一个和最后一个，如果没有找到则返回-1，-1。 用stl中的upper_bound和lower_bound。 其中lower_bound返回不小于target的第一个数，如果都小于target，则返回last（last=nums.end()，其中last是超出范围的）。 upper返回大于target的第一个数，如果都小于targ

简单题，求回文的整数，先额外判断一下负数都不可能为回文串，其他的作为一种考虑。 class Solution { public: bool isPalindrome(int x) { int s[1000]; int cnt=0; long long xx=x; if(xx<0)return false; w

每个节点上标明从这个点跳到其他点的最大距离，最后问你最后能不能跳到最后一个点。 更新从这个点到能跳的最大距离，之间的点明显也可以跳。依次扫描这些点，如果遍历到这个点但是能够达到的点并没有会到这个点，那么就不可能走到这个点，那么就返回false。如果能扫描到最后一个点，那么就返回true。 class Solution { public: bool canJump(vector& num

求和最大的连续的子序列。 直接一次遍历，如果和小于0的话，就自动舍弃，在遍历的过程中记得更新和最大的。 class Solution { public: int maxSubArray(vector& nums) { int sum=0; int ans=nums[0]; for(int ii=0;ii<nums.size();ii++)

求一个数的n次方。 n给的是int类型的，但是其实n取到-2147483648时，程序会出现问题，不知道为什么。只有特殊处理了。 采用二分的方法对n进行处理，这样的话迭代会很快。O(logn)的时间复杂度。 class Solution { public: double myPow(double x, int n) { //double sum=1;

和046意思差不多，区别在于这里不允许重复的序列。因为给的序列可能是有重复的数字。 class Solution { public: vector>ff; vector> permuteUnique(vector& nums) { vectorgg; sort(nums.begin(),nums.end()); find_ans(0

求给定序列的排列个数。 class Solution { public: vector>ff; vector> permute(vector& nums) { vectorgg; find_ans(0,0,gg,nums); return ff; } void find_ans(int step,i

求两个大数的乘法，用字符串表示的那种。 直接模拟，不过算乘法的时候需要将字符串颠倒下次序。然后需要另外考虑一个比较大的数字乘以0，如果不另外处理的话，结果为很多0的字符串的，这样的话就当是一个0输出。 class Solution { public: string multiply(string num1, string num2) { reverse(num1.beg

求一个未排序的序列，其中几个数的和为target，数字不能重复。 使用的方法和039差不多，具体差别在代码中展示。 class Solution { public: void get_ans(int ans,vector& nums,vector>&an,vector get_ss,int limit){ if(ans==0){an.push_

给你一个没有排序的序列和一个target，求出序列的和的值为target，允许序列中选择的值可以重复。 直接用递归。由于需要答案有序，所以先把序列排序，然后再递归的时候不能选择比上一次小的值，可以避免重复的计算。 其中不要随便运用vectoruu中的uu.size()-1这个数，会出错的，当uu.size()为0的时候。 class Solution { public: v

1, 11, 21, 1211, 111221, ... 意思为第一个为1，那么第二个就表示为第一个为1个1，所有为11，第三个就是来描述第二个的，有2个1，那么就是21，第四个来描述第三个，为1个2，1个1，所以为1211.依次类推。 class Solution { public: string countAndSay(int n) { n--; v

寻找一个排序的序列的某个target，如果没有，就输入它如果插入的话，应该插入在哪里的位置。假设序列没有重复数字的情况。 直接用STL中的lower_bound即可。 class Solution { public: int searchInsert(vector& nums, int target) { vector::iterator find; f

删除从结尾到开头第n个的单向链表的值，并返回链表，通过用两个指针，一个在前，一个在后，他们之前的距离就为n，当前面的指针指到结尾时，后面的也就恰恰指到目标值了，当然我是按照指到目标的前一个值来计算的，这样容易计算。 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListN

交换相邻两个节点的顺序，不能只是改变节点的值。 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution {

有三种颜色，给他们排序，不用一般的排序算法。 由于只有三种数字，所有可以直接统计，然后再依次赋值即可。 class Solution { public: void sortColors(vector& nums) { int temp[3]; temp[0]=temp[1]=temp[2]=0; for(int ii=0;ii<nums.

在矩阵中找一个数。矩阵则是有规律的。 class Solution { public: int climbStairs(int n) { int temp[3]; temp[0]=1; temp[1]=1; for(int ii=2;ii<=n;ii++){ temp[ii%3]=temp[(ii-1

记录所有的三个数的和为0的组合，其中按照大小排序，并且不能有重复的。 这一题感觉，首先排序，我是用两个for循环求出所有的两个数的之和，但是由于前面我用map将所有的数都标记记录了一遍，所以直接验证两数之和的相反数是不是在map中来判断，但是不知道这样为何为超时，时间复杂度也就是O（n^2）. 然后后面就是参照discuss中的算法来做的。简而言之，先排序，然后先确认两数之和的相反数，因为它必

从一个一维的开头到结尾，每次可以走一步或者两步。求到结尾的步骤方法的个数。 class Solution { public: int climbStairs(int n) { int temp[3]; temp[0]=1; temp[1]=1; for(int ii=2;ii<=n;ii++){ te

和LeetCode 063和LeetCode 062差不多一样的意思，做法也差不多，主要这题是求左上到右下的最短代价。而一个位置的最短代价是dp[ii][jj]=min(dp[ii-1][jj],dp[ii][jj-1])+在此处的代价。 class Solution { public: int minPathSum(vector>& grid) { int m=grid

和leetcode 062大概一致的意思。主要是要额外判断有障碍的情况。 有障碍的情况是此处的走法为0。class Solution { public: int uniquePathsWithObstacles(vector>& obstacleGrid) { int m=obstacleGrid.size(); int n=obstacleGrid[0]

求从左上角走到右下角所需要的多少种走法。 用简单的动态规划吧，不过也没有求最优解的那种。 到达一个点的走法个数只能是从它正上方和左边的走法的个数的和。即dp[i][j]=dp[i-1][j]+dp[i][j-1]其中dp表示的是走法。 class Solution { public: int uniquePaths(int m, int n) { vector>dp(

两个用字符串存储的二进制数相加。 class Solution { public: string addBinary(string a, string b) { string ff; int sum=0; int nn=0; reverse(a.begin(),a.end()); reverse(b.begi

给一个用vector保存的数加一，主要考虑最大的位会不会进位即可。 class Solution { public: vector plusOne(vector& digits) { vectorff; int sum=0; int len=digits.size(); digits[len-1]++; su

求最大前缀。暴力算法O（n^2）现在才知道那个如果没有数据的话，需要输出“”。 我看到在discuss中有一种方法是，对于每个字符，纵向遍历，如果一列下来有不同的，那么最长前缀就是前面一列的字符了。感觉挺好的虽然时间复杂度依然是O（n^2），但是没有浪费找的时间。 class Solution { public: string longestCommonPrefix(vector& s

给你一个范围1-n，然后从中选k个数，有多少种组合。 直接用递归。 class Solution { public: void dfs(int step,int kk,int nn,int limit,vectortemp,vector>&ans){ if(step==kk){ans.push_back(temp);return ;} for(int i

给你一个集合，问有多少个子集。 直接用递归。 class Solution { public: void dfs(int step,int nn,int limit,vectortemp,vector>&ans,vectornums){ ans.push_back(temp); if(step==nn)return ; for(i

求给定的序列中三个数的和与给定的目标最接近。 这个可以转化为3sum问题，即LeetCode 015的做法，将目标减去一个数，只不过判断的不是为相反数，而是最接近。 class Solution { public: int threeSumClosest(vector& nums, int target) { vector >w; vectortemp;

可以直接用stl中的next_permutation来实现，但是在321中不会自动返回为123，所以这个地方要额外判断。我是直接写的。 这个里面的判断大小规则是： 从前往后，如果序列相同的位置的数比另一个相同位置的数大，那么这个序列就比另外一个序列大，那么1 2 4 3的下一个则为1 3 2 4。 做法为，首先从后往前遍历，如果出现前面的数比后面的数要小，假设这个数为A，前面的数为B，B