class Solution {
public:
vector<string> readBinaryWatch(int num) {
vector<string>res;
for(int i = 0; i < 12; i ++)
for(int j = 0; j < 60; j ++)
if(count(i) + count(j) == num)
res.push_back(to_string(i) + ":" +
(j < 10 ? "0" + to_string(j) : to_string(j)));
return res;
}
int count(int n) //计算二进制中有多少个1
{
int res = 0;
while(n != 0)
{
n = n & (n - 1);
res ++;
}
return res;
}
};
class Solution {
public:
string removeKdigits(string num, int k) {
string res;
for(auto c : num)
{
while(res.size() && res.back() > c && k)
{
res.pop_back();
k--;
}
res += c;
}
while(k --) res.pop_back();
int i = 0;
while(i < res.size() && res[i] == '0') i ++;
if(i == res.size()) return "0";
return res.substr(i);
}
};
class Solution {
public:
bool canCross(vector<int>& stones) {
map<int, set<int>>map;
for(int i = 0; i < stones.size(); i ++)
map[stones[i]] = {};
map[0] = {0};
for(int i = 0; i < stones.size(); i ++)
for(int x : map[stones[i]])
for(int step = x - 1; step <= x + 1; step ++)
if(step > 0 && map.count(stones[i] + step))
map[stones[i] + step].insert(step);
return map[stones[stones.size() - 1]].size() > 0;
}
};
class Solution {
public:
bool canCross(vector<int>& stones) {
int n = stones.size();
vector<vector<bool>> dp(n, vector<bool>(n + 1, false));
dp[0][0] = true;
for(int i = 1; i < n; i ++)
for(int j = 0; j < i; j ++)
{
int k = stones[i] - stones[j]; //间隔
if(k < n + 1 && k <= stones[j] + 1)
{
dp[i][k] = dp[j][k - 1] || dp[j][k] || dp[j][k + 1];
if(i == n - 1 && dp[i][k] == true) return true;
}
}
return false;
}
};
/**
* 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 res = 0;
int sumOfLeftLeaves(TreeNode* root) {
dfs(root);
return res;
}
void dfs(TreeNode* root)
{
if(!root) return;
dfs(root->left);
dfs(root->right);
if(root->left && !root->left->left && !root->left->right) res += root->left->val;
}
};
/**
* 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 sumOfLeftLeaves(TreeNode* root) {
int cur = 0;
if(!root) return 0;
if(root->left && !root->left->left && !root->left->right)
cur += root->left->val;
return cur + sumOfLeftLeaves(root->left) + sumOfLeftLeaves(root->right);
}
};
class Solution {
public:
string toHex(int num) {
if(num == 0) return "0";
string hex = "0123456789abcdef", res = "";
while(num && res.size() < 8)
{
res = hex[num & 0xf] + res;
num >>= 4;
}
return res;
}
};
class Solution {
public:
vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
auto cmp = [](const vector<int>&a, const vector<int>&b)
{
return a[0] > b[0] || a[0] == b[0] && a[1] < b[1];
};
sort(people.begin(), people.end(), cmp);
vector<vector<int>> res;
for(auto p : people) res.insert(res.begin() + p[1], p);
return res;
}
};
class Solution {
public:
int trapRainWater(vector<vector<int>>& heightMap) {
if(heightMap.empty()) return 0;
int n = heightMap.size(), m = heightMap[0].size(), cur_max = INT_MIN, res = 0;
if(n <= 2 || m <= 2) return 0;
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>>heap;//小根堆
for(int i = 0; i < n; i ++) //左右边界
{
heap.push(make_pair(heightMap[i][0], i * m));//记录对应的高度和位置
heap.push(make_pair(heightMap[i][m - 1], i * m + m - 1));
}
for(int j = 1; j < m - 1; j ++) //上下边界
{
heap.push(make_pair(heightMap[0][j], j));
heap.push(make_pair(heightMap[n - 1][j], (n - 1) * m + j));
}
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1}, visit[n][m] = {};
while(!heap.empty())
{
auto t = heap.top();
heap.pop();
cur_max = max(cur_max, t.first);
int r = t.second / m, c = t.second % m;
for(int i = 0; i < 4; i ++)
{
int x = r + dx[i], y = c + dy[i];
if(x > 0 && x < n - 1 && y > 0 && y < m - 1 && !visit[x][y])
{
visit[x][y] = 1;
if(heightMap[x][y] < cur_max)
res += cur_max - heightMap[x][y];
heap.push(make_pair(heightMap[x][y], x * m + y));
}
}
}
return res;
}
};
class Solution {
public:
int longestPalindrome(string s) {
int cnts[60] = {0};
for(int i = 0; i < s.size(); i ++)
cnts[s[i] - 'A'] ++;
int res = 0;
for(auto cnt : cnts)
res += cnt / 2 * 2;
if(res < s.size())
res ++;
return res;
}
};
class Solution {
public:
int splitArray(vector<int>& nums, int m) {
int n = nums.size();
vector<vector<long>> f(n + 1, vector<long>(m + 1, INT_MAX));//f[i][j]表示前i个分成j份的最大和
vector<long> s(n + 1, 0); //前缀和
f[0][0] = 0;
for(int i = 0; i < n; i ++)
s[i + 1] = s[i] + nums[i];
for(int i = 1; i <= n; i ++)
for(int j = 1; j <= m; j ++)
for(int k = 0; k < i; k ++)
f[i][j] = min(f[i][j], max(f[k][j - 1], s[i] - s[k]));
return f[n][m];
}
};
class Solution {
public:
vector<string> fizzBuzz(int n) {
vector<string> res;
for(int i = 1; i <= n; i ++)
{
if(i % 3 == 0 && i % 5 == 0) res.push_back("FizzBuzz");
else if(i % 3 == 0) res.push_back("Fizz");
else if(i % 5 == 0) res.push_back("Buzz");
else res.push_back(to_string(i));
}
return res;
}
};
class Solution {
public:
int numberOfArithmeticSlices(vector<int>& A) {
if(A.size() < 3) return 0;
int res = 0, dp = 0, d1 = A[1] - A[0];
for(int i = 2; i < A.size(); i ++)
{
int d2 = A[i] - A[i - 1];
if(d1 == d2)
res += (++dp); //以A[i]为结尾的等差数列长度
else dp = 0;
d1 = d2;
}
return res;
}
};