精华内容
下载资源
问答
  • 输出A/B内容:长度/最大值/最小值/交集/并集/差集集合形式(受限与输出不能输出特定范围指定位数,将在下一篇文章介绍) 注意:随机数取值范围不是[)而是[] ''' import random def myFunc(): List = [] for ...
    '''
    随机生成10个整数:范围[0-10]
    分别组成A集合和B集合
    输出A/B内容的:长度/最大值/最小值/交集/并集/差集的集合形式(受限与输出不能输出特定范围指定位数,将在下一篇文章介绍)
    注意:随机数的取值范围不是[)而是[]
    
    '''
    import random
    def myFunc():
        List = []
        for j in range(5):
            x=random.randint(0,10)
            List.append(x)
        return set(List)
    A = myFunc()
    B = myFunc()
    print(str.format("集合的内容,长度,最大值,最小值分别为:\n{0} {1} {2} {3}",A,len(A),max(A),min(A)))
    print(str.format("{0} {1} {2} {3}",B,len(B),max(B),min(B)))
    print(str.format("A和B的并集,交集和差集分别为:\n{0} {1} {2} ",A|B,A&B,A-B))
    
    

    更多干货正在赶来,敬请期待……

    PS:本文原创首发于公众号「让我遇见相似的灵魂」,回复关键字获取数十本程序员经典电子书。

    左手代码,右手吉他,这就是天下:如果有一天我遇见相似的灵魂 那它肯定是步履艰难 不被理解 喜黑怕光的。如果可以的话 让我触摸一下吧
    它也一样孤独得太久。 不一样的文艺青年,不一样的程序猿。

    展开全文
  • 元素删除可参考http://c.biancheng.net/view/429.html 去重可参考... 对vector中pair排序https://www.cnblogs.com/bigyang/p/8590552.html 批量赋值:https://blog.csdn.net...

    元素删除可参考 http://c.biancheng.net/view/429.html

    去重可参考https://blog.csdn.net/HE19930303/article/details/50579996

    对vector中的pair排序 https://www.cnblogs.com/bigyang/p/8590552.html

    批量赋值:https://blog.csdn.net/t46414704152abc/article/details/79229715

    以下代码参考https://www.cnblogs.com/mayouyou/p/8921598.html

    #include <iostream>
    #include <vector>
    #include <algorithm> //sort函数、交并补函数
    #include <iterator> //求交并补使用到的迭代器
    using namespace std;
    
    //打印容器vector
    void print_vector(vector<int> v)
    {
        if(v.size()>0){
            cout<<"{";  
            for(int i=0;i<int(v.size());i++){  
                cout<<v[i]<<",";  
            }  
            cout<<"\b}";  
        }
        else{
            cout<<"{}";
        }
    }
    
    //容器vector中元素的去重
    vector<int> unique_element_in_vector(vector<int> v)
    {
        vector<int>::iterator vector_iterator;
        sort(v.begin(),v.end());
        vector_iterator = unique(v.begin(),v.end());
        if(vector_iterator != v.end()){
            v.erase(vector_iterator,v.end());
        }
        return v;
    }
    
    //两个vector求交集
    vector<int> vectors_intersection(vector<int> v1,vector<int> v2)
    {
        vector<int> v;
        sort(v1.begin(),v1.end());   
        sort(v2.begin(),v2.end());   
        set_intersection(v1.begin(),v1.end(),v2.begin(),v2.end(),back_inserter(v));//求交集 
        return v;
    }
    
    //两个vector求并集
    vector<int> vectors_set_union(vector<int> v1,vector<int> v2)
    {
        vector<int> v;
        sort(v1.begin(),v1.end());   
        sort(v2.begin(),v2.end());   
        set_union(v1.begin(),v1.end(),v2.begin(),v2.end(),back_inserter(v));//求交集 
        return v;
    }
    
    //判断vector的某一元素是否存在
    bool is_element_in_vector(vector<int> v,int element)
    {
        vector<int>::iterator it;
        it=find(v.begin(),v.end(),element);
        if (it!=v.end()){
            return true;
        }
        else{
            return false;
        }
    }
    
    int main(){
        vector<int> v1,v2,v;
        v1.push_back(22);v1.push_back(22);v1.push_back(23);v2.push_back(23);v2.push_back(24);
        cout<<"v1是否存在1这个元素?"<<is_element_in_vector(v1,1)<<endl;
        cout<<"对v1去重:";
        v1=unique_element_in_vector(v1);
        print_vector(v1);
        cout<<endl;
        cout<<"求v1与v2的交集:";
        v=vectors_intersection(v1,v2);
        print_vector(v);
        cout<<endl;
        cout<<"求v1与v2的并集:";
        v=vectors_set_union(v1,v2);
        print_vector(v);
        
        //求最大最小值
        vector<double>::iterator biggest = std::max_element(v.begin(), v.end());
        cout << "Max element is " << *biggest<< " at position " << distance(v.begin(), biggest) << endl;
        vector<double>::iterator smallest= std::min_element(v.begin(), v.end());
        cout << "Min element is " << *smallest<< " at position " << distance(v.begin(), smallest) << endl;
    
    
        return 0;
    }
    
       

    Enjoy!

    展开全文
  • 关键字:二分查找归航return:(Trivial) LeetCode 1177—构建回文串检测​zhuanlan.zhihu.com归航return:(Trivial) LeetCode 350—两个数组的交集 II​zhuanlan.zhihu.comProblem给出一个函数 f(x, y) 和一个目标...

    关键字:二分查找

    归航return:(Trivial) LeetCode 1177—构建回文串检测zhuanlan.zhihu.com
    归航return:(Trivial) LeetCode 350—两个数组的交集 IIzhuanlan.zhihu.com

    Problem

    给出一个函数 f(x, y) 和一个目标结果 z,请你计算方程 f(x,y) == z 所有可能的正整数 数对 xy

    给定函数是严格单调的,也就是说:

    • f(x, y) < f(x + 1, y)
    • f(x, y) < f(x, y + 1)
    interface CustomFunction {
    public:
      // Returns positive integer f(x, y) for any given positive integer x and y.
      int f(int x, int y);
    };

    如果你想自定义测试,你可以输入整数 function_id 和一个目标结果 z 作为输入,其中 function_id 表示一个隐藏函数列表中的一个函数编号,题目只会告诉你列表中的 2 个函数。

    你可以将满足条件的 结果数对 按任意顺序返回。

    示例 1:

    输入:function_id = 1, z = 5
    输出:[[1,4],[2,3],[3,2],[4,1]]
    解释:function_id = 1 表示 f(x, y) = x + y

    示例 2:

    输入:function_id = 2, z = 5
    输出:[[1,5],[5,1]]
    解释:function_id = 2 表示 f(x, y) = x * y

    提示:

    • 1 <= function_id <= 9
    • 1 <= z <= 100
    • 题目保证 f(x, y) == z 的解处于 1 <= x, y <= 1000 的范围内。
    • 1 <= x, y <= 1000 的前提下,题目保证 f(x, y) 是一个 32 位有符号整数。
    1237. 找出给定方程的正整数解 - 力扣(LeetCode)leetcode-cn.com

    Solution

    本题最难的并不是完成题目的求解,而是理解题意。事实上,本题给出了一个映射关系:

    其中在 x 方向上和 y 方向上都满足单调递增的特性,或者说,偏“差分”大于 0。由于题目将 x,y 的范围都限制在了 [1,1000] 内,因此可以将问题理解成一个 1000*1000 的数组储存了所有结果,而且结果在横向和纵向上都是有序的。

    等等,这好熟悉,似乎这道题在哪里做过?答案是肯定的,就是 LeetCode 240. 那么本题实际上就是在有限的范围里求解同一个问题。注意到整数的一个基本性质:

    又因为

    ,因此反复运用性质
    (1),就可以得到:

    那么就有:

    ,这样最多做一个时间复杂度
    的暴力穷举就可以了。Java 代码如下(C++ 代码甚至不能达到
    刷题学习法的目的,因此不写出):
    class Solution {
        public List<List<Integer>> findSolution(CustomFunction customfunction, int z) {
            List<List<Integer>> res = new ArrayList<List<Integer>>();
            for (int i = 1;i <= z; ++i){
                for (int j = 1; j <= z; ++j){
                    if (customfunction.f(i,j) == z){
                        List<Integer> tmp = new ArrayList<Integer>();
                        tmp.add(i);
                        tmp.add(j);
                        res.add(tmp);
                    }
                }
            }
            return res;
        }
    }

    但是这个算法太慢了,因为并没有好好利用好数组的有序条件,而二分查找就是为了处理此类问题而产生的。此处再次安利这个知乎回答中的写法:

    def lower_bound(array, first, last, value): # 返回[first, last)内第一个不小于value的值的位置
        while first < last: # 搜索区间[first, last)不为空
            mid = first + (last - first) // 2  # 防溢出
            if array[mid] < value: first = mid + 1
            else: last = mid
        return first  # last也行,因为[first, last)为空的时候它们重合

    于是可以将内层改写为二分查找来实现。C++ 版本如下:

    class Solution {
    public:
        vector<vector<int>> findSolution(CustomFunction& customfunction, int z) {
            vector<vector<int>> res;
            for (int i = 1; i <= z; ++i){
                int jForFixedI = getLowerBoundsWithXfixed(customfunction, i, z);
                if (customfunction.f(i, jForFixedI) == z){
                    res.emplace_back(vector<int>{i,jForFixedI});
                }
            }
            return res;
        }
    private:
        int getLowerBoundsWithXfixed(CustomFunction& customfunction, int xFixed, int z){
            int left = 1;
            int right = z;
            int mid, midVal;
            while (left < right){
                mid = left+(right-left)/2;
                midVal = customfunction.f(xFixed, mid);
                if (midVal == z){
                    return mid;
                }
                else if (z > midVal){
                    left = mid+1;
                }
                else{
                    right = mid;
                }
            }
            return mid;
        }
    };
    

    Java 版本如下:

    class Solution {
        public List<List<Integer>> findSolution(CustomFunction customfunction, int z) {
            List<List<Integer>> res = new ArrayList<List<Integer>>();
            for (int i = 1;i <= z; ++i){
                int jForFixedI = getLowerBoundWithXfixed(customfunction, i, z);
                if (customfunction.f(i,jForFixedI) == z){
                    List<Integer> tmp = new ArrayList<Integer>();
                    tmp.add(i);
                    tmp.add(jforFixedI);
                    res.add(tmp);
                }
            }
            return res;
        }
        private int getLowerBoundWithXfixed(CustomFunction customfunction, int fixedX, int z){
            int begin = 1;
            int end = z;
            int mid, midVal;
            while (begin < end){
                mid = begin+(end-begin)/2;
                midVal = customfunction.f(fixedX,mid);
                if (midVal == z){
                    return mid;
                }
                else if (z > midVal){
                    begin = mid+1;
                }
                else{
                    end = mid;
                }
            }
            return begin;
        }
    }

    上述两种算法的时间复杂度都是

    。实际上还有一种更快的,从上到下从右到左的思路,时间复杂度是
    ,利用的仍然是函数的单调性:
    My concise O(m+n) Java solution - LeetCode Discussleetcode.com

    这里给出了针对 240 题的核心思路,同样适用于这道题:

    从右上角开始往左侧或者往下行走,每次走一步,如果某个点的函数值等于我们的期望值,那么往左走(往下边走也可以),如果函数值小于期望值,那么往下走,如果函数值大于期望值,那么往左走。我的 LeetCode 240 题题解中给出了对上述算法正确性的证明和代码实现。由于本题中 m=n,因此算法复杂度就是

    然后,本题中实际上真的有必要一步一步往下边走吗?答案是否定的,可以直接用二分查找来完成往下面走的探索,这样就可以将时间复杂度降低到

    ,虽然时间复杂度分析在本题中是一样的结果,但是实际上是不同的,这实际上也是一个时间复杂度符号不足的体现。

    上述算法的 C++ 实现如下:

    class Solution {
    public:
        vector<vector<int>> findSolution(CustomFunction& customfunction, int z) {
            vector<vector<int>>res;
            int curX = 1;
            int curY = z;
            int curVal;
            while (curX <= z && curY > 0){
                curVal = customfunction.f(curX, curY);
                if (curVal == z){
                    res.emplace_back(vector<int>{curX,curY});
                    --curY;
                }
                else if (curVal < z){
                    curX = getLowerBoundOnX(customfunction, curY, z);
                    if (curX == z+1)
                        break;
                }
                else{
                    --curY;
                }
            }
            return res;
        }
        int getLowerBoundOnX(CustomFunction& customfunction, int curY, int res){
            int begin = 1;
            int end = res+1;
            int mid;
            int midVal;
            while (begin < end){
                mid = begin+(end-begin)/2;
                midVal = customfunction.f(mid, curY);
                if (res == midVal){
                    return mid;
                }
                else if (res < midVal){
                    end = mid;
                }
                else{
                    begin = mid+1;
                }
            }
            return begin;
        }
    };
    

    Java 实现如下:

    class Solution {
        public List<List<Integer>> findSolution(CustomFunction customfunction, int z) {
            int curX = 1;
            int curY = z;
            int curVal;
            List<List<Integer>>res = new ArrayList<List<Integer>>();
            while (curX <= z && curY > 0){
                curVal = customfunction.f(curX, curY);
                if (curVal == z){
                    List<Integer> temp = new ArrayList<Integer>();
                    temp.add(curX);
                    temp.add(curY);
                    res.add(temp);
                    --curY;
                }
                else if (curVal < z){
                    curX = getLowerBoundsOnX(customfunction, curY, z);
                    if (curX == z+1){
                        break;
                    }
                }
                else{
                    --curY;
                }
            }
            return res;
        }
        private int getLowerBoundsOnX(CustomFunction customfunction, int yFixed, int target){
            int begin = 1;
            int end = target+1;
            int mid, midVal;
            while (begin < end){
                mid = begin+(end-begin)/2;
                midVal = customfunction.f(mid, yFixed);
                if (target == midVal){
                    return mid;
                }
                else if (target > midVal){
                    begin = mid+1;
                }
                else{
                    end = mid;
                }
            }
            return begin;
        }
    }

    EOF。

    展开全文
  • 对于一个数字,其在交集中出现的次数等于该数字在两个数组中出现次数的最小值。 操作流程 首先遍历第一个数组,并在哈希表中记录第一个数组中的每个数字以及对应出现的次数,然后遍历第二个数组,对于第二个数组中的...

    求解两个数组的交集的方法

    样题描述

    在这里插入图片描述

    方法说明

    由于同一个数字在两个数组中都可能出现多次,因此需要用哈希表存储每个数字出现的次数。对于一个数字,其在交集中出现的次数等于该数字在两个数组中出现次数的最小值。

    操作流程

    首先遍历第一个数组,并在哈希表中记录第一个数组中的每个数字以及对应出现的次数,然后遍历第二个数组,对于第二个数组中的每个数字,如果在哈希表中存在这个数字,则将该数字添加到答案,并减少哈希表中该数字出现的次数。

    注意:
    为了降低空间复杂度,首先遍历较短的数组并在哈希表中记录每个数字以及对应出现的次数,然后遍历较长的数组得到交集。

    java代码

    package haxibiao;
    import java.util.Arrays;
    import java.util.HashMap;
    import java.util.Map;
    
    //两个数组的交集  350
    public class Solutioon {
        public int[] intersect(int[] nums1, int[] nums2){
              if( nums1.length > nums2.length){
                  intersect(nums2, nums1);    //如果nums1大于nums2时,交换两个数组
              }
              //创建一个哈希表
              Map<Integer,Integer> map = new HashMap<Integer,Integer>();
              for(int num: nums1){   //遍历数组nums1中的元素,count表示重复出现的元素的个数的
                  int count = map.getOrDefault(num,0)+1;
                  map.put(num, count); 
              }
              //创建一个用于存放输出结果的数组
              int[] intersection = new int[nums1.length];  
              int index = 0;
              for(int num : nums2){
                  //得到遍历数组nums1时对应num元素的个数,该num元素和其对应的count存在哈希表中
                  int count = map.getOrDefault(num, 0);
                  if(count > 0){
                      //如果哈希表中对应元素的个数大于零,则将此时遍历nums2时的num放进创建的intersection数组中
                      intersection[index++] = num; 
                      count --;
                      if(count > 0){
                         map.put(num,count);//将num元素对应的个数count进行自减操作后,再放回哈希表中
                      }else{
                          map.remove(num); //如果num对应的个数值小于等于0就将这个数从哈希表中移除
                      }
                  }
              }
            return Arrays.copyOfRange(intersection, 0, index);
        }
        public static void main(String[] args){
            int nums1[] = new int[]{4,9,5,4,4};
            int nums2[] = new int[]{9,4,9,8,4,6};
            Solutioon sool = new Solutioon();
            sool.intersect(nums1,nums2);
        }
    }
    

    思路总结

    对于两个数组求其交集,首先创建一个哈希表,遍历两个数组中长度较短的,遍历nums1时将不同的数组元素放入到HashMap中,并且每次遍历时将遍历的元素个数加 1,直到数组元素遍历结束。遍历第二个数组的时候,首先创建一个数组用来存放两个数组的交集元素,,遍历第二个数组时,在
    HashMap中寻找与第二个数组相等的元素,并将该数组元素相应的个数值取出来,赋值给count,,当count 大于零时,也就是HashMap中还有对应num的元素,此时进行的操作就是将这个第二个数组中此时的num值赋值给创建的 intersection 数组,并且将索引值index加 1,并且将count减 1,进行了上述操作后,如果count的值还是大于零,则将此时的 num 和 count 放入到 HashMap中,否则就将HashMap中这个元素移除,然后重复循环执行,知道循环结束,最后输出intersection 数组。

    展开全文
  • 示例1:输入:nums1 = [1,2,2,1], nums2 = [2,2]输出:[2,2]示例2:输入:nums1 = [4,9,5], nums2 = [9,4,9,8,4]输出:[4,9]说明:输出结果中每个元素出现的次数,应与元素在两个数组中出现次数的最小值一致。...
  • 两个数组的交集

    2020-11-26 20:36:07
    说明:输出结果中每个元素出现的次数,应与元素在两个数组中出现次数的最小值一致。我们可以不考虑输出结果的顺序。 思路:循环一个数组,看另一个数组中是否存在,若存在将其存到新数组中,同时删除未循环数组中的...
  • 虽然线段树和树状数组也可以求解区间最大值和最小值,但是他们确没有st表速度快,st表预处理之后查询区间最大最小值只要O(1)时间,st表精要就是dp数组特点,dp[i][j]表示是从i开始,长度为2^j长度区间...
  • 两个数组的交集 II

    2021-01-19 23:44:13
    两个数组的交集 II ...输出结果中每个元素出现的次数,应与元素在两个数组中出现次数的最小值一致。 我们可以不考虑输出结果的顺序。 进阶: 如果给定的数组已经排好序呢?你将如何优化你的算法? 如果&
  • 示例 1:输入:nums1 = [1,2,2,1], nums2 = [2,2]输出:[2,2]示例 2:输入:nums1 = [4,9,5], nums2 = [9,4,9,8,4]输出:[4,9]说明:输出结果中每个元素出现的次数,应与元素在两个数组中出现次数的最小值一致。...
  • 两个数组的交集II

    2020-07-13 20:12:47
    两个数组的交集II ...输出结果中每个元素出现的次数,应与元素在两个数组中出现次数的最小值一致。 我们可以不考虑输出结果的顺序。 题解 /** * @param {number[]} nums1 * @param {number[]} nums2 * @r
  • 如果开始时间的最大值小于等于结束时间的最小值则说明这两个时间段有交集。 注: 博客:https://blog.csdn.net/badao_liumang_qizhi 关注公众号 霸道的程序猿 获取编程相关电子书、教程推送与免费下载。 实现 ...
  • 求解集合的交集问题

    千次阅读 2014-10-12 19:10:06
    用快排,平均复杂度O(N*logN)),设置两个指针p和q,同时指向集合A和集合B的最小值,不相等的话移动*p和*q中较小值的指针,相等的话同时移动指针p和q,并且记下相等的数字,为交集的元素之一,依次操作,直到其中一...
  • 算法题:两个数组的交集 II

    千次阅读 2020-12-14 12:42:54
    输出结果中每个元素出现的次数,应与元素在两个数组中出现次数的最小值一致。 我们可以不考虑输出结果的顺序。 进阶: 如果给定的数组已经排好序呢?你将如何优化你的算法? 如果nums1的大小比nums2小很多,哪种方法...
  • 示例示例 1:输入:nums1 = [1,2,2,1], nums2 = [2,2]输出:[2,2]示例 2:输入:nums1 = [4,9,5], nums2 = [9,4,9,8,4]输出:[4,9]说明:输出结果中每个元素出现的次数,应与元素在两个数组中出现次数的最小值一致。...
  • 输出结果中每个元素出现的次数,应与元素在两个数组中出现次数的最小值一致。 我们可以不考虑输出结果的顺序。 解决思路一:哈希表 由于同一个数字在两个数组中都可能出现多次,因此需要用哈希表存储每个数字出现的...
  • SQL 取日期时间交集的算法?

    千次阅读 2013-09-27 16:38:59
    [beginDate1 ~ endDate1] 和 [beginDate2 ~ endDate2],这两个时间段,请为如何取交集? 答案: MIN(endDate1, endDate2) >= MAX(beginDate1, ...(用两"尾"的最小值,然后比较两"头"的最大值,若大等于零则有交集)
  • 目录问题描述1.1排序求交集1.2代码2.1...输出结果中每个元素出现的次数,应与元素在两个数组中出现次数的最小值一致。 我们可以不考虑输出结果的顺序。 进阶: 如果给定的数组已经排好序呢?你将如何优化你的算法? 如
  • 350. 两个数组的交集 II ...输出结果中每个元素出现的次数,应与元素在两个数组中出现次数的最小值一致。 我们可以不考虑输出结果的顺序。 进阶: 如果给定的数组已经排好序呢?你将如何优化你的算..
  • 两个数组的交集 II 作者:力扣 (LeetCode) ...输出结果中每个元素出现的次数,应与元素在两个数组中出现次数的最小值一致。 我们可以不考虑输出结果的顺序。 示例 1: 输入:nums1 = [1,2,2,1], nums2 = [2,2]
  • 输出结果中每个元素出现的次数,应与元素在两个数组中出现次数的最小值一致。我们可以不考虑输出结果的顺序。 进阶: 如果给定的数组已经排好序呢?你将如何优化你的算法? 来源:力扣(LeetCode) 链接:h
  • 1. 相离,可以通过判断两个矩形X最大值,最小值以及Y最大值,最小值的大小比较判定。(空间搜索外包矩形常用算法) 2. 包含与被包含,也是通过两个矩形X最大值,最小值以及Y最大值,最小值的大小比较判定。...
  • 目录LeetCode 350: 两个数组的交集 II题目描述解题哈希表排序 LeetCode 350: 两个数组的交集 II ...输出结果中每个元素出现的次数,应与元素在两个数组中出现次数的最小值一致。 我们可以不考虑输出结果的顺序
  • 输出结果中每个元素出现的次数,应与元素在两个数组中出现次数的最小值一致。 我们可以不考虑输出结果的顺序。 进阶: 如果给定的数组已经排好序呢?你将如何优化你的算法? 如果 nums1 的大小比 nums2 小很多,哪...
  • 输出结果中每个元素出现的次数,应与元素在两个数组中出现次数的最小值一致。 我们可以不考虑输出结果的顺序。 举例: 输入:nums1 = [4,9,5], nums2 = [9,4,9,8,4] 输出:[4,9] 题干解析: 交集:既出现在nums1中 ...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 213
精华内容 85
关键字:

交集的最小值