在一個由 0 和 1 組成的二維矩陣內，找到只包含 1 的最大正方形，並返回其面積。
示例:
輸入:
1 0 1 0 0
1 0 1 1 1
1 1 1 1 1
1 0 0 1 0
輸出: 4
class Solution {//一維 動態規劃
public:
int maximalSquare(vector<vector<char>>& matrix) {
int mSize=matrix.size();
if(mSize==0)return 0;
int nSize=matrix[0].size();
if(nSize==0)return 0;
vector<int>dp(nSize+1,0);//邊長
int temp=dp[0],res=0;
for(int i=0;i<mSize;++i)
for(int j=1;j<=nSize;++j)
if(matrix[i][j-1]=='1'){
swap(temp,dp[j]);
dp[j]=min(dp[j],min(dp[j-1],temp))+1;
res=max(res,dp[j]);
}
else{
temp=dp[j];
dp[j]=0;
}
return res*res;
}
};
運用你所掌握的數據結構，設計和實現一個 LRU (最近最少使用) 緩存機制。它應該支持以下操作： 獲取數據 get 和 寫入數據 put 。
獲取數據 get(key) - 如果密鑰 (key) 存在於緩存中，則獲取密鑰的值（總是正數），否則返回 -1。
寫入數據 put(key, value) - 如果密鑰已經存在，則變更其數據值；如果密鑰不存在，則插入該組「密鑰/數據值」。當緩存容量達到上限時，它應該在寫入新數據之前刪除最久未使用的數據值，從而爲新的數據值留出空間。
進階:
你是否可以在 O(1) 時間複雜度內完成這兩種操作？
示例:
LRUCache cache = new LRUCache( 2 /* 緩存容量 */ );
cache.put(1, 1);
cache.put(2, 2);
cache.get(1); // 返回 1
cache.put(3, 3); // 該操作會使得密鑰 2 作廢
cache.get(2); // 返回 -1 (未找到)
cache.put(4, 4); // 該操作會使得密鑰 1 作廢
cache.get(1); // 返回 -1 (未找到)
cache.get(3); // 返回 3
cache.get(4); // 返回 4
class LRUCache {
int capacity;
typedef list<pair<int,int>>::iterator it;//容器pop/push不會影響迭代器的值，除非把迭代器對應的節點給pop掉
unordered_map<int,it>m;//key map映射到list *m[key]
list<pair<int,int>> li;//pair<key,value>爲了可以list映射到map，即m.erase(list.back().first)
public:
LRUCache(int capacity) {
this->capacity=capacity;
}
int get(int key) {
if(m.count(key)==0)return -1;
pair<int,int> temp=*m[key];
li.erase(m[key]);
li.push_front(temp);
m[key]=li.begin();
return temp.second;
}
void put(int key, int value) {
if(m.count(key)==0){
li.push_front(make_pair(key,value));
}
else{
pair<int,int> temp=*m[key];
temp.second=value;
li.erase(m[key]);
li.push_front(temp);
}
m[key]=li.begin();
if(m.size()>capacity){
m.erase(li.back().first);
li.pop_back();
}
}
};
/**
* Your LRUCache object will be instantiated and called as such:
* LRUCache* obj = new LRUCache(capacity);
* int param_1 = obj->get(key);
* obj->put(key,value);
*/
給你一個長度爲 n 的整數數組 nums，其中 n > 1，返回輸出數組 output ，其中 output[i] 等於 nums 中除 nums[i] 之外其餘各元素的乘積。
示例:
輸入: [1,2,3,4]
輸出: [24,12,8,6]
提示：題目數據保證數組之中任意元素的全部前綴元素和後綴（甚至是整個數組）的乘積都在 32 位整數範圍內。
說明: 請不要使用除法，且在 O(n) 時間複雜度內完成此題。
進階：
你可以在常數空間複雜度內完成這個題目嗎？（ 出於對空間複雜度分析的目的，輸出數組不被視爲額外空間。）
class Solution {
public:
vector<int> productExceptSelf(vector<int>& nums) {
int nSize=nums.size();
vector<int>left(nSize);
left[0]=nums[0];
for(int i=1;i<nSize-1;++i)
left[i]=left[i-1]*nums[i];
int right=1;
for(int i=nSize-1;i>0;--i){
left[i]=left[i-1]*right;
right*=nums[i];
}
left[0]=right;
return left;
}
};
給定一個整數數組，其中第 i 個元素代表了第 i 天的股票價格 。
設計一個算法計算出最大利潤。在滿足以下約束條件下，你可以儘可能地完成更多的交易（多次買賣一支股票）:
你不能同時參與多筆交易（你必須在再次購買前出售掉之前的股票）。
賣出股票後，你無法在第二天買入股票 (即冷凍期爲 1 天)。
示例:
輸入: [1,2,3,0,2]
輸出: 3
解釋: 對應的交易狀態爲: [買入, 賣出, 冷凍期, 買入, 賣出]
class Solution {//一維 動態規劃
public:
int maxProfit(vector<int>& prices) {
int pSize=prices.size();
if(pSize<=1)return 0;
vector<vector<int>>dp(pSize,vector<int>(2,0));//0不持有股票
dp[0][0]=0;
dp[0][1]=-prices[0];
dp[1][0]=max(dp[0][0],dp[0][1]+prices[1]);
dp[1][1]=max(dp[0][1],dp[0][0]-prices[1]);
for(int i=2;i<pSize;++i){
dp[i][0]=max(dp[i-1][0],dp[i-1][1]+prices[i]);
dp[i][1]=max(dp[i-1][1],dp[i-2][0]-prices[i]);
}
return dp[pSize-1][0];
}
};
class Solution {
public:
int maxProfit(vector<int>& prices) {
int pSize=prices.size();
if(pSize<=1)return 0;
int dp00=0,dp01=-prices[0];
int dp10=max(dp00,dp01+prices[1]);
int dp11=max(dp01,dp00-prices[1]);
for(int i=2;i<pSize;++i){
dp01=dp10;//dp01當作temp，保存上一個dp10,最後賦值給dp00
dp10=max(dp10,dp11+prices[i]);
dp11=max(dp11,dp00-prices[i]);
dp00=dp01;//
}
return dp10;
}
};
給定一個非空的整數數組，返回其中出現頻率前 k 高的元素。
示例 1:
輸入: nums = [1,1,1,2,2,3], k = 2
輸出: [1,2]
示例 2:
輸入: nums = [1], k = 1
輸出: [1]
說明：
你可以假設給定的 k 總是合理的，且 1 ≤ k ≤ 數組中不相同的元素的個數。
你的算法的時間複雜度必須優於 O(n log n) , n 是數組的大小。
class Solution {
public:
struct ValKey{
int val;
int key;
ValKey():val(0),key(0){};
ValKey(int v,int k):val(v),key(k){};
bool operator >(const ValKey &vk)const{
//if(val==vk.val)return key>vk.key;
return val>vk.val;
};
bool operator <(const ValKey &vk)const{
//if(val==vk.val)return key>vk.key;
return val<vk.val;
};
};
vector<int> topKFrequent(vector<int>& nums, int k) {
unordered_map<int,int> m;
priority_queue<ValKey,vector<ValKey>,greater<ValKey>>q;
vector<int>res;
for(auto i:nums)
++m[i];
for(auto mi:m){
if(q.size()<k)
q.push(ValKey(mi.second,mi.first));
else if(q.size()==k&&mi.second>q.top().val)
q.pop(),q.push(ValKey(mi.second,mi.first));
}
while(q.size()){
res.push_back(q.top().key);
q.pop();
}
return res;
}
};