leetcode 0218

目录

  • ? 1200. 最小绝对差
  • 描述
  • 解答
    • cpp
    • py
  • ? 897. 递增顺序查找树
  • 描述
  • 解答
    • cpp

      • 指针问题？
      • fuck ptr
    • py
  • ? 183. 从不订购的客户
  • 描述
  • 解答
    • sql todo rev me
  • ? 575. 分糖果
  • 描述
  • 解答
    • cpp
    • py
  • ? 136. 只出现一次的数字
  • 描述
  • 解答
    • cpp
    • py

? 1200. 最小绝对差

描述

给你个整数数组?arr，其中每个元素都 不相同。

请你找到所有具有最小绝对差的元素对，并且按升序的顺序返回。

?

示例 1：

输入：arr = [4,2,1,3]
输出：[[1,2],[2,3],[3,4]]
示例 2：

输入：arr = [1,3,6,10,15]
输出：[[1,3]]
示例 3：

输入：arr = [3,8,-10,23,19,-4,-14,27]
输出：[[-14,-10],[19,23],[23,27]]
?

提示：

2 <= arr.length <= 10^5
-10^6 <= arr[i] <= 10^6

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-absolute-difference
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解答

sort 后，进行查找相邻的两者 差值，放入map

然后对map 的key 排序，打印出最小的key 对应的所有 values

实际上大家都如下，使用遍历数组，然后过程中记录minDiff，然后在原地做事情，没有使用map

这些个解答没有使用我自己想的map， 因为key 可能重复，所以他用了数组：vector， list

cpp

class Solution {
public:
    vector<vector<int>> minimumAbsDifference(vector<int>& arr) {
        sort(arr.begin(), arr.end());
        int minest = INT_MAX;
        for(int i = 0; i < arr.size() - 1; i++) {
            int curDiff = arr[i+1] - arr[i];
            minest = minest >= curDiff ? curDiff: minest;
        }
        vector<vector<int>> res;
        for (int i = 0; i < arr.size() - 1; i++) {
            if(arr[i+1] - arr[i] == minest){
                res.push_back({arr[i], arr[i+1]});
                //两个 int 尺寸的int 被放入内层vector，然后作为一个vector 放入外层vector
            }
        }
        return res;
    }
};
/*执行用时 :
96 ms
, 在所有 C++ 提交中击败了
90.87%
的用户
内存消耗 :
17 MB
, 在所有 C++ 提交中击败了
72.87%
的用户*/

py

class Solution:
    def minimumAbsDifference(self, arr: List[int]) -> List[List[int]]:
        arr.sort()
        len1 = len(arr)
        len2 = len1 - 1
        mininum = [0] * len2
        for i in range (len2):
            mininum[i] = arr[i+1] - arr[i]# guess we dont need abs
        m = min(mininum)
        res = []
        for i in range (len2):
            if mininum[i] == m:
                res.append([arr[i], arr[i+1]])
        return res
'''
执行用时 :
484 ms
, 在所有 Python3 提交中击败了
41.26%
的用户
内存消耗 :
27.2 MB
, 在所有 Python3 提交中击败了
49.59%
的用户
'''

? 897. 递增顺序查找树

描述

给定一个树，按中序遍历重新排列树，使树中最左边的结点现在是树的根，并且每个结点没有左子结点，只有一个右子结点。

输入：[5,3,6,2,4,null,8,1,null,null,null,7,9]

       5
      /     3    6
   / \      2   4    8
?/        / \
1        7   9

输出：[1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]

 1
? ?  2
?   ?    3
?     ?      4
?       ?        5
?         ?          6
?           ?            7
?             ?              8
?                                9  

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/increasing-order-search-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解答

cpp

my dont compile pass:

/**
 * 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:
    TreeNode* increasingBST(TreeNode* root) {
        if(!root) {
            return NULL;//blank tree
        }
        stack<TreeNode> s;
        TreeNode *res = (TreeNode *) malloc (sizeof(TreeNode));
        TreeNode *ret = res;
        while(root || !s.empty()) {
            while(root) {
                s.push(root);
                root = root->left;
            }
            root = s.top();
            s.pop();
            res = root;
            root = root->right;
            res = res->right;
        }
        return ret;
    }
};

指针问题？

/**
 * 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:
    TreeNode* increasingBST(TreeNode* root) {
        if(!root) {
            return NULL;//blank tree
        }
        stack<TreeNode> s;
        TreeNode *res = (TreeNode *) malloc (sizeof(TreeNode));
        TreeNode *ret = res;
        while(root || !s.empty()) {
            while(root) {
                s.push(*root);
                root = root->left;
            }
            //we must re-declare root ptr
            TreeNode *node = (TreeNode *) malloc (sizeof(TreeNode));
            *node = s.top();
            s.pop();
            printf(":%d:", node->val);
            res->right = node;
            res = res->right;
            root = node->right;
        }
        return ret->right;
    }
};

output:

fuck ptr

/**
 * 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:
    TreeNode* increasingBST(TreeNode* root) {
        if(!root) {
            return NULL;//blank tree
        }
        stack<TreeNode> s;
        TreeNode *res = (TreeNode *) malloc (sizeof(TreeNode));
        TreeNode *ret = res;
        while(root || !s.empty()) {
            while(root) {
                s.push(*root);
                root = root->left;
            }
            //we must re-declare node ptr
            TreeNode *node = (TreeNode *) malloc (sizeof(TreeNode));
            *node = s.top();
            s.pop();
            printf(":%d:", node->val);

            res->right = (TreeNode *) malloc(sizeof(TreeNode));
            res->right = node;
            res->left = NULL;
            res = res->right;
            root = node->right;

        }
        printf("bef ret");
        return ret;
    }
};
//  气死人！！！todo fuck me！！

py

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def increasingBST(self, root: TreeNode) -> TreeNode:
        s = []
        dummy = TreeNode(0)
        p = dummy
        while s or root:
            if root:
                s.append(root)
                root = root.left
            else:
                cur = s.pop()
                root = cur.right
                cur.left = None
                p.right = cur
                p = p.right
        return dummy.right
'''
执行用时 :
88 ms
, 在所有 Python3 提交中击败了
84.62%
的用户
内存消耗 :
13.2 MB
, 在所有 Python3 提交中击败了
43.45%
的用户
'''

? 183. 从不订购的客户

https://leetcode-cn.com/problems/customers-who-never-order/

描述

某网站包含两个表，Customers 表和 Orders 表。编写一个 SQL 查询，找出所有从不订购任何东西的客户。

Customers 表：

+----+-------+
| Id | Name  |
+----+-------+
| 1  | Joe   |
| 2  | Henry |
| 3  | Sam   |
| 4  | Max   |
+----+-------+
Orders 表：

+----+------------+
| Id | CustomerId |
+----+------------+
| 1  | 3          |
| 2  | 1          |
+----+------------+
例如给定上述表格，你的查询应返回：

+-----------+
| Customers |
+-----------+
| Henry     |
| Max       |
+-----------+

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/customers-who-never-order
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解答

sql todo rev me

# 498ms
select c.Name as Customers from Customers c left join Orders o on o.CustomerId = c.Id where o.Id is null;

# 532ms
select c.Name as Customers from Customers c where not exists (select 1 from Orders o where o.CustomerId = c.Id);

# 455ms
select c.Name as Customers from Customers c where c.Id not in (select distinct o.CustomerId from Orders o);

? 575. 分糖果

https://leetcode-cn.com/problems/distribute-candies/

描述

给定一个偶数长度的数组，其中不同的数字代表着不同种类的糖果，每一个数字代表一个糖果。你需要把这些糖果平均分给一个弟弟和一个妹妹。返回妹妹可以获得的最大糖果的种类数。

示例 1:

输入: candies = [1,1,2,2,3,3]
输出: 3
解析: 一共有三种种类的糖果，每一种都有两个。
     最优分配方案：妹妹获得[1,2,3],弟弟也获得[1,2,3]。这样使妹妹获得糖果的种类数最多。
示例 2 :

输入: candies = [1,1,2,3]
输出: 2
解析: 妹妹获得糖果[2,3],弟弟获得糖果[1,1]，妹妹有两种不同的糖果，弟弟只有一种。这样使得妹妹可以获得的糖果种类数最多。
注意:

数组的长度为[2, 10,000]，并且确定为偶数。
数组中数字的大小在范围[-100,000, 100,000]内。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/distribute-candies
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解答

cpp

class Solution {
public:
    int distributeCandies(vector<int>& candies) {
        set<int> myset;
        set<int>::iterator it;
        for(int i: candies){
            myset.insert(i);
        }
        int halfCount = candies.size() / 2;
        int ans = 0;
        //add each kind in myset to sis
        int sisGet = 0;
        for(it = myset.begin(); it != myset.end(); ++it){
            //for each kind in myset, give it to sis
            sisGet++;
        }
        // sister got : more kinds, give the redundant kinds to bro
        // so sister left halfCount
        if(sisGet > halfCount) {
            return halfCount;
        }else if (sisGet < halfCount){
            // if there are so few kind, that's all sis can got, so return it
            return sisGet;
        }
        // sisGet == halfCount
        return halfCount;
    }
};
/*执行用时 :
424 ms
, 在所有 C++ 提交中击败了
39.25%
的用户
内存消耗 :
54.8 MB
, 在所有 C++ 提交中击败了
10.24%
的用户*/
//fuck me tdo, can't use set properly, now I can use c++ fucking set ok

py

niu‘s idea:

step1: first, we want to find all the unique candy?

推翻：

设想 有糖果： 蜜桃，蜜桃，蜜桃，大白兔，大白兔，四百木，巴达木，六百木

蜜桃 counter = 2
大白兔 counter = 2
四百木 counter = 1

当： if Counter[某个种类] == 1:
sis += 1

那么结果：妹妹，只得到： 四百木

哥哥反而得到了： 蜜桃，大白兔

class Solution:
    def distributeCandies(self, candies: List[int]) -> int:
        from collections import Counter
        sis = 0
        c = Counter(candies)
        # 首先分配给sis 所有稀有糖果
        for i in range(max(candies)):
            if c[i] == 1:
                # this is the unique fruit
                sis+=1
        if sis < (len(candies) // 2):
            # 如果妹妹没拿够
            # 那么如果 糖果本身 的种类 就少于 一半，那么 妹妹最多获得所有种类的水果
            # 也就是 return len(set(candies))
            if len(set(candies)) < (len(candies) // 2):
                return len(set(candies))
            else:
            # 如果呢，种类大于 一半，那么 妹妹就能拿 一半 数量的水果，每个水果
            # 就是一个种类
                return len(candies) // 2
        # 如果妹妹光拿稀有水果 就超过了 一半的数量，那么不要贪心，就拿一半，另一半还要
        # 给哥哥
        else:
            return len(candies) // 2
 '''
执行用时 :
1928 ms
, 在所有 Python3 提交中击败了
5.33%
的用户
内存消耗 :
15 MB
, 在所有 Python3 提交中击败了
48.59%
的用户
 '''

? 136. 只出现一次的数字

https://leetcode-cn.com/problems/single-number/

描述

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1:

输入: [2,2,1]
输出: 1
示例?2:

输入: [4,1,2,1,2]
输出: 4

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/single-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解答

cpp

 int singleNumber(vector<int>& nums) {
        int result = 0;
        for (int i = 0; i < nums.size(); i++) {
            bitset<4> bs1(result);
            bitset<4> bs2(nums[i]);
            cout<<bs1<<"^"<<bs2<<"=";
            result = result^nums[i];//二进制异或运算,
            bitset<4> bs3(result);
            cout<<bs3<<endl;
        }
        return result;

    }
//my

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int res;
        for(int num: nums) {
            res ^= num;
        }
        return res;
    }
};

todo fix 力扣SB：

py

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        from collections import Counter
        c = Counter(nums)
        print(c)
        for i in nums:
            if c[i] == 1:
                return i
'''
执行用时 :
96 ms
, 在所有 Python3 提交中击败了
80.27%
的用户
内存消耗 :
15.8 MB
, 在所有 Python3 提交中击败了
40.45%
的用户
'''

原文地址：https://www.cnblogs.com/paulkg12/p/12326565.html

时间： 2024-10-15 00:57:46

leetcode 0218的相关文章

[LeetCode] 349 Intersection of Two Arrays &amp; 350 Intersection of Two Arrays II

这两道题都是求两个数组之间的重复元素,因此把它们放在一起. 原题地址: 349 Intersection of Two Arrays :https://leetcode.com/problems/intersection-of-two-arrays/description/ 350 Intersection of Two Arrays II:https://leetcode.com/problems/intersection-of-two-arrays-ii/description/ 题目&解法

LeetCode 442. Find All Duplicates in an Array （在数组中找到所有的重复项）

Given an array of integers, 1 ≤ a[i] ≤ n (n = size of array), some elements appear twice and others appear once. Find all the elements that appear twice in this array. Could you do it without extra space and in O(n) runtime? Example: Input: [4,3,2,7,

LeetCode OJ - Sum Root to Leaf Numbers

这道题也很简单,只要把二叉树按照宽度优先的策略遍历一遍,就可以解决问题,采用递归方法越是简单. 下面是AC代码: 1 /** 2 * Sum Root to Leaf Numbers 3 * 采用递归的方法,宽度遍历 4 */ 5 int result=0; 6 public int sumNumbers(TreeNode root){ 7 8 bFSearch(root,0); 9 return result; 10 } 11 private void bFSearch(TreeNode ro

LeetCode OJ - Longest Consecutive Sequence

这道题中要求时间复杂度为O(n),首先我们可以知道的是,如果先对数组排序再计算其最长连续序列的时间复杂度是O(nlogn),所以不能用排序的方法.我一开始想是不是应该用动态规划来解,发现其并不符合动态规划的特征.最后采用类似于LRU_Cache中出现的数据结构(集快速查询和顺序遍历两大优点于一身)来解决问题.具体来说其数据结构是HashMap<Integer,LNode>,key是数组中的元素,所有连续的元素可以通过LNode的next指针相连起来. 总体思路是,顺序遍历输入的数组元素,对每个

LeetCode OJ - Surrounded Regions

我觉得这道题和传统的用动规或者贪心等算法的题目不同.按照题目的意思,就是将被'X'围绕的'O'区域找出来,然后覆盖成'X'. 那问题就变成两个子问题: 1. 找到'O'区域,可能有多个区域,每个区域'O'都是相连的: 2. 判断'O'区域是否是被'X'包围. 我采用树的宽度遍历的方法,找到每一个'O'区域,并为每个区域设置一个value值,为0或者1,1表示是被'X'包围,0则表示不是.是否被'X'包围就是看'O'区域的边界是否是在2D数组的边界上. 下面是具体的AC代码: class Boar

LeetCode 10. Regular Expression Matching

https://leetcode.com/problems/regular-expression-matching/description/ Implement regular expression matching with support for '.' and '*'. '.' Matches any single character. '*' Matches zero or more of the preceding element. The matching should cover

（leetcode题解）Pascal&#39;s Triangle

Pascal's Triangle  Given numRows, generate the first numRows of Pascal's triangle. For example, given numRows = 5,Return [ [1], [1,1], [1,2,1], [1,3,3,1], [1,4,6,4,1] ] 题意实现一个杨辉三角. 这道题只要注意了边界条件应该很好实现出来,C++实现如下 vector<vector<int>> generate(int

[LeetCode]Count Primes

题目:Count Primes 统计1-n的素数的个数. 思路1: 通常的思想就是遍历(0,n)范围内的所有数,对每个数i再遍历(0,sqrt(i)),每个除一遍来判断是否为素数,这样时间复杂度为O(n*sqrt(n)). 具体实现不在贴代码,过程很简单,两重循环就可以解决.但是效率很差,n较大时甚至会花几分钟才能跑完. 思路2: 用埃拉特斯特尼筛法的方法来求素数,时间复杂度可以达到O(nloglogn). 首先开一个大小为n的数组prime[],从2开始循环,找到一个质数后开始筛选出所有非素数

[LeetCode]Repeated DNA Sequences

题目:Repeated DNA Sequences 给定包含A.C.G.T四个字符的字符串找出其中十个字符的重复子串. 思路: 首先,string中只有ACGT四个字符,因此可以将string看成是1,3,7,20这三个数字的组合串: 并且可以发现{ACGT}%5={1,3,2,0};于是可以用两个位就能表示上面的四个字符: 同时,一个子序列有10个字符,一共需要20bit,即int型数据类型就能表示一个子序列: 这样可以使用计数排序的思想来统计重复子序列: 这个思路时间复杂度只有O(n),但是