513. Find Bottom Left Tree Value
int findBottomLeftValue(TreeNode* root) {
if (root== nullptr){
return 0;
}
queue<TreeNode*> queueTotal;
queue<TreeNode*> queueCurr;
queueTotal.push(root);
int val=-1;
while (!queueTotal.empty()){
val=queueTotal.front()->val;
while (!queueTotal.empty()){
TreeNode* node=queueTotal.front();
queueTotal.pop();
if (node->left){
queueCurr.push(node->left);
}
if (node->right){
queueCurr.push(node->right);
}
}
swap(queueCurr,queueTotal);
}
return val;
}
515. Find Largest Value in Each Tree Row
层次遍历
vector<int> largestValues(TreeNode* root) {
vector<int> ans;
if (root== nullptr){
return ans;
}
queue<TreeNode*> nodes;
queue<TreeNode*> curr;
nodes.push(root);
while (!nodes.empty()){
int largest=numeric_limits<int>::min();
while (!nodes.empty()){
TreeNode* node=nodes.front();
nodes.pop();
largest= max(node->val,largest);
if (node->left){
curr.push(node->left);
}
if (node->right){
curr.push(node->right);
}
}
ans.push_back(largest);
nodes.swap(curr);
}
return ans;
}
516. Longest Palindromic Subsequence
int cache[1002][1002];
class Solution {
public:
int longestPalindromeSubseq(string s) {
string origin(s);
std::reverse(s.begin(), s.end());
for (int i = 1; i <= origin.size(); ++i) {
for (int j = 1; j <= s.size(); ++j) {
if (origin[i - 1] == s[j - 1]) {
cache[i][j] = cache[i - 1][j - 1] + 1;
} else {
cache[i][j] = max(cache[i - 1][j - 1], max(cache[i - 1][j], cache[i][j - 1]));
}
}
}
return cache[s.size()][s.size()];
}
};
520. Detect Capital
class Solution {
public boolean detectCapitalUse(String word) {
if (word.length()<2){
return true;
}
if (Character.isLowerCase(word.charAt(0))){
return detectAllLowercase(word.substring(1));
}else {
return detectAllLowercase(word.substring(1))||detectAllCapital(word.substring(1));
}
}
public boolean detectAllCapital(String word){
for (int i=0;i<word.length();i++){
if (Character.isLowerCase(word.charAt(i))){
return false;
}
}
return true;
}
public boolean detectAllLowercase(String word){
for (int i=0;i<word.length();i++){
if (Character.isUpperCase(word.charAt(i))){
return false;
}
}
return true;
}
}
521. Longest Uncommon Subsequence I
非常简单
public int findLUSlength(String a, String b) {
if (a.length()!=b.length()){
return Math.max(a.length(), b.length());
}
else if (a.equals(b)){
return -1;
}
return a.length();
}
523. Continuous Subarray Sum
bool checkSubarraySum(vector<int>& nums, int k) {
unordered_map<int,int> prefixModulo;
prefixModulo[0]=-1; // 非常重要 考虑边界情况 [23,2,4,6,6] 7
int currSum=0;
for (int i=0;i<nums.size();i++) {
currSum+=nums[i];
currSum%=k;
if (!prefixModulo.count(currSum)){
prefixModulo[currSum]=i;
}
else if (i-prefixModulo[currSum]>1){
return true;
}
}
return false;
}
524. Longest Word in Dictionary through Deleting
贪心？
string findLongestWord(string s, vector<string> &dictionary) {
std::sort(dictionary.begin(), dictionary.end(), [](string s1, string s2) {
if (s1.size() != s2.size()) {
return s1.size() > s2.size();
}
return strcmp(s1.c_str(), s2.c_str()) < 0;
});
for (string ss: dictionary) {
int s_idx = 0;
int ss_idx = 0;
while (s_idx < s.size()) {
if (s[s_idx] == ss[ss_idx]) {
ss_idx++;
if (ss_idx == ss.size()) {
return ss;
}
}
s_idx++;
}
}
return "";
}
525. Contiguous Array
int findMaxLength(vector<int>& nums) {
int curr_zeros=0;
int curr_ones=0;
unordered_map<int,int> subs;
subs[0]=-1;
int max_len=0;
for (int i = 0; i < nums.size(); ++i) {
if (nums[i]==0){
curr_zeros++;
}
else{
curr_ones++;
}
int curr_sub=curr_zeros-curr_ones;
if (!subs.count(curr_sub)){
subs[curr_sub]=i;
}
else{
max_len=max(max_len,i-subs[curr_sub]);
}
}
return max_len;
}
*526. Beautiful Arrangement
Backtrack
class Solution {
List<Integer>[] match;
boolean[] visited;
int num=0;
int target;
public int countArrangement(int n) {
visited=new boolean[n+1];
match=new ArrayList[n+1];
target=n;
for (int i=0;i<=n;i++){
match[i]=new ArrayList<>();
}
for (int i=1;i<=n;i++){
for (int j=1;j<=n;j++){
if (i%j==0||j % i == 0){
match[i].add(j);
}
}
}
backtrack(1);
return num;
}
public void backtrack(int index) {
if (index==target+1){
num++;
return;
}
for (int val:match[index]){
if (!visited[val]){
visited[val]=true;
backtrack(index+1);
visited[val]=false;
}
}
}
}
529. Minesweeper
class Solution {
public:
int dir[8][2] = {-1, -1, 0, -1, 1, -1, 1, 0, 1, 1, 0, 1, -1, 1, -1, 0};
int Near_Boom(vector<vector<char>>& board, int x, int y){
int boom = 0;
for(int i = 0; i < 8; i++){
int nextx = x + dir[i][0];
int nexty = y + dir[i][1];
if(nextx < 0 || nexty < 0 || nextx >= board.size() || nexty >= board[0].size())
continue;
if(board[nextx][nexty] == 'M'){
boom++;
}
}
return boom;
}
void BFS(vector<vector<char>>& board, int x, int y){
queue<pair<int, int>> que;
que.push(pair<int, int>(x, y));
//定义一个队列，存放周围无地雷（即B）的情况， 队列为空则说明已经被排查完毕
//传进来的位置必然是周围无地雷，加入队列
while(!que.empty()){
int x = que.front().first;
int y = que.front().second;
que.pop();
//获取队头元素的坐标，下面来判断其周围是有地雷还是无地雷
for(int i = 0; i < 8; i++){
int nextx = x + dir[i][0];
int nexty = y + dir[i][1];
if(nextx < 0 || nexty < 0 || nextx >= board.size() || nexty >= board[0].size())
continue;
// 坐标超出有效范围，继续下一轮循环
if(board[nextx][nexty] == 'B') continue;
// 已经处理过的位置，跳过，防止重复加入队列造成死循环
int tot = Near_Boom(board, nextx, nexty);
// 获得当前处理位置的周围地雷数目
if(tot != 0) board[nextx][nexty] = tot + '0';
// 周围地雷不是0， 相当于case2， 修改值（注意是char类型）
else{
board[nextx][nexty] = 'B';
que.push(pair<int, int>(nextx, nexty));
}
// 相当于case3， 周围无地雷， 更改为B， 加入队列
}
}
}
vector<vector<char>> updateBoard(vector<vector<char>>& board, vector<int>& click) {
int x = click[0];
int y = click[1];
char tag=board[click[0]][click[1]];
if (tag=='M'){
board[click[0]][click[1]]='X';
return board;
}
//case1 如果点击的是地雷，修改为X返回即可
int res = Near_Boom(board, x, y);
//定义Near_Boom函数，用于求得点击位置周围的地雷数目
if(res){
board[x][y] = res + '0';
return board;
}
//case2 点击位置周围有地雷， 修改为地雷数量返回即可
board[x][y] = 'B';
BFS(board, x, y);
//case3 点击位置周围无地雷，修改为B，然后广度优先搜索，找出它周围的位置是什么case
return board;
}
};
530. Minimum Absolute Difference in BST
BST首先想中序遍历
class Solution {
public:
int prev=-100000;
int minDiff=numeric_limits<int>::max();
int getMinimumDifference(TreeNode* root) {
inorderTraversal(root);
return minDiff;
}
void inorderTraversal(TreeNode* node){
if (node == nullptr){
return;
}
inorderTraversal(node->left);
minDiff=min(abs(prev-node->val), minDiff);
prev=node->val;
inorderTraversal(node->right);
}
};
532. K-diff Pairs in an Array
class Solution {
public:
int findPairs(vector<int>& nums, int k) {
if (k==0){
return zeroDiff(nums);
}
int ans=0;
unordered_map<int,int> target;
unordered_set<int> stored;
for (int num : nums) {
if (stored.count(num)){
continue;
}
stored.insert(num);
if (target.count(num)){
ans+=target[num];
}
target[num+k]++;
target[num-k]++;
}
return ans;
}
int zeroDiff(vector<int>& nums){
int ans=0;
unordered_map<int,int> stored;
for (int num:nums) {
stored[num]++;
if (stored[num]==2){
ans++;
}
}
return ans;
}
};
更严谨的
class Solution {
public int findPairs(int[] nums, int k) {
Map<Integer, Integer> map = new HashMap<>();
for (int i : nums) map.put(i, map.getOrDefault(i, 0) + 1);
int ans = 0;
for (int i : nums) {
if (map.get(i) == 0) continue;
if (k == 0) {
if (map.get(i) > 1) ans++;
} else {
int a = i - k, b = i + k;
if (map.getOrDefault(a, 0) > 0) ans++;
if (map.getOrDefault(b, 0) > 0) ans++;
}
map.put(i, 0);
}
return ans;
}
}
537. Complex Number Multiplication
class Solution {
public static final HashSet<Character> others = initSet();
public static HashSet<Character> initSet() {
HashSet<Character> others = new HashSet<>();
others.add('+');
others.add('-');
others.add('i');
return others;
}
public String complexNumberMultiply(String num1, String num2) {
int[] numerical_num1 = departNumber(num1);
int[] numerical_num2= departNumber(num2);
int real_res=numerical_num1[0]*numerical_num2[0]-numerical_num1[1]*numerical_num2[1];
int imaginary_res=numerical_num1[0]*numerical_num2[1]+numerical_num1[1]*numerical_num2[0];
return ""+real_res+"+"+imaginary_res+"i";
}
public int[] departNumber(String num) {
String[] departedNum=num.split("\\+");
int real_num=0;
int imaginary_num=0;
for (String s:departedNum){
int curr_tag=1;
for (int i=0;i<s.length();i++){
if (s.charAt(i)=='-'){
curr_tag=-1;
}
else if (s.charAt(i)=='i'){
imaginary_num= curr_tag;
return new int[]{real_num,imaginary_num};
}
else{
int j=i;
while (j<s.length()&&!others.contains(s.charAt(j))){
j++;
}
int curNum=Integer.parseInt(s.substring(i,j))*curr_tag;
if (j==s.length()){
real_num=curNum;
i=j-1;
}
else{
imaginary_num=curNum;
return new int[]{real_num,imaginary_num};
}
}
}
}
return new int[]{real_num,imaginary_num};
}
}
538. Convert BST to Greater Tree
右序遍历
class Solution {
int prevSum=0;
public TreeNode convertBST(TreeNode root) {
preOrder(root);
return root;
}
public void preOrder(TreeNode treeNode){
if (treeNode==null){
return ;
}
preOrder(treeNode.right);
treeNode.val=treeNode.val+prevSum;
prevSum=treeNode.val;
preOrder(treeNode.left);
}
}
*539. Minimum Time Difference
排序
如何应对循环排序?加一份等于数组长度的复制！
例如 a[i]=3 len(a)=5 a[i+1]=3+5=8!
public int findMinDifference(List<String> timePoints) {
int n = timePoints.size() * 2;
int[] nums = new int[n];
for (int i = 0, idx = 0; i < n / 2; i++, idx += 2) {
String[] ss = timePoints.get(i).split(":");
int h = Integer.parseInt(ss[0]), m = Integer.parseInt(ss[1]);
nums[idx] = h * 60 + m;
nums[idx + 1] = nums[idx] + 1440;
}
Arrays.sort(nums);
int ans = nums[1] - nums[0];
for (int i = 0; i < n - 1; i++) ans = Math.min(ans, nums[i + 1] - nums[i]);
return ans;
}
桶排
static constexpr int MAX_TIME=60*24;
class Solution {
public:
int findMinDifference(vector<string>& timePoints) {
int blanket[2*MAX_TIME];
fill(blanket,blanket+2*MAX_TIME,0);
for (string val:timePoints) {
string hours=val.substr(0,2);
string minutes=val.substr(3,2);
int total_time= stoi(hours)*60+ stoi(minutes);
blanket[total_time]++;
blanket[total_time+MAX_TIME]++;
}
int min_diff=MAX_TIME;
int begin=0;
while (blanket[begin]==0){
begin++;
}
int prev=begin;
for (int i = begin+1; i < MAX_TIME*2; ++i) {
if (blanket[i]==0){
continue;
}
if (blanket[i]>1){
cout<<"ahaha"<<blanket[i]<<endl;
return 0;
}
min_diff=min(min_diff,i-prev);
prev=i;
}
return min_diff;
}
};
*540. Single Element in a Sorted Array
842
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
