vvickey11的博客

class Solution { public: int countSegments(string s) { int count = 0 ; int len = s.size(); for(int i = 0 ; i < len ; i++ ){ if(s[i] == ' '){ co

class Solution { public: int rob(vector& nums) { int length = nums.size(); //cout << "length = " << length << endl; int dp[10000] = {0}; int max1 = 0; int max2 = 0; if (length == 0){ r

class Solution { public: vector plusOne(vector& digits) { int len = digits.size(); int plus = 0; for(int i = len - 1 ; i >=0 ;i--){ if(i == len - 1){

class Solution { public: int maxProfit(vector& prices) { //这道题我想的太复杂了，其实就是从头开始，只要后项大于前项就把数据加入到结果中， //多次交易的累和，只能向后计算 //贪心算法 int len = prices.size(); int res

class Solution { public: int maxProfit(vector& prices) { int len = prices.size(); if (len == 0){ return 0; } int minpos = 0; int maxn = 0 ; int j = 0; for (int i = 0; i < len; i++){

class Solution { public: string countAndSay(int n) { if( n <= 0){ return NULL; } string dp[n]; dp[0] = "1"; string now; string newstr;

class Solution { public: bool isPalindrome(string s) { int len = s.size(); if(len <= 1){ //记住回文数长度为1，是回文数 return true; } bool ti = false ,tj

class Solution { public: int singleNumber(vector& nums) { int temp = 0; //用异域的思想，出现两次的数就是最后异域为0，只有全部异域之后剩下的就是出现次数为1的元素 for(int i = 0 ; i < nums.size() ;i++){ te

点击打开链接 上面的参考的答案 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public

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

class Solution { public: int mySqrt(int x) { double cur = x,pre =0; while(abs(pre-cur)>0.000001){ pre = cur; cur = pre/2 + (x/(2*pre)); } r

参考了： （1）点击打开链接 （2）点击打开链接 class Solution { public: int maxProfit(vector& prices) { if(prices.size() == 0){ return 0; } int g[3] = {0} , l[3] = {0}; //

参考链接： （1）点击打开链接 （2）点击打开链接 class Solution { public: int maxProfit(int k, vector& prices) { if(prices.size() == 0){ return 0; } if( k > prices.size()){

分析法案：点击打开链接 最小的负数乘以负数是可以变成最大的乘积，因为是可以当个值成为一个字串的所以有和单个值的比较。有两个乘积记录子序列的乘积，从最大的正值和最小的负值去记录更新。 class Solution { public: int maxProduct(vector& nums) { int re; if(nums.empty()){

参考链接： 点击打开链接 class Solution { public: bool checkSubarraySum(vector& nums, int k) { if(nums.empty()){ return false; } //注意map用法，还有就是这个题目用的是余数 //有相同余

参考答案链接： 点击打开链接 class NumArray { public: //构造函数 NumArray(vector nums) { if(nums.empty()){ return; } else{ //求出从开始的0位置到当前i位置的累加和 /

reverse讲解，size与capcity区别：点击打开链接 参考代码解释：点击打开链接 我的实现： class Solution { public: void reverseWords(string &s) { //利用reverse函数事半功倍 //string类型是可以用s[]这样来访问元素的 //storeIndex表示当前存

class Solution { public: bool detectCapitalUse(string word) { int len = word.size(); if(len<=0){ return false; } if(len == 1){ return true;

class Solution { public: bool repeatedSubstringPattern(string s) { int len = s.size(); //注意这里从1开始，因为最小包含子串的字符串是2 //必须是包含等于二分之一的原因是奇数个字符的字符串 for(int i = 1; i <= len/

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

class Solution { public: vector getRow(int rowIndex) { vector res; if(rowIndex==0){ res.push_back(1); return res; } vector pre ; pre

class Solution { public: vector> generate(int numRows) { vector> res; if(numRows == 0) return res; if(numRows == 1) return {{1}}; for(int j = 0 ; j < numRows ; j+

class Solution { public: int searchInsert(vector& nums, int target) { int len = nums.size(); if(len == 0){ return 0; } if(target < nums[0] || target ==

class Solution { public: int strStr(string haystack, string needle) { int len1 = haystack.size(); int len2 = needle.size(); int i = 0 ; int index; //当两个序列的

class Solution { public: bool wordBreak(string s, vector& wordDict) { unordered_set wordSet; for(auto &item : wordDict){ wordSet.insert(item); }

参考链接： 点击打开链接 /** * 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) {} * }; */ clas

class Solution { public: int maxSubArray(vector& nums) { int length = nums.size(); int sum = 0 ; sum = nums[length-1]; int maxsum = sum ; //从后向前，因为

/**  * 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) {} * }; */ clas

class Solution { public: void merge(vector& nums1, int m, vector& nums2, int n) { vector res; int i , j , k; if(nums2.size() == 0) return; for(i = 0 , j = 0 , k = 0

class Solution { public: vector twoSum(vector& nums, int target) { map my_Map; vector result; for(int i = 0 ; i < nums.size() ; i++) { //保证每次插入的元素是在my_Map里是唯一的

#include #include #include #define INT_MAX 0x7fffffff using namespace std; class Solution { public: int reverse(int x) { //主要的是考慮溢出，一開始想用堆棧做但是是不對的，得先把各个数位分开啊！这个是关键 //接着，得考虑变换后是否会超越边界

//解题思路，回文数就是1234321 //分别提取最高位和最低位的数进行比较 #include using namespace std; ////这个处理不了溢出 //class Solution{ //public: // bool isParlindrome(int x){ // int nTen = 1; // int high = 0; //

class Solution { public: int uniquePaths(int m, int n) { //自底向上，从最后一个节点的方案数向回计算 int a[1000][1000]; if(n ==1 || m==1){ return 1; } a[m][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) {} * };

参考链接： 点击打开链接 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL)

class Solution { public: int maximalSquare(vector>& matrix) { int rows = matrix.size(); if(rows == 0) return 0; int cols = matrix[0].size(); vector > dp

class Solution { public: int numDistinct(string s, string t) { int rows = s.size(); int cols = t.size(); int dp[rows + 1][cols + 1] = {0}; //当T为空，T的子串在S中出现的次数是1，因为空

class Solution { public: int minimumTotal(vector>& triangle) { int rows = triangle.size(); int res; if (rows<1){ return 0; } if (rows == 1){ return triangle[0][0]; } int dp[1000][