Kiritow/OJ-Problems-Source
1
0
Fork 0
mirror of https://github.com/Kiritow/OJ-Problems-Source.git synced 2024-03-22 13:11:29 +08:00
Code Issues Projects Releases Wiki Activity
1126c4062a
OJ-Problems-Source/LeetCode-CN/刷题.md
JZFamily c76d6555d3
Update 刷题.md
2018-07-06 12:58:21 +08:00

2476 lines
51 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

>create by jzf@2018/06/20
[TOC]
# 作业
## 627. 交换工资 @2018/06/20
### jzf :517ms
```c++
update salary
set sex = case when sex ='m' then 'f' else 'm' end;
```
### kiritow:563ms
```c++
update salary set sex = case sex
when 'f' then 'm'
when 'm' then 'f'
end
```
## 3. 无重复字符的最长子串 @2018/06/20
### 北河
* 第一版 :392ms
```c++
class Solution {
public:
int lengthOfLongestSubstring(string s) {
map<char, short> v;
int max_num = 0;
for (int i = 0; i < s.size(); ++i) {
if (v.find(s[i]) != v.end()) {
if (max_num < v.size()) {
max_num = v.size();
}
i = v.find(s[i])->second + 1;
v.clear();
}
if (i >= s.size()) {
break;
}
v[s[i]] = i;
if (max_num < v.size()) {
max_num = v.size();
}
}
return max_num;
}
};
```
* 第2版 :32ms
```c++
class Solution {
public:
int lengthOfLongestSubstring(string s) {
map<char, short> v;
int max_num = 0;
for (int i = 0; i < s.size(); ++i) {
if (v.find(s[i]) != v.end()) {
if (max_num < v.size()) {
max_num = v.size();
}
++i;
while (i < s.size()) {
if (v.find(s[i]) != v.end()) {
++i;
continue;
}
--i;
break;
}
if (i >= s.size()) {
return max_num;
}
i = v.find(s[i])->second + 1;
v.clear();
}
if (i >= s.size()) {
break;
}
v[s[i]] = i;
if (max_num < v.size()) {
max_num = v.size();
}
}
return max_num;
}
};
```
### jzf :252 ms 8
```c++
class Solution {
public:
int lengthOfLongestSubstring(string s) {
int num =1;
int max =0;
if(s.length()==1)
{
return 1;
}
for(size_t i =0;i<s.length();i++)
{
for(size_t j=i+1;j<s.length();j++)
{
int flag =0;
for(size_t k =i;k<j;k++)
{
if(s[j]==s[k])
{
flag =1;
break;
}
num++;
}
if(num>max)
{
max =num;
}
if(flag ==1)
{
break;
}
num =1;
}
num =1;
}
return max;
}
};
```
### puck :544ms 2
```c++
#ifndef SOLUTION_H
#define SOLUTION_H
#include <algorithm>
#include <string>
#include <set>
using std::string;
class Solution
{
public:
int lengthOfLongestSubstring(string s)
{
int result{};
for (std::size_t i{}; i < s.size(); ++i)
{
string tmp_str = s.substr(i);
int cu_length{};
std::set<char> set_except;
for (auto ch : tmp_str)
{
if (set_except.end() == set_except.find(ch))
{
set_except.insert(ch);
++cu_length;
}
else
{
break;
}
}
result = std::max(result, cu_length);
}
return result;
}
};
#endif
```
### kiritow ：24ms 2
```c++
#include <cstdlib>
#include <cstring>
class Solution {
public:
int lengthOfLongestSubstring(string s) {
int sz = s.size();
int bin[256];
int maxlen = 0;
int clen = 0;
int L = 0;
while (L < sz)
{
memset(bin, 0, sizeof(int) * 256);
int i;
for (i = L; i < sz; i++)
{
if (bin[s[i]])
{
maxlen = clen > maxlen ? clen : maxlen;
clen = 0;
L++;
break;
}
else
{
bin[s[i]] = 1;
clen++;
}
}
if (i == sz)
{
maxlen = clen > maxlen ? clen : maxlen;
break;
}
}
return maxlen;
}
};
```
### 知识点
桶排序
sync_with_stdio
### 总结
1, 对比代码发现，利用现有的数据结构，可以快速出活，而且代码简洁，逻辑清晰。
2, STL不好好用，很慢。
## 494. 目标和 @2018/06/21
### jzf
* 第一版 超时 复杂度 n*2^n
```c++
class Solution {
public: int findTargetSumWays(vector<int>& nums, int S) {
int n = 0;
int sum = 0;
int b = 0;
int size =nums.size();
for (size_t k = 0; k <size ; k++)
{
b = ((1 << k) | b);
}
for (size_t i = 0; i <= b; i++)
{
n = 0;
for (size_t j = 0; j < size; j++)
{
n += ((1 << j)&i) ? -nums[j] : nums[j];
}
if (n == S)
{
sum++;
}
}
return sum;
}
};
```
* 第二版
### kiritow ：24ms 2
```c++
class Solution {
public:
int findTargetSumWays(vector<int>& nums, int S) {
if (S < -1000 || S>1000) return 0;
int sz = nums.size();
int msz = sizeof(int) * 2048;
int _bin[2048] = { 0 };
int _xbin[2048] = { 0 };
int* p = _bin;
int* q = _xbin;
memset(p, 0, msz);
p[1000] = 1;
for (int i = 0; i < sz; i++)
{
memset(q, 0, msz);
for (int j = 0; j < 2048; j++)
{
if (p[j])
{
//printf("p[%d]=%d\n", p[j]);
// now=j-1000;
int L = j - nums[i]; // now-nums[i]+1000
int R = j + nums[i];
q[L] += p[j];
q[R] += p[j];
//printf("q[%d]=%d\n", L, q[L]);
//printf("q[%d]=%d\n", R, q[R]);
}
}
std::swap(p, q);
}
return p[S + 1000];
}
};
```
### 知识点
dfs
bfs
剪枝
记忆搜索
去掉重复
没写dp，身败名裂--惠惠语录
## 601. 体育馆的人流量@2018/06/21
### jzf :521ms 抄
```sql
select s1.*
from stadium as s1, stadium as s2,stadium as s3
where (((s2.id =s1.id+1) and (s3.id =s1.id+2))
or((s2.id =s1.id-1) and (s3.id =s1.id+1))
or((s2.id =s1.id-2) and (s3.id =s1.id-1)))
and
(s1.people>=100 and s2.people>=100 and s3.people >=100)
group by s1.id
```
### 知识点
mysql必知必会 16章 自连接
### 总结
1，看了下最快的sql语句，感叹逻辑差不过的东西，差距真大呀
## 9. 回文数@2018/06/22
### 羽柔子 372ms
```js
var isPalindrome = function(x) {
return x.toString()===x.toString().split("").reverse().join("");
};
```
* 第二版 ：128ms
```c++
class Solution {
int list[10],len=0,i=0;
public:
bool isPalindrome(int x) {
if(x<0)return false;
len=i=0;
//分解
while(true){
if(x>=10){
list[len++]=x%10;
x/=10;
}
else{
list[len++]=x;
break;
}
}
//判断
--len;
for(i=0;i<len&&list[i]==list[len];i++,len--);
return i>=len;
}
};
```
### jzf
* 第一版 ：232ms
```c++
class Solution {
public:
bool isPalindrome(int x) {
int mod;
int sh =x;
vector<int> vec;
if(x <0)
{
return false;
}
if(x ==0)
{
return true;
}
for(size_t i =0;sh>0;i++)
{
vec.push_back(sh%10);
sh = sh/10;
}
vector<int>::iterator i=vec.begin();
vector<int>::iterator j=vec.end()-1;
for(;i<j;i++,j--)
{
if(*i!=*j)
{
return false;
}
}
return true;
}
};
```
* 第2版 ：140ms
```c++
class Solution {
public: bool isPalindrome(int x) {
int mod;
int sh =x;
vector<int> vec;
if(x <0)
{
return false;
}
if(x ==0)
{
return true;
}
if(x%10 ==0)
{
return false;
}
for(size_t i =0;sh>0;i++)
{
vec.push_back(sh%10);
sh = sh/10;
}
vector<int>::iterator i=vec.begin();
vector<int>::iterator j=vec.end()-1;
for(;i<j;i++,j--)
{
if(*i!=*j)
{
return false;
}
}
return true;
}
};
```
### 北河 244ms
* 第一版
```c++
class Solution {
public:
bool isPalindrome(int x) {
char p[10], q[10];
short size = sprintf(p, "%d", x);
reverse_copy(p, p + size, q);
return x < 0 ? false : (mismatch(p, p + size / 2 + 1, q).first == (p + size / 2 + 1) ? true : false);
}
};
```
* 第二版
```c++
class Solution {
public:
bool isPalindrome(int x) {
if (x < 0) {
return false;
}
string s = to_string(x);
return mismatch(s.begin(), s.end(), s.rbegin()).first == s.end();
}
};
```
### kiritow 120ms
```c++
#include <cstdio>
class Solution {
public:
bool isPalindrome(int x) {
/*
// Converting to string is too slow!!
char buff[64] = { 0 };
sprintf(buff, "%d", x);
int len = strlen(buff);
int L = 0, R = len - 1;
while (L < R)
{
if (buff[L] != buff[R]) return false;
++L;
--R;
}
return true;
*/
if (x < 0) return false;
int buff[64] = { 0 };
int c = 0;
int tx = x;
while (tx > 0)
{
buff[c++] = tx % 10;
tx /= 10;
}
int L = 0, R = c - 1;
while (L < R)
{
if (buff[L] != buff[R]) return false;
++L;
--R;
}
return true;
}
};
```
### puck
```c++
#include <string>
class Solution
{
public:
bool isPalindrome(int x)
{
if (x < 0)
return false;
std::string tmp = std::to_string(x);
std::size_t bi_size = tmp.size() / 2;
auto half = tmp.begin() + bi_size;
auto iter = tmp.begin();
auto riter = tmp.rbegin();
for (; iter != half; ++iter, ++riter)
{
if (*iter != *riter)
return false;
}
return true;
}
};
```
### 总结
1，
我在想一个问题
*羽柔子撤回了一条消息*
喵在想一个问题 --羽柔子语录
## 225. 用队列实现栈@2018/06/22
### 羽柔子 0ms
```c++
class MyStack {
int stack[10],index=0;
public:
/** Initialize your data structure here. */
MyStack() {
}
/** Push element x onto stack. */
void push(int x) {
stack[index++]=x;
}
/** Removes the element on top of the stack and returns that element. */
int pop() {
return stack[--index];
}
/** Get the top element. */
int top() {
return stack[index-1];
}
/** Returns whether the stack is empty. */
bool empty() {
return !index;
}
};
```
### kiritow
```c++
#include <list>
class MyStack {
public:
/** Initialize your data structure here. */
MyStack() {
}
/** Push element x onto stack. */
void push(int x) {
lst.push_back(x);
}
/** Removes the element on top of the stack and returns that element. */
int pop() {
int t = lst.back();
lst.pop_back();
return t;
}
/** Get the top element. */
int top() {
return lst.back();
}
/** Returns whether the stack is empty. */
bool empty() {
return lst.empty();
}
private:
std::list<int> lst;
};
```
## 28. 实现strStr() @2018/06/23
### jzf
* 第一版 4ms
```c++
class Solution {
public:
int strStr(string haystack, string needle) {
string::iterator ihay;
string::iterator inee;
int ni =haystack.size();
int nn =needle.size();
int ret = -1;
if(nn==0)
{
return 0;
}
if(ni<nn)
{
return -1;
}
for(size_t i=0;i<ni-nn+1;i++)
{
if(!(haystack.substr(i,nn)).compare(needle))
{
ret =i;
break;
}
}
return ret;
}
};
```
### 羽柔子
```c++
class Solution {
public:
int strStr(string haystack, string needle) {
if(needle.size()==0)return 0;
if(haystack.size()<needle.size())return -1;
size_t
i,j,
ilen=haystack.size()-needle.size(),
jlen=needle.size();
for( i = 0; i <= ilen; i++){
for( j = 0; j < jlen; j++)
if(haystack[i+j]!=needle[j])
goto A;
return i;
A:;
}
return -1;
}
};
```
### puck
```c++
class Solution
{
public:
int strStr(string haystack, string needle)
{
std::size_t size_a{haystack.size()};
std::size_t size_b{needle.size()};
if (0 == size_b)
{
return 0;
}
bool flag{};
for (int i{}; i < size_a; ++i)
{
if (haystack.at(i) == needle.at(0))
{
flag = true;
for (int j{1}; j < size_b; ++j)
{
if (i + j >= size_a || haystack.at(i + j) != needle.at(j))
{
flag = false;
break;
}
}
if (flag)
{
return i;
}
}
}
return -1;
}
};
```
## 823. Binary Trees With Factors@2018/06/23
## 196. 删除重复的电子邮箱@2018/06/23
### 北河
*
```sql
delete from Person where id in (select c.id from (select a.id from Person a join Person b on a.Email = b.Email and a.Id > b.Id) c);
```
## 48. 旋转图像@2018/06/24
### jzf
* 4ms
```c++
class Solution {
public:
void rotate(vector<vector<int>>& matrix) {
int tmp;
for(size_t i=0; i<matrix.size();i++)
{
for(size_t j=i+1;j<matrix.size();j++)
{
tmp =matrix[i][j];
matrix[i][j] =matrix[j][i];
matrix[j][i] =tmp;
}
}
for(size_t i =0;i<matrix.size();i++)
{
reverse(matrix[i].begin(),matrix[i].end());
}
}
};
```
### kiritow
```c++
class Solution {
public:
void rotate(vector<vector<int>>& matrix) {
int n = matrix.size();
if (n % 2) // odd number, easy
{
int mid = n / 2;
for (int dis = 1; dis <= mid; dis++)
{
// do chain swap at distance:dis
int swap_n = 2 * dis + 1;
// save right col
vector<int> tvec;
int begin_pos = mid - dis;
for (int i = 0; i < swap_n; i++)
{
tvec.push_back(matrix[begin_pos + i][mid + dis]);
}
// start rotate
// RIGHT <- UPPER
for (int i = 0; i < swap_n; i++)
{
//printf("matrix[%d][%d]<-matrix[%d][%d]\n", begin_pos + i, mid + dis, mid - dis, begin_pos + i);
matrix[begin_pos + i][mid + dis] = matrix[mid - dis][begin_pos + i];
}
// UPPER <- LEFT
for (int i = 0; i < swap_n; i++)
{
//printf("matrix[%d][%d]<-matrix[%d][%d]\n", mid - dis, begin_pos + i, begin_pos + i, mid - dis);
matrix[mid - dis][begin_pos + (swap_n - i - 1)] = matrix[begin_pos + i][mid - dis];
}
// LEFT <- DOWNER
for (int i = 0; i < swap_n; i++)
{
//printf("matrix[%d][%d]<-matrix[%d][%d]\n", begin_pos + i, mid - dis, mid + dis, begin_pos + i);
matrix[begin_pos + i][mid - dis] = matrix[mid + dis][begin_pos + i];
}
// DOWNER <- TEMP
for (int i = 0; i < swap_n; i++)
{
//printf("matrix[%d][%d]<-tvec[%d]\n", mid + dis, begin_pos + i, i);
matrix[mid + dis][begin_pos + (swap_n - i - 1)] = tvec[i];
}
// debug
//print(matrix);
}
}
else // oh, this stuff sucks.
{
int mid = n / 2 ;
for (int dis = 1; dis <= mid ; dis++)
{
// do chain swap at distance:dis
int swap_n = 2 * dis;
// save right col
vector<int> tvec;
int begin_pos = mid - dis;
for (int i = 0; i < swap_n; i++)
{
tvec.push_back(matrix[begin_pos + i][mid + dis - 1]);
}
// start rotate
// RIGHT <- UPPER
for (int i = 0; i < swap_n; i++)
{
//printf("matrix[%d][%d]<-matrix[%d][%d]\n", begin_pos + i, mid + dis, mid - dis, begin_pos + i);
matrix[begin_pos + i][mid + dis - 1] = matrix[mid - dis][begin_pos + i];
}
// UPPER <- LEFT
for (int i = 0; i < swap_n; i++)
{
//printf("matrix[%d][%d]<-matrix[%d][%d]\n", mid - dis, begin_pos + i, begin_pos + i, mid - dis);
matrix[mid - dis][begin_pos + (swap_n - i - 1)] = matrix[begin_pos + i][mid - dis];
}
// LEFT <- DOWNER
for (int i = 0; i < swap_n; i++)
{
//printf("matrix[%d][%d]<-matrix[%d][%d]\n", begin_pos + i, mid - dis, mid + dis, begin_pos + i);
matrix[begin_pos + i][mid - dis] = matrix[mid + dis -1][begin_pos + i];
}
// DOWNER <- TEMP
for (int i = 0; i < swap_n; i++)
{
//printf("matrix[%d][%d]<-tvec[%d]\n", mid + dis, begin_pos + i, i);
matrix[mid + dis -1][begin_pos + (swap_n - i - 1)] = tvec[i];
}
// debug
//print(matrix);
}
}
}
};
```
### puck
```c++
#include <algorithm>
class Solution
{
public:
void rotate(vector<vector<int>> &matrix)
{
auto n = matrix.size();
auto max = n - 1;
auto half = n / 2;
for (int i{}; i < half; ++i)
{
for (int j{}; j < half; ++j)
{
std::swap(matrix[i][j], matrix[j][max - i]);
std::swap(matrix[i][j], matrix[max - i][max - j]);
std::swap(matrix[i][j], matrix[max - j][i]);
}
}
if (n == 2 * half + 1)
{
for (int i{}; i < half; ++i)
{
std::swap(matrix[i][half], matrix[half][max - i]);
std::swap(matrix[i][half], matrix[max - i][half]);
std::swap(matrix[i][half], matrix[half][i]);
}
}
}
};
```
## 4. 两个排序数组的中位数@2018/06/24
### 种子 似乎不符合复杂度限制
```c++
class Solution {
public:
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
copy(nums2.begin(),nums2.end(),back_inserter(nums1));
sort(nums1.begin(),nums1.end());
return nums1.size()%2?\
double(nums1[nums1.size()/2]):\
double(nums1[nums1.size()/2]+nums1[nums1.size()/2-1])/2;
}
};
```
### 北河 48ms
```c++
class Solution {
public:
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
std::multiset<int> v;
copy(nums1.begin(), nums1.end(), inserter(v, v.begin()));
copy(nums2.begin(), nums2.end(), inserter(v, v.begin()));
std::multiset<int>::iterator p, q;
p = q = v.begin();
return v.size() % 2 == 0 ? ((double)*(advance(p, v.size() / 2 - 1), p) + (double)*(advance(q, v.size() / 2), q))/ 2 : (double)*(advance(p, v.size() / 2), p);
}
};
```
### kiritow
```c++
#include <algorithm>
class Solution {
public:
void forward_until(vector<int>& nums1, vector<int>& nums2,
int lenA,int lenB,
int& idxA, int& idxB, int& passed, int midLen)
{
while (idxA < lenA&&idxB < lenB && passed < midLen)
{
if (nums1[idxA] < nums2[idxB])
{
idxA++;
passed++;
}
else
{
idxB++;
passed++;
}
}
while (idxA < lenA&&passed < midLen)
{
idxA++;
passed++;
}
while (idxB < lenB&&passed < midLen)
{
idxB++;
passed++;
}
}
int getCurrent(vector<int>& nums1, vector<int>& nums2,
int lenA,int lenB,
int idxA, int idxB)
{
if (idxA < lenA&&idxB < lenB)
{
return std::min(nums1[idxA], nums2[idxB]);
}
else if (idxA < lenA)
{
return nums1[idxA];
}
else
{
return nums2[idxB];
}
}
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
int lenA = nums1.size();
int lenB = nums2.size();
int sumLen = lenA + lenB;
int midLen = sumLen / 2 - (1 - (sumLen % 2));
int idxA = 0;
int idxB = 0;
int passed = 0;
forward_until(nums1, nums2, lenA, lenB, idxA, idxB, passed, midLen);
if (sumLen % 2)
{
return getCurrent(nums1, nums2, lenA, lenB, idxA, idxB);
}
else
{
int step1 = getCurrent(nums1, nums2, lenA, lenB, idxA, idxB);
forward_until(nums1, nums2, lenA, lenB, idxA, idxB, passed, midLen + 1);
int step2 = getCurrent(nums1, nums2, lenA, lenB, idxA, idxB);
return (step1 + step2) / 2.0;
}
}
};
```
### jzf
算了，我就算是抄上边几个的吧。
### 小白
* 第一版 40ms
```c++
class Solution {
public:
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
vector<int> ab;
std::merge(nums1.begin(), nums1.end(), nums2.begin(), nums2.end(), std::back_inserter(ab));
return (double(ab[(ab.size() >> 1) - !(ab.size() & 1)]) + double(ab[(ab.size() >> 1)])) *0.5;
}
};
```
* 第二版
```c++
class Solution {
public:
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
vector<int> ab;
std::merge(nums1.begin(), nums1.end(), nums2.begin(), nums2.end(), std::back_inserter(ab));
return (double(ab[(ab.size() >> 1) - !(ab.size() & 1)]) + double(ab[(ab.size() >> 1)])) *0.5;
}
};
```
* 第三版 40ms
```c++
class Solution {
public:
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
vector<int> ab;
ab.reserve(nums1.size() + nums2.size());
std::merge(nums1.begin(), nums1.end(), nums2.begin(), nums2.end(), std::back_inserter(ab));
return double(ab[(ab.size() >> 1) - !(ab.size() & 1)] + ab[(ab.size() >> 1)]) * 0.5;
}
};
```
### 总结
1，北河和种子的体现了使用STL的巨大优势，利用现有的工具，确实好很多。
而我在解题的过程中出现了自创轮子没本事放弃，和不熟悉STL等问题
2，算法还是要学的，STL的复杂度也要会分析
### 知识点
1， std::merge
2，copy
## 724. 寻找数组的中心索引@2018/06/25
### jzf 28ms
```c++
class Solution {
public:
int pivotIndex(vector<int>& nums) {
vector<int>::iterator iter;
int sum =0;
int ret =-1;
for(iter =nums.begin();iter!=nums.end();iter++)
{
sum+=*iter;
}
int tmp =0;
for(size_t i=0;i<nums.size();i++)
{
if((sum -nums[i]-tmp)==tmp)
{
ret =i;
break;
}
tmp+=nums[i];
}
return ret;
}
};
```
### 羽柔子
```js
var pivotIndex = function(nums) {
var r = 0,l=0,len = nums.length;
if(len<2)return -1;
for(
var i = 1;
i < len;
i++
)r += nums[i];
for(
var i=0;
l!=r && i<len;
){
l+=nums[i];
i++;
r-=nums[i];
}
return i>=len?-1:i;
};
```
```c++
class Solution {
public:
int pivotIndex(vector<int>& nums) {
int r = 0,l=0,len = nums.size(),i;
if(len<2)return -1;
for( i = 1; i < len; i++ )r += nums[i];
for(i=0; l!=r && i<len;){
l+=nums[i];
i++;
r-=nums[i];
}
return i>=len?-1:i;
}
};
```
### puck
```c++
#include <algorithm>
class Solution
{
public:
int pivotIndex(vector<int> &nums)
{
int n{-1};
auto iter = std::find_if(nums.begin(), nums.end(), [&](const int a) {
return ++n, std::accumulate(nums.begin(), nums.begin() + n, 0) ==
std::accumulate(nums.begin() + n + 1, nums.end(), 0);
});
if (iter == nums.end())
{
return -1;
}
return iter - nums.begin();
}
};
```
### 小白
```c++
```
## 5. 最长回文子串@2018/06/25
### jzf
* 第一版 超时
```c++
class Solution {
public:
string longestPalindrome(string s) {
int len =s.size();
string retStr="";
for(size_t i = len; i>0;i--)
{
for(size_t j =0;j+i<=len;j++)
{
string str =s.substr(j,i);
string str2 =str;
reverse(str2.begin(),str2.end());
if(!str.compare(str2))
{
retStr =str;
return retStr;
}
}
}
return retStr;
}
};
```
* 第二版 超时
```c++
class Solution {
public:
string longestPalindrome(string s) {
int len =s.size();
string retStr=s.substr(0,1);
for(size_t i = len; i>1;i--)
{
for(size_t j =0;j+i<=len;j++)
{
string str =s.substr(j,i);
string str2 =str;
reverse(str2.begin(),str2.end());
if(!str.compare(str2))
{
retStr =str;
return retStr;
}
}
}
return retStr;
}
};
```
* 8ms
```c++
class Solution {
public:
int func(string &str, int n)
{
int ret = 1;
size_t k = 1;
for ( ;k <= n && (n + k)<=str.size(); k++)
{
if (str[n - k] == str[n + k + 1])
{
ret ++;
}
else
{
break;
}
}
return ret;
}
int func2(string &str, int n)
{
int ret = 1;
size_t k = 1;
for (; k <= n && (n + k+3) <= str.size(); k++)
{
if (str[n - k] == str[n + k+2])
{
ret++;
}
else
{
break;
}
}
return ret;
}
string longestPalindrome(string s) {
int len = s.size();
int max = 0;
int center = 0;
int f = 0;
if (len<2)
{
return s;
}
if (len == 2)
{
if (s[0] == s[1])
{
return s;
}
else
{
return s.substr(0, 1);
}
}
std::vector<int> vec1;
for (size_t i = 0; i<len - 1; i++)
{
if (s[i] == s[i + 1])
{
vec1.push_back(i);
}
}
for (size_t i = 0; i<vec1.size(); i++)
{
int tmp = func(s, vec1[i]);
if (tmp>max)
{
max = tmp;
center = vec1[i];
f = 1;
}
if (max + i>s.size())
{
break;
}
}
std::vector<int> vec2;
for (size_t i = 0; i<len - 2; i++)
{
if (s[i] == s[i + 2])
{
vec2.push_back(i);
}
}
for (size_t i = 0; i<vec2.size(); i++)
{
int tmp = func2(s, vec2[i]);
if (tmp + 1>max)
{
max = tmp ;
center = vec2[i];
f = 2;
}
if (max + i>s.size())
{
break;
}
}
if (f == 0)
{
return s.substr(0,1);
}
if (f == 1)
{
return s.substr(center - max+1, max * 2);
}
if (f == 2)
{
return s.substr(center -max+1, max * 2 + 1);
}
}
};
```
### 小白
* 第一版 超时
```c++
std::pair<string::const_iterator, string::const_iterator> longestPalindrome(string::const_iterator a, string::const_iterator b)
{
if (a==b || std::mismatch(a, b, make_reverse_iterator(b)).first == b)
return std::make_pair(a, b);
auto str1 = longestPalindrome(a + 1, b), str2 = longestPalindrome(a, b - 1);
return (str1.second - str1.first) > (str2.second - str2.first) ? str1 : str2;
}
string longestPalindrome(const string &s) {
auto pr = longestPalindrome(s.begin(), s.end());
return std::string(pr.first, pr.second);
}
```
```c++
class Solution {
public:
string longestPalindrome(string s) {
auto lr_max = std::make_pair( s.crend(), s.cbegin() );
auto lr_dist_comp = [](decltype(lr_max) a, decltype(lr_max) b)
{return std::distance(a.first.base(), a.second) <
std::distance(b.first.base(), b.second); };
for (auto cent = lr_max; cent != std::make_pair(s.crbegin(), s.cend()); std::distance(cent.first.base(), cent.second) == 0 ? ++cent.second : (--cent.first).base() )
lr_max = std::max(lr_max, std::mismatch((cent.first - 1), s.crend(), cent.second), lr_dist_comp);
return std::string(lr_max.first.base(), lr_max.second);
}
};
```
## 384. 打乱数组@2018/06/26
### jzf
```c++
class Solution {
vector<int> nums;
public:
Solution(vector<int> nums) {
this->nums = nums;
}
/** Resets the array to its original configuration and return it. */
vector<int> reset() {
return nums;
}
/** Returns a random shuffling of the array. */
vector<int> shuffle() {
vector<int> result(nums);
for (int i = 0;i < result.size();i++) {
int pos = rand()%(result.size()-i);
swap(result[i+pos], result[i]);
}
return result;
}
};
```
### 北河
```c++
class Solution {
public:
Solution(vector<int> nums) :m_nums(nums.begin(), nums.end()) {
}
/** Resets the array to its original configuration and return it. */
vector<int> reset() {
return m_nums;
}
/** Returns a random shuffling of the array. */
vector<int> shuffle() {
vector<int> v(m_nums.begin(), m_nums.end());
random_shuffle(v.begin(), v.end());
return v;
}
private:
vector<int> m_nums;
};
```
### 总结
1， 北河的STL确实知道的很多，random_shuffle 惊艳了我
### 知识点
随机数
## 843. 猜猜这个单词@2018/06/26
### 北河
```c++
class Solution {
vector<int> nums;
public:
Solution(vector<int> nums) {
this->nums = nums;
}
/** Resets the array to its original configuration and return it. */
vector<int> reset() {
return nums;
}
/** Returns a random shuffling of the array. */
vector<int> shuffle() {
vector<int> result(nums);
for (int i = 0;i < result.size();i++) {
int pos = rand()%(result.size()-i);
swap(result[i+pos], result[i]);
}
return result;
}
};
```
## 6. Z字形变换@2018/06/26
### jzf
```c++
```
## 180. 连续出现的数字@2018/06/26
### jzf
```sql
select distinct s1.Num as ConsecutiveNums from Logs as s1 ,Logs as s2,Logs as s3
where(( (s1.id= s2.id-1 and s1.id =s3.id-2)
||(s1.id =s2.id+1 and s1.id =s3.id-1)
||(s1.id =s2.id+2 and s1.id =s3.id+1))
and(s1.Num =s2.Num and s1.Num =s3.Num))
```
## 7. 反转整数@2018/06/27
### jzf
* 第一版
```c++
class Solution {
public:
int reverse(int x) {
char str[16]={0};
sprintf(str,"%d",x);
string s =str;
if(s[0]=='-')
{
std::reverse(s.begin()+1,s.end());
}
else
{
std::reverse(s.begin(),s.end());
}
long ret =atol(s.c_str());
if(ret >INT_MAX||ret<INT_MIN)
{
return 0;
}
return ret;
}
};
```
* 第二版 抄 ，我很喜欢这个解法
```c++
class Solution {
public:
int reverse(int x) {
long long res = 0;
while (x != 0) {
res = res * 10 + x % 10;
x /= 10;
}
return (res < INT_MIN || res > INT_MAX) ? 0 : res;
}
};
```
* 第三版
```c++
```
### 小白
* 第一版 出错
```c++
class Solution {
public:
int reverse(int x) {
char str[12], *p = str + sprintf(str, "%d", x);
std::reverse(str + (x < 0), p);
int r = strtol(str, NULL, 10);
return errno == ERANGE ? (errno = 0) : r;
}
};
```
* 第二版
```c++
int reverse(int x) {
auto str = to_string(x);
std::reverse(str.begin(), str.end());
try
{
return str.back() == '-' ? -std::stoi(str): std::stoi(str);
}
catch (...)
{
return 0;
}
}
```
### 总结
1，他这边用 strtol 和spritnf("%ld")出错
原因不知
### 知识点
1，这边atoi strtoi 遇见不合适的字符会跳过，和停止
## 147. 对链表进行插入排序@2018/06/27
### 北河 16ms
```c++
class Solution {
public:
ListNode* insertionSortList(ListNode* head) {
list<int> v;
ListNode *p = head;
while (p) { v.push_back(p->val); p = p->next;}
v.sort();
p = head;
for (list<int>::iterator it = v.begin(); it != v.end(); ++it, p = p->next) {
p->val = *it;
}
return head;
}
};
```
### jzf
```c++
class Solution {
public:
ListNode* insertionSortList(ListNode* head) {
ListNode* node =head;
if(head ==NULL)
{
return head;
}
vector<ListNode*> vec;
while(node != NULL)
{
vec.push_back(node);
node =node->next;
}
sort(vec.begin(),vec.end(),[](ListNode*a,ListNode*b){return a->val <b->val;});
for(auto iter =vec.begin();iter!= vec.end();iter++)
{
if(iter==vec.end()-1)
{
(*iter)->next =NULL;
break;
}
(*iter)->next =*(iter+1);
}
return *vec.begin();
}
};
```
### puck
```c++
class Solution
{
public:
ListNode *insertionSortList(ListNode *head)
{
if (nullptr == head)
{
return nullptr;
}
ListNode *fast{head->next};
ListNode *slow{head};
ListNode *new_head{head};
ListNode *tmp[2]{};
while (nullptr != fast)
{
if (slow->val > fast->val)
{
// delete the node
slow->next = fast->next;
if (new_head->val > fast->val)
{
fast->next = new_head;
new_head = fast;
}
else
{
tmp[0] = new_head;
tmp[1] = new_head->next;
while (nullptr != tmp[1])
{
if (tmp[1]->val > fast->val)
{
fast->next = tmp[1];
tmp[0]->next = fast;
break;
}
tmp[0] = tmp[1];
tmp[1] = tmp[1]->next;
}
}
}
slow = fast;
fast = fast->next;
}
return new_head;
}
};
```
## 828. 独特字符串@2018/06/28
### 北河
```c++
```
### jzf
* 第一版超时
```c++
class Solution {
public:
int uniqueLetterString(string S) {
int sum = 0;
vector<pair<int,string>> vec;
for(size_t i =0;i<S.size();i++)
{
vector<pair<int,string>> vecTmp;
vecTmp =vec;
vec.clear();
string str=S.substr(i,1);
vec.push_back(make_pair(1,str));
sum++;
if(i ==0)
{
continue;
}
for(size_t j=0;j<i;j++)
{
int a =count(vecTmp[j].second.begin(),vecTmp[j].second.end(),S[i]);
int b =0;
if(a==0)
{
b =vecTmp[j].first+1;
vec.push_back(make_pair(b,vecTmp[j].second+str));
}
else
{
if(a==1)
{
b =vecTmp[j].first-1;
}
else
{
b =vecTmp[j].first;
}
vec.push_back(make_pair(b,vecTmp[j].second+str));
}
sum+=b;
}
}
return sum;
}
};
```
* 第二版超时
```c++
class Solution {
public:
int uniqueLetterString(string S) {
int sum = 0;
vector<pair<int,string>> vec;
for(size_t i =0;i<S.size();i++)
{
string str=S.substr(i,1);
vec.push_back(make_pair(1,str));
sum++;
if(i ==0)
{
continue;
}
for(size_t j=0;j<i;j++)
{
int a =count(vec[j].second.begin(),vec[j].second.end(),S[i]);
if(a==0)
{
vec[j].second+=str;
vec[j].first+=1;
sum+= vec[j].first;
}
else
{
if(a ==1)
{
vec[j].first-=1;
}
vec[j].second+=str;
sum+= vec[j].first;
}
}
}
return sum;
}
};
```
### puck
```c++
#include <algorithm>
#include <unordered_map>
class Solution
{
public:
int uniqueLetterString(string S)
{
std::size_t sz = S.size();
int result{};
auto ed = S.end();
bool flg{true};
for (auto iter{ S.begin() }; iter != ed; ++iter)
{
for (auto ite2{ 1 + iter }; flg; ++ite2)
{
if (ite2 == ed)
{
flg = false;
}
result += uniqueNum(string(iter, ite2));
}
flg = true;
}
return result;
}
private:
int uniqueNum(string s)
{
//std::unordered_map<char, int> map;
//for (string::value_type ch : s)
//{
// ++map[ch];
//}
//int num{};
//for (auto &pair : map)
//{
// if (1 == pair.second)
// {
// ++num;
// }
//}
//return num;
short a[128]{};
for (string::value_type ch : s)
{
++a[ch];
}
return std::count(std::begin(a), std::end(a), 1);
}
};
```
## 693. 交替位二进制数@2018/06/29
### jzf
* 第一版 错误
```c++
class Solution {
public:
bool hasAlternatingBits(int n) {
// #define IS_TARGET(x) ((x&0xaaaaaaaa)&&(x&0x55555555))
int x =n;
if( ((x&0xaaaaaaaa)==x)&&((x|0xaaaaaaaa)==0xaaaaaaaa))
{
int x =~n;
if( ((x&0x55555555)==x)&&((x|0x55555555)==0x55555555))
{
return true;
}
else
{
return false;
}
}
if( ((x&0x55555555)==x)&&((x|0x55555555)==0x55555555))
{
int x =~n;
if( ((x&0xaaaaaaaa)==x)&&((x|0xaaaaaaaa)==0xaaaaaaaa))
{
return true;
}
else
{
return false;
}
}
return false;
}
};
```
* 第二版 0s
```c++
class Solution {
public:
bool hasAlternatingBits(int n) {
int tmp=0;
for(size_t i= n&1?0:1;i<31;)
{
tmp |=1<<i;
if(tmp>n)
{
return false;
}
else if(tmp ==n)
{
return true;
}
i +=2;
}
return false;
}
};
```
### 总结
1， 想通过按位与等方式解决问题的时候，对于异或同或之类的转换忘记了，结果绕了很大的弯子。数学还是要学一学的。
2，那个神奇的代码对提升速度真的很有效.
## 63. 不同路径 II@2018/06/30
### 北河 0ms
```c++
static auto XXX = []() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
return 0;
}();
class Solution {
public:
int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
int m = obstacleGrid.size();
int n = obstacleGrid[0].size();
int v[m][n];
memset(v, 0, m * n * sizeof(int));
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
if (obstacleGrid[i][j] != 0) {
continue;
}
if (i == 0 && j != 0) {
v[i][j] = v[i][j - 1];
} else if (j == 0 && i != 0) {
v[i][j] = v[i - 1][j];
} else if ( i != 0 && j != 0) {
v[i][j] += obstacleGrid[i - 1][j] > 0 ? 0 : v[i - 1][j];
v[i][j] += obstacleGrid[i][j - 1] > 0 ? 0 : v[i][j - 1];
} else {
v[i][j] = 1;
}
}
}
return v[m - 1][n - 1];
}
};
```
### jzf
```c++
class Solution {
public:
int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
int dp[101] ={0};
for(int i =0;i<obstacleGrid.size();i++)
{
for(int j =0;j<obstacleGrid[i].size();j++)
{
if(i==0 &&j==0 )
{
dp[j]=obstacleGrid[i][j]?0:1;
}
else if(j==0)
{
dp[j]=obstacleGrid[i][j]?0:dp[j];
}
else
{
dp[j]=obstacleGrid[i][j]?0:dp[j]+dp[j-1];
}
}
}
return dp[(*(obstacleGrid.end()-1)).size()-1];
}
};
```
### 总结
1，先解决的718，我使用了暴力超时了，在摸索的过程中，我画了二叉树的图，和一个数组A和B为列表项的二维表。发现二维表可以很好的表示关系
2，根据二维表的规律，我学习了动态规划，但是还是多次失败了，其原因在于边界处理十分困难，如何处理二维表的边界上的计算公式很头疼。
## 718. 最长重复子数组@2018/07/01
### jzf
* 第一版 超时
```c++
class Solution {
public:
int findLength(vector<int>& A, vector<int>& B) {
int max=0;
for(size_t i =0 ;i<A.size();i++)
{
for(size_t j=0;j<B.size();j++)
{
int tmp =0;
size_t k =i;
size_t x =j;
while(k<A.size()&&x<B.size())
{
if(A[k]!=B[x])
{
break;
}
tmp++;
k++;
x++;
}
if(tmp>max)
{
max =tmp;
}
}
}
return max;
}
};
```
* 第二版 dp
```c++
```
### 北河
```c++
static auto XX = []() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
return 0;
}();
class Solution {
public:
int findLength(vector<int>& A, vector<int>& B) {
vector<int> dp(1001);
int m = 0;
for (int i = A.size() - 1; i >= 0; --i) {
for (size_t j = 0; j < B.size(); ++j) {
if (A[i] == B[j]) {
dp[j] = dp[j + 1] + 1;
if (dp[j] > m) {
m = dp[j];
}
} else {
dp[j] = 0;
}
}
}
return m;
}
};
```
## 406. 根据身高重建队列@2018/07/02 未备份
## 455. 分发饼干@2018/07/03
### jzf
```c++
class Solution {
public:
int findContentChildren(vector<int>& g, vector<int>& s) {
sort(g.begin(),g.end());
sort(s.begin(),s.end());
int j =0;
int i=0;
int t =0;
for(;i<std::min(g.size(),s.size());i++)
{
for(;j<s.size();)
{
if(g[i] <=s[j])
{
t++;
j++;
break;
}
j++;
}
}
return t;
}
};
```
### 北河
## 738.单调递增的数字@2018/07/04
### 北河
```c++
```
### jzf
```c++
class Solution {
public:
int turn2Int(char *p)
{
int ret=0;
while(*p !=0)
{
ret= ret*10+(*p-'0');
p++;
}
return ret;
}
void tostr(int tmp,char* p)
{
int s =1;
int q =tmp;
for(;q>10;q/=10)
{
s*=10;
}
for(;s>0;s/=10)
{
*(p++)=tmp/s+'0';
tmp=tmp%s;
}
}
int monotoneIncreasingDigits(int N) {
// tostring(N);
char str[11]={0};
tostr(N,str);
int t=0;
for(size_t i=0;i<11 &&str[i]!=0;i++)
{
if(str[i] > str[i+1])
{
t =i;
break;
}
}
if(t==0)
{
str[0]-=1;
for(int i= t+1;i<11 &&str[i]!=0;i++)
{
str[i] ='9';
}
return turn2Int(str+t);
}
else if(str[t+1]==0)
{
return N;cout<<12;
}
else
{
int tmp =t;
while(t>0)
{
if(str[t]>str[t-1])
{
str[t]-=1;
for(int i= t+1;i<11 &&str[i]!=0;i++)
{
str[i] ='9';
}
return turn2Int(str);
}
t--;
}
if(t==0)
{
str[0]-=1;
for(int i= t+1;i<11 &&str[i]!=0;i++)
{
str[i] ='9';
}
return turn2Int(str+t);
}
}
return turn2Int(str+t);
}
};
```
## 313. 超级丑数@2018/07/05 无人做
## 20. 有效的括号@2018/07/06
### 羽柔子
```javascript
var isValid = function (s) {
var l = new Array();
return s.split("").every(e => {
switch (e) {
case '(': return l.push(1);
case ')': return l.pop() == 1;
case '{': return l.push(2);
case '}': return l.pop() == 2;
case '[': return l.push(3);
case ']': return l.pop() == 3;
};
}) ? !l.length : false;
};
```
### jzf
* 第一版错误
```c++
class Solution {
public:
bool isClosed(char c, char dst)
{
switch (c)
{
case '[':
return dst == ']';
case '{':
return dst == '}';
case '(':
return dst == ')';
default:
return false;
}
}
bool isOpen(char c)
{
switch (c)
{
case '[':
case '{':
case '(':
return true;
default:
return false;
}
}
bool check(size_t &i, string &s)
{
size_t j = i + 1;
bool ret=false;
for (; j<s.size(); j++)
{
if (isClosed(s[i], s[j]) && ((j - i) & 1) == 1)
{
ret =true;
for (size_t k = (j - i-1)/2; k>0; k--)
{
if (!isClosed(s[i + k], s[j - k]))
{
return false;
}
}
break;
}
}
i = j;
return ret;
}
bool isValid(string s) {
// '[''{''('')''}'']'
for (size_t i = 0; i<s.size(); i++)
{
if (isOpen(s[i]) && (i & 1) == 0)
{
if (!check(i, s))
{
return false;
}
}
else
{
return false;
}
}
return true;
}
};
```
* 第二版
```c++
class Solution {
public:
bool isClosed(char c, char dst)
{
switch (c)
{
case '[':
return dst == ']';
case '{':
return dst == '}';
case '(':
return dst == ')';
default:
return false;
}
}
bool isOpen(char c)
{
switch (c)
{
case '[':
case '{':
case '(':
return true;
default:
return false;
}
}
bool isValid(string s) {
// '[''{''('')''}'']'
bool ret =false;
int tmp =0;
while(s.size()!=tmp)
{
tmp =s.size();
for(int i=0;i<tmp-1;i++)
{
if(isClosed(s[i],s[i+1]))
{
s.erase(i,2);
break;
}
}
}
return tmp==0?true:false;
}
};
```
### 三浪
```c
typedef struct tagStack
{
char * p;
int iPos;
}Stack;
void BulidStack(Stack *pStack, int size)
{
pStack->p = (char *)malloc(size * sizeof(char));
memset(pStack->p, 0, size);
pStack->iPos= 0;
}
void DestroyStack(Stack *pStack)
{
free(pStack->p);
}
int Push(Stack *pStack, char ch)
{
if (pStack->iPos >= 0)
{
*(pStack->p + pStack->iPos) = ch;
++(pStack->iPos);
return 0;
}
return -1;
}
int Pop(Stack *pStack)
{
--(pStack->iPos);
if (pStack->iPos >= 0)
{
*(pStack->p + pStack->iPos) = '\0';
return 0;
}
return -1;
}
char GetPairChar(char ch)
{
switch (ch)
{
case ')':
return '(';
case '}':
return '{';
case ']':
return '[';
default:
return '\0';
}
}
bool IsPush(char ch)
{
if (ch == '(' || ch == '{' || ch == '[')
{
return true;
}
return false;
}
bool isValid(char *s)
{
if ('\0' == *s)
{
return true;
}
int n = 0;
char chPre = *s;
if (!IsPush(chPre))
{
return false;
}
Stack myStack;
BulidStack(&myStack, strlen(s) + 1);
while (*s != '\0')
{
char chCur = *s;
if (IsPush(chCur))
{
if (0 != Push(&myStack, chCur))
{
return false;
}
}
else
{
if ((myStack.iPos >= 1) &&
(myStack.p[myStack.iPos - 1] == GetPairChar(chCur)))
{
if (0 != Pop(&myStack))
{
return false;
}
}
else
{
if (0 != Push(&myStack, chCur))
{
return false;
}
}
}
chPre = *s;
++s;
}
if (0 == myStack.iPos)
{
DestroyStack(&myStack);
return true;
}
else
{
DestroyStack(&myStack);
return false;
}
}
```
### 总结
1，我在做这道题的时候，出现了许多次的分析失误，疏忽了一些情形。
2，发现 s.size()的返回类型是size_t ，遇到了一个比较悲惨的越界错误。
size_t是unsigned int类型的
当 for(int i=0; i<tmp -1;i++)中的tmp = 0时，就出现了大bug;
Reference in New Issue View Git Blame Copy Permalink