精华内容
下载资源
问答
  • 洗牌 codeExercise 做过的算法题的集锦,代码文件里有题目描述,以及思路的说明。新做的题目,会把题目和解法补充在该文件中。 leetcode lintcode 剑指Offer 程序员面试金典 公司真题 注意:题目中说到的格式要严格...
  • 洗牌 #数据结构与算法(Java描述) Algorithm 算法实例:缓存算法、洗牌算法、雪花算法、排序算法 leetcode:算法题 算法思想:递归、回溯、分治、贪心、动态规划 Data Structure 数组、稀疏数组 布隆过滤器 图(邻接表...
  • leetcode 洗牌 quizKiller 题目都是面试题或者leetcode,尽可能找到更多解 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 13. 14.
  • leetcode-洗牌-71

    2021-06-16 13:38:08
      洗牌在生活中十分常见,现在需要写一个程序模拟洗牌的过程。 现在需要洗2n张牌,从上到下依次是第1张,第2张,第3张一直到第2n张。首先,我们把这2n张牌分成两堆,左手拿着第1张到第n张(上半堆),右手拿着第n+...

    题目要求
      洗牌在生活中十分常见,现在需要写一个程序模拟洗牌的过程。 现在需要洗2n张牌,从上到下依次是第1张,第2张,第3张一直到第2n张。首先,我们把这2n张牌分成两堆,左手拿着第1张到第n张(上半堆),右手拿着第n+1张到第2n张(下半堆)。接着就开始洗牌的过程,先放下右手的最后一张牌,再放下左手的最后一张牌,接着放下右手的倒数第二张牌,再放下左手的倒数第二张牌,直到最后放下左手的第一张牌。接着把牌合并起来就可以了。 例如有6张牌,最开始牌的序列是1,2,3,4,5,6。首先分成两组,左手拿着1,2,3;右手拿着4,5,6。在洗牌过程中按顺序放下了6,3,5,2,4,1。把这六张牌再次合成一组牌之后,我们按照从上往下的顺序看这组牌,就变成了序列1,4,2,5,3,6。 现在给出一个原始牌组,请输出这副牌洗牌k次之后从上往下的序列。
    思路
      有多少个组,循环输入多少个组的数据,每一个组可以输入2n个数字,洗k次,运用vector将数字进行存储,引入一个中间的数组,用来存储一轮洗完的牌序,然后将洗完的再存回原数组,清空中间数组,如果还需要排序就再借助中间数组重新存储洗完的牌序,每一组牌处理完,将牌序打印出来。

    代码实现

    #include <iostream>
    #include <vector>
    
    using namespace std;
    int main()
    {
    	vector<int> st;
    	int T;//数据组
    	int n;//有2n个数
    	int k;//洗多少次
    	int num;
    	cin >> T;
    	while (T--)
    	{
    		cin >> n >> k;
    		for (int i = 0; i < 2 * n; i++)
    		{
    			cin >> num;
    			st.push_back(num);
    		}
    		vector<int> tmp;
    		while (k--)
    		{
    			for (int j = 0; j < n; j++)
    			{
    				tmp.push_back(st[j]);
    				tmp.push_back(st[j + n]);
    			}
    			for (int j = 0; j < 2 * n; j++)
    			{
    				st[j] = tmp[j];
    			}
    			tmp.clear();
    		}
    		for (auto e : st)
    			cout << e << ' ';
    		st.clear();
    	}
    	return 0;
    }
    
    展开全文
  • leetcode 870 优势洗牌

    2018-08-21 20:42:54
    leetcode 870 优势洗牌 题目描述: 给定两个大小相等的数组 A 和 B,A 相对于 B 的优势可以用满足 A[i] &gt; B[i] 的索引 i 的数目来描述。返回 A 的任意排列,使其相对于 B 的优势最大化。 题目分析: 这...

    每天坚持刷题!!!

    leetcode 870 优势洗牌

    题目描述:
    给定两个大小相等的数组 A 和 B,A 相对于 B 的优势可以用满足 A[i] > B[i] 的索引 i 的数目来描述。返回 A 的任意排列,使其相对于 B 的优势最大化。

    题目分析:

    1. 这道题乍看起来似乎可以用动态规划,但是细细一想这道题是无法拆分成子问题的。OK,既然动态规划没法用又是求极值的话,首先尝试用贪心法。

    2. 具体分析下,如果给定一个B中的一个数 Bx B x ,贪心的来看我们最好在A中找到所有比这个 Bx B x 大的数中最小的那个,即min([d for d in A if d > Bx B x ]), 这样可以让A中更大的数去匹配B中可能存在的比 Bx B x 大的数

    3. 但是对每个B中的数去找这个备选的list实在太浪费时间,所以一个比较好的方法就是先对A和B进行升序排序,两个指针分别指向A和B开头的数,然后A的指针从头开始移动找到第一个比B的指针指向的数大的数,然后记下A的指针指向的数要移动的位置,即要移动到B的指针指向的数的原来的下标,然后B的指针移动到下一个数,直到A或B的指针指向末尾,没有匹配上的数字随机分配。

    def advantageCount(self, A, B):
            """
            :type A: List[int]
            :type B: List[int]
            :rtype: List[int]
            """
            if not A and not B:
                return
            if len(A) == len(B) == 1:
                return A
            bb = sorted([(i, id) for id, i in enumerate(B)], key=lambda x: x[0])
            A = sorted(A)
            result = [-1 for _ in B]
            temp = []
            start_a = 0
            for data in bb:
                while start_a < len(A) and A[start_a] <= data[0]:
                    temp.append(A[start_a])
                    start_a += 1
                if start_a >= len(A):
                    break
                result[data[1]] = A[start_a]
                start_a += 1
            for i in xrange(len(result)):
                if result[i] == -1:
                    result[i] = temp.pop()
            return result
    展开全文
  • leetcode 870 优势洗牌 JavaScript 思路: 田忌赛马,意思就是,A拿最小的如果能打得过B最小的,ok同意;如果打不过,我当前A最小的这个要把B最大的抵掉,从而保证A若赚则赚,亏的时候换掉别人最猛的那只。 代码...

    leetcode 870 优势洗牌 JavaScript
    在这里插入图片描述
    思路:
    田忌赛马,意思就是,A拿最小的如果能打得过B最小的,ok同意;如果打不过,我当前A最小的这个要把B最大的抵掉,从而保证A若赚则赚,亏的时候换掉别人最猛的那只。
    代码思路大致相同,首先给A和B排序,之后给定i用于遍历完整个A,j和k分别指向B排序后的头和尾
    这里有个注意的点,因为后面需要得到对应的下标位置去放数字,所以B在排序前先给定下标,给完之后再对B排序
    比如1 10 4 11 对应下标0 1 2 3
    排序完之后我要的下标顺序是0 2 1 3
    实际上代码实现只对A排序 B本身不排序,B排序的是下标,也就是我代码下面这个tnums2存的是:根据B大小排序后得到的下标[0,2,1,3];然后j k分别指向这个数组的0和3,这样nums2[tnums2[j]]的j遍历就能按大小顺序遍历nums2了,这样做可以保证数据插入到最终数组ans对应下标的位置,也就是ans其实是和nums2顺序一致的,实际目的是用A的数据覆盖B的数据。
    之后按照比对思路去进行即可,交换的时候根据刚刚0213这个下标来确定放入的位置。
    代码如下:

    /**
     * @param {number[]} nums1
     * @param {number[]} nums2
     * @return {number[]}
     */
    var advantageCount = function(nums1, nums2) {
        nums1.sort((a,b)=>a-b);
        let tnums2 = nums2.map((val,index)=>index).sort((a,b)=>{if(nums2[a]>nums2[b]) return 1;else return -1;});
        let ans = [];
        let i = 0;//tnums1
        let j = 0;//tnums2
        let k= nums1.length-1;
        while(i<nums1.length){
            if(nums1[i]>nums2[tnums2[j]]){
                ans[tnums2[j++]] = nums1[i];
            }
            else {
                ans[tnums2[k--]] = nums1[i]
            }
            i++;
        }
        return ans;
    };
    
    展开全文
  • 给定两个大小相等的数组 A 和 B,A 相对于 B 的优势可以用满足 A[i] > B[i] 的索引 i 的数目来描述。 返回 A 的任意排列,使其相对于 B 的优势最大化。 示例 1: 输入:A = [2,7,11,15], B = [1,10,4,11] ...

    给定两个大小相等的数组 A 和 B,A 相对于 B 的优势可以用满足 A[i] > B[i] 的索引 i 的数目来描述。

    返回 A 的任意排列,使其相对于 B 的优势最大化。

    示例 1:

    输入:A = [2,7,11,15], B = [1,10,4,11]
    输出:[2,11,7,15]
    

    示例 2:

    输入:A = [12,24,8,32], B = [13,25,32,11]
    输出:[24,32,8,12]
    

    提示:

    1 <= A.length = B.length <= 10000
    0 <= A[i] <= 10^9
    0 <= B[i] <= 10^9
    

    思 路 分 析 : \color{blue}思路分析: 典型的贪心策略题,首先我们使用把vector容器A转换成multiset容器,然后顺序扫描B,对于每一个元素B[i]我们都尽可能在剩余的multiset容器中找到一个比它大的最小元素,如果找到了则直接使用,否则取出multiset中最小的元素。

    class Solution {
    public:
        vector<int> advantageCount(vector<int>& A, vector<int>& B) {
            vector<int> resVec;
            multiset<int> mySet(A.begin(), A.end());//把A转化成set容器
            for (const auto &num : B){//顺序扫描B
                auto it = mySet.upper_bound(num);//(二分法)获取最小的比num大的元素的迭代器
                if (it == mySet.end()){//如果剩余的mySet中没有比num大的元素,则取出最小的元素
                    it = mySet.begin();
                }
                resVec.push_back(*it);
                mySet.erase(it);//将*it从mySet中移除
            }
            return resVec;
        }
    };
    

    在这里插入图片描述

    展开全文
  • leetcode870 优势洗牌

    2021-09-04 17:00:05
    给定两个大小相等的数组 A 和 B,A 相对于 B 的优势可以用满足 A[i] > B[i] 的索引 i 的数目来描述。 返回 A 的任意排列,使其相对于 B 的优势最大化。 示例 1: 输入:A = [2,7,11,15], B = [1,10,4,11] ...
  • leetcode 870题 优势洗牌

    2020-03-23 23:07:02
    leetcode 870 优势洗牌 贪心算法 田忌赛马 题目:给定两个大小相等的数组 A 和 B A 相对于 B 的优势可以用满足 A[i] > B[i] 的索引 i 的数目来描述。 返回 A 的任意排列,使其相对于 B 的优势最大化。 分析: 想...
  • leetcode 870优势洗牌

    2020-02-01 14:41:33
    给定两个大小相等的数组A和B,A 相对于 B 的优势可以用满足A[i] > B[i]的索引 i的数目来描述。 返回A的任意排列,使其相对于 B的优势最大化。 示例 1: ...输入:A = [2,7,11,15], B = [1,10,4,11] ...
  • leetcode 840 优势洗牌

    2018-10-13 11:52:27
    思路:很简单,田忌赛马。强对强,弱对弱,如果发现你的强打不过对方的强,就用最弱的对对方的强; 程序实现问题: 1、为了分出强弱,肯定要sort()排序一下, sort(C.rbegin(), C.rend());...
  • leetcode 870. 优势洗牌

    2018-08-22 17:11:27
    给定两个大小相等的数组 A 和 B,A 相对于 B 的优势可以用满足 A[i] &gt; B[i] 的索引 i 的数目来描述。 返回 A 的任意排列,使其相对于 B 的优势最大化。   ...输入:A = [2,7,11,15], B = [1,10,4...
  • 优势洗牌 JAVA 题解 题目链接:https://leetcode-cn.com/problems/advantage-shuffle/ 思想: 田忌赛马 每次拿A的“当前轮次“的最小值和B的”当前轮次“最小值比较, 若大于,则OK,满足。(1) 若小于,则将A的值...
  • LeetCode 870. 优势洗牌

    2018-07-18 16:13:12
    最近刷LeetCode题目的一些思路,题目信息 给定两个大小相等的数组 A 和 B,A 相对于 B 的优势可以用满足 A[i] &gt; B[i] 的索引 i 的数目来描述。 返回 A 的任意排列,使其相对于 B 的优势最大化。...
  • Leetcode 870. 优势洗牌

    2019-03-30 01:03:00
    870.优势洗牌 显示英文描述 我的提交返回竞赛 用户通过次数49 用户尝试次数92 通过次数49 提交次数192 题目难度Medium 给定两个大小相等的数组A和B,A 相对于 B 的优势可以用满足A[i] &...
  • Leetcode 870:优势洗牌

    2019-04-10 23:02:38
    题目描述 给定两个大小相等的数组A和B,A 相对于 B 的优势可以用满足A[i] > B[i]的索引i的数目来描述。 返回A的任意排列,使其相对于B的优势最大化。 ...输入:A = [12,24,8,32], B = [...
  • 我们可以用手中最弱的来与 b 配对,这样会使 A 中剩余的严格地变大,因此会有更多得分点。 代码 class Solution ( object ) : def advantageCount ( self , A , B ) : """ :type A: List[int] ...
  • leetcode 870.优势洗牌

    2018-11-03 07:52:46
    请输入代码给定两个大小相等的数组 A 和 B,A 相对于 B 的优势可以用满足 A[i] > B[i] 的索引 i 的数目来描述。 返回 A 的任意排列,使其相对于 B 的优势最大化。 示例 1: 输入:A = [2,7,11,15], B = [1,10,4,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 832
精华内容 332
关键字:

leetcode洗牌