注：本页有大量的锁定题，由于本人非常穷，所以本页的题非常少。
268. Missing Number
class Solution {
public:
int missingNumber(vector<int>& nums) {
int k=INT_MAX;
for(int i=0;i<nums.size();i++)
{
if(nums[i]==0)
continue;
nums[abs(nums[i])-1]=-abs(nums[abs(nums[i])-1]);
if(nums[abs(nums[i])-1]==0)
k=abs(nums[i])-1;
}
if(k!=INT_MAX)
nums[k]=-1;
for(int i=0;i<nums.size();i++)
if(nums[i]>=0)
return i+1;
return 0;
}
};注：简单题，如果数字存在的话则对应下标的那个数标为负数，特殊情况是0，需要特殊考虑。faster than 51.79%。
273. Integer to English Words
注：困难题，。faster than XX%。
274. H-Index/275. H-Index II
class Solution {
public:
int hIndex(vector<int>& citations) {
if(citations.size()==0)
return 0;
sort(citations.begin(),citations.end());
int max=INT_MIN,p=1;
for(int i=citations.size()-1;i>=0;i--)
{
if(citations[i]>=p)
max=p>=max?p:max;
p++;
}
return max==INT_MIN?0:max;
}
};注：中等题，可以用二分法解决，当时只想到排序，没有想到还可以继续简化时间。faster than 25.58%。
278. First Bad Version
// Forward declaration of isBadVersion API.
bool isBadVersion(int version);
class Solution {
public:
int firstBadVersion(int n) {
long long low=1,high=n,mid;
while(low<=high)
{
mid=(low+high)/2;
if(!isBadVersion(mid))
low=mid+1;
else high=mid-1;
}
return low;
}
};注：简单题，简单的考察二分法，这里需要使用长整型，因为测试用例太大相加会越界。faster than 100%。
279. Perfect Squares
class Solution {
public:
int numSquares(int n) {
vector<int> a(n+1,INT_MAX);
a[0]=1;
for(int i=1;i<=n;i++)
{
int k=int(sqrt(i));
if(k*k==i)
a[i]=1;
else
for(int j=1;j<=i/2;j++)
a[i]=min(a[i-j]+a[j],a[i]);
}
return a[n];
}
};注：中等题，动态规划题。faster than 2.06%。
282. Expression Add Operators
注：困难题，如果数字存在的话则对应下标的那个数标为负数，特殊情况是0，需要特殊考虑。faster than 51.79%。
283. Move Zeroes
class Solution {
public:
void moveZeroes(vector<int>& nums) {
int k=0;
for(int i=0;i<nums.size();i++)
if(nums[i]==0)
{
nums.erase(nums.begin()+i);
i--;
k++;
}
while(k--)
nums.push_back(0);
}
};注：简单题，双指针法是最优解，我直接删除添加了。faster than 93.87%。
284. Peeking Iterator
注：中等题，如果数字存在的话则对应下标的那个数标为负数，特殊情况是0，需要特殊考虑。faster than 51.79%。
287. Find the Duplicate Number
注：中等题，如果数字存在的话则对应下标的那个数标为负数，特殊情况是0，需要特殊考虑。faster than 51.79%。
289. Game of Life
注：中等题，如果数字存在的话则对应下标的那个数标为负数，特殊情况是0，需要特殊考虑。faster than 51.79%。
290. Word Pattern
class Solution {
public:
bool wordPattern(string pattern, string str) {
unordered_map<char,int> m1;
unordered_map<string,int> m2;
istringstream in(str);
int i = 0;
for(string word;in>>word;++i){
if(m1.find(pattern[i])!=m1.end()||m2.find(word)!=m2.end()){
if(m1[pattern[i]]!=m2[word]){
return false;
}
}else{
m1[pattern[i]] = m2[word] = i+1;
}
}
return i==pattern.size();
}
};注：简单题，用俩map即可求解，代码懒得写，抄来的。faster than 100.00%。
292. Nim Game
class Solution {
public:
bool canWinNim(int n) {
if (n % 4 == 0)
return false;
return true;
}
};注：简单题，不解释，浪费时间。faster than 100.00%。
295. Find Median from Data Stream
https://blog.csdn.net/qq508618087/article/details/51014047
https://blog.csdn.net/u014673347/article/details/50633866
注：困难题，需要用到堆，同时维护大顶堆和小顶堆。faster than XX%。
297. Serialize and Deserialize Binary Tree
注：困难题，需要用到堆，同时维护大顶堆和小顶堆。faster than XX%。
299. Bulls and Cows
class Solution {
public:
string getHint(string secret, string guess) {
int a=0,b=0;
map<char,int> c;
string s;
for(char a:secret)
c[a]++;
for(int i=0;i<guess.size();i++)
if(secret[i]==guess[i])
{
a++;
c[secret[i]]--;
}
for(int i=0;i<guess.size();i++)
if(secret[i]!=guess[i]&&c.find(guess[i])!=c.end()&&c[guess[i]]>0)
{
b++;
c[guess[i]]--;
}
s+=to_string(a)+'A';
s+=to_string(b)+'B';
return s;
}
};注：中等题，两编遍历就好了。faster than 58.73%。
300. Longest Increasing Subsequence
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
if(nums.size()==0)
return 0;
vector<int> a(nums.size(),1);
int k=1;
for(int i=nums.size()-2;i>=0;i--)
{
for(int j=i+1;j<nums.size();j++)
{
if(nums[j]>nums[i])
{
a[i]=max(a[i],a[j]+1);
k=max(a[i],k);
}
}
}
return k;
}
};注：中等题，我想到的是动态规划方法，还有一更变态的动态规划+二分搜索，在内循环直接找第一个大于nums[i]的数，丧心病狂。faster than 58.73%。
306. Additive Number
注：中等题，两编遍历就好了。faster than 58.73%。
312. Burst Balloons
注：中等题，两编遍历就好了。faster than 58.73%。
313. Super Ugly Number
注：中等题，两编遍历就好了。faster than 58.73%。
315. Count of Smaller Numbers After Self
class Solution {
public:
vector<int> countSmaller(vector<int>& nums) {
vector<int> counts(nums.size());
vector<int> trans;
if (nums.size() == 0)
return counts;
trans.push_back(nums[nums.size() - 1]);
for (int i = nums.size() - 2; i >= 0; i--) {
// 这里二分我们用STL里的就好了
auto it = lower_bound(trans.begin(), trans.end(), nums[i]);
counts[i] = it - trans.begin();
trans.insert(it, nums[i]);
}
return counts;
}
};
注：困难题，用二分查找法。faster than XX%。
316. Remove Duplicate Letters
注：困难题，如果数字存在的话则对应下标的那个数标为负数，特殊情况是0，需要特殊考虑。faster than 51.79%。
Rrui的Leetcode算法刷题笔记（七）链接如下：
https://blog.csdn.net/Rrui7739/article/details/84073153
279. 完全平方数
class Solution {
public:
int numSquares(int n) {
vector<int> dp(n + 1, INT_MAX);
for(int i = 1; i * i <= n; i++)
dp[i * i] = 1;
for(int i = 1; i <= n; i++)
for(int j = 1; j * j < i; j++)
dp[i] = min(dp[i], dp[i - j * j] + 1);
return dp[n];
}
};287. 寻找重复数
class Solution {
public:
int findDuplicate(vector<int>& nums) {
if(nums.empty())
return 0;
int low = 1, high = nums.size()-1;
while(low<high)
{
int mid = (low+high)/2;//找到（1，n）的中间的数
int count = 0;
for(int i=0;i<nums.size();++i)
{
if(nums[i] <= mid)//找到数组中比中间的数小的所有数的个数
count++;
}
if(count <= mid)//如果个数小于中间的数，则重复的数在数组右边，反之在左边
low = mid+1;
else
high = mid;
}
return low;
}
};307. 区域和检索 - 数组可修改
class NumArray {
public:
vector<int> a;
NumArray(vector<int> nums) {
a=nums;
}
void update(int i, int val) {
a[i]=val;
}
int sumRange(int i, int j) {
int sum=0;
for(int k=i;k<=j;k++)
sum+=a[k];
return sum;
}
};
/**
* Your NumArray object will be instantiated and called as such:
* NumArray obj = new NumArray(nums);
* obj.update(i,val);
* int param_2 = obj.sumRange(i,j);
*/