Ultra-QuickSort

POJ2299——Ultra-QuickSort（归并排序）

序列的逆序数=在只允许相邻两个元素交换的条件下,得到有序序列的交换次数#include #include #include usingnamespacestd; inta[500010],t[500010]; longlongans;//必须用双长整型 voidmerge_sort(int*A,intx,inty,int*T)//归并排序 { if(y-x>1)//直到一个序列只有2个元素，则该序
u014141559·2014-07-09 11:00

POJ_2299 Ultra-QuickSort【归并排序】

题目链接：http://poj.org/problem?id=2299题目大意：求出排序过程中的最小交换次数利用归并排序的分治算法解决此题。代码：#include #include #include #defineN500001 usingnamespacestd; inta[N]; inttemp[N]; longlongans; voidmerge(int*a,intstart,intmid,
u013912596·2014-06-29 00:00

BNU Ultra-QuickSort

G.Ultra-QuickSortTimeLimit:7000msCaseTimeLimit:7000msMemoryLimit:65536KB64-bitintegerIOformat:%lld    Javaclassname:MainFontSize:Inthisproblem,youhavetoanalyzeaparticularsortingalgorithm.Thealgorithmp
u011641865·2014-05-20 17:00

POJ 2299 Ultra-QuickSort(树状数组)

请不要随便指点别人该怎么做、每个人的人生都应该自己掌握、你给不了别人一切、你也不懂别人的忧伤、                                             微笑不代表快乐、哭泣不一定悲伤        不努力怎么让关心你的人幸福、不努力怎么让看不起你的人绝望、                                                        
verticallimit·2014-05-13 02:00

POJ 2299 Ultra-QuickSort(树状数组+离散化)

 树状数组intlow(inti){ returni&(-i); }更新voidupdate(inti){ while(i0){ s+=num[i]; i-=low(i); } returns; } 离散化的方式：structNode{intval;intpos;};Nodenode[500005];intreflect[500005];val存放原数组的元素，pos存放原始位置，
u013365671·2014-05-11 21:00

PKU Ultra-QuickSort （树状数组求逆序数）

题意：就是求逆序数；思路：我们用一个结构体保存数列的值和下标（num，id）；然后对num从大到小排列，算出num之前比num的id还要小的个数，即a[i]>a[j]&&i #include #include #include #include #include #include #include #include #include #include usingnamespacestd; #def
u012861385·2014-04-26 10:00

poj 2299 Ultra-QuickSort （离散化，树状数组，逆序对）

小记：看到这题感到莫名的熟悉感，大概是因为蓝桥杯最后一题也是求这样的逆序对吧，而我写的解题报告也是用树状数组实现的。所以直接动手思路：题意就是求一个序列中的逆序对数，hdu2689和这个题类似（点击看那题的解题报告），只不过这题的数比较大，不能直接对元素数用树状树状，为此我们必须离散化，离散化是，用一个结构体数组，其保存元素值和次序id：structnode{ intnum,id; }a[MAX_
ljd4305·2014-04-13 10:00

POJ 2299 Ultra-QuickSort（树状数组+离散化处理）

DescriptionInthisproblem,youhavetoanalyzeaparticularsortingalgorithm.Thealgorithmprocessesasequenceofndistinctintegersbyswappingtwoadjacentsequenceelementsuntilthesequenceissortedinascendingorder.Fort
gemire·2014-03-20 18:00

POJ 2299 Ultra-QuickSort(树状数组+离散化 或 归并排序求逆序)

POJ2299Ultra-QuickSort(树状数组+离散化或归并排序求逆序)http://poj.org/problem?id=2299题意：给你一个n个整数组成的序列，每次只能交换相邻的两个元素，问你最少要进行多少次交换才能使得整个整数序列上升有序。分析:因为交换相邻的元素只会序列的逆序数减1，到最后的有序数列是没有逆序数的。所以我们只需要计算初始序列有多少逆序，就可以知道要多少操作了。有人
u013480600·2014-03-15 10:00

POJ 2299 Ultra-QuickSort

题目链接：POJ2299Ultra-QuickSort乍一看是冒泡排序，不过用冒泡排序会超时。仔细想想其实就是求逆序对总数。用分治法（归并排序改一下）可以做。还可以用树状数组做，不过0≤a[i]≤999,999,999范围太大了，这里用到了离散化的思想，下面引用别人的解释：离散化，是数据范围太大是所借用的利器，举个例子，有四个数9999999911231583数据范围太大，而树状数组中的c数组开的
fobdddf·2014-03-10 18:00

[POJ 2299] Ultra-QuickSort (逆序对的数目)

Ultra-QuickSort题目链接：http://poj.org/problem?
SIOFive·2014-03-10 01:00

POJ - 2299 Ultra-QuickSort （归并排序）

题意：给你一个序列，让你求出这个序列的逆序数思路：归并排序的应用，将一个序列分成左右两个部分，当右边退出的话，那么此时左边还有几个，就代表这个数有几个逆序数#include #include #include #include usingnamespacestd; constintMAXN=1000010; inta[MAXN],t[MAXN],n; longlongsum; voidmerg
u011345136·2014-03-04 22:00

归并排序求 逆序对数 TOJ 1455 Ultra-QuickSort

题目就是让求数组中，逆序数对的个数，比如说，，9，1，0，5，4 就有（9，1）（9，0）（9，4）（9，5）（1，0）（5，4）6对；如果直接暴力搜索的话，O（n^2）会超时；借用归并排序的高效性，以及过程也是比较大小，便可以用来求逆序数对；可以直接套用归并排序的模版来用，注意几个问题:这个题，数据量比较大，最后结果是longlong型的，然后大数组最好都是在main（）函数外面； 代码：#in
u013652219·2014-03-01 22:00

poj 2299 Ultra-QuickSort（树状数组+离散化的题目）据说是简单题，不过还是觉得好难。。。

1、http://poj.org/problem?id=22992、题目大意：一个序列有n个数字，他们是无序的，现在要将这些数字交换顺序，使得他们是从小到大排列的，输出最少交换几次，3、思路分析如果数字个数很小的话，实际上是可以用冒泡排序的，冒泡交换的步数实际上就是所求，但是数据很大，所以不能这么做，看网上解题报告用树状数组解决，作为第一个树状数组的题目，真心觉得好难，还得继续看，还有一个问题就是
sdjzping·2014-02-25 17:00

poj 2299 Ultra-QuickSort 题解

DescriptionInthisproblem,youhavetoanalyzeaparticularsortingalgorithm.Thealgorithmprocessesasequenceofndistinctintegersbyswappingtwoadjacentsequenceelementsuntilthesequenceissortedinascendingorder.Fort
u013724185·2014-02-22 13:00

uva 10810 - Ultra-QuickSort(排序)

题目链接：uva10810-Ultra-QuickSort题目大意：给出一个序列，每次交换两个数，这两个数之间的距离就是代价，问说要将序列排序的总代价是多少。解题思路:归并排序下的逆序数的个数。#include #include constintN=500005; typedeflonglongll; intn,g[N],f[N]; llMsort(intl,intr,int*a,int*b)
u011328934·2014-01-23 20:00

UVA 10810 - Ultra-QuickSort（树状数组+离散化求逆序对)

ProblemB:Ultra-QuickSortInthisproblem,youhavetoanalyzeaparticularsortingalgorithm.Thealgorithmprocessesasequenceof ndistinctintegersbyswappingtwoadjacentsequenceelementsuntilthesequenceissortedinascen
u011217342·2014-01-22 10:00

10810 - Ultra-QuickSort（归并排序求逆序数）

ProblemB:Ultra-QuickSortInthisproblem,youhavetoanalyzeaparticularsortingalgorithm.Thealgorithmprocessesasequenceof ndistinctintegersbyswappingtwoadjacentsequenceelementsuntilthesequenceissortedinascen
u011217342·2014-01-20 19:00

POJ 2299 Ultra-QuickSort 求逆序对数（归并排序，树状数组）

Ultra-QuickSortTimeLimit:7000MS MemoryLimit:65536KTotalSubmissions:36281 Accepted:13078DescriptionInthisproblem,youhavetoanalyzeaparticularsortingalgorithm.Thealgorithmprocessesasequenceofndistinctint
u011400953·2013-12-15 11:00

poj 2299 Ultra-QuickSort

归并排序求逆序对数(不能理解图片乱入...)Ultra-QuickSortTimeLimit: 7000MSMemoryLimit: 65536KTotalSubmissions: 36250Accepted: 13066DescriptionInthisproblem,youhavetoanalyzeaparticularsortingalgorithm.Thealgorithmprocesse
locusxt·2013-12-11 13:00

(应用排序算法编程7.2.2)POJ 2299 Ultra-QuickSort(使用归并排序来计算逆序对的个数)

/* *POJ_2299.cpp * *Createdon:2013年11月1日 *Author:Administrator */ #include #include usingnamespacestd; constintmaxn=500010; typedeflonglonglolo;//这里不要使用int,因为a[i]的范围达到了999999999。在最坏的情况下,需要交换的次数已经不
caihongshijie6·2013-11-01 11:00

POJ 2299 Ultra-QuickSort

转载请注明出处：忆梦http://blog.csdn.net/yimeng2013/article/details/13033965题目链接：http://poj.org/problem?id=2299题意：有n个数，进行升序排列，每次只能移动相邻的两个数，问最少需要操作多少次题解：典型的树状数组求逆序数问题。#include #include #include #include usingnam
fjy4328286·2013-10-25 21:00

UVa 10810 - Ultra-QuickSort

题目：给出一个数列，每次交换相邻数字，求排成递增序的最少交换次数。分析：逆序数。排序最少交换次数：1.相邻交换，为逆序数；随意交换，为总数减环个数。      证明：每次相邻交换时，逆序数减1或者加1，所以最优情况下，逆序数为交换次数下界。            存在性，每次找到逆序对交换即可构造出一种下界。注意：使用long类型即可。#include #include #include usi
mobius_strip·2013-10-11 20:00

POJ 2299 Ultra-QuickSort

特殊的快速排序——归并排序。给定N个数，求排成升序序列所需要的最小交换次数。每次只能交换相邻的两个数。作为一名《线性代数》只考了60+的选手竟然一眼就看出要求逆序数有木有，可是我不会求啊有木有，搞来搞去还是要用归并排序啊有木有。T^T归并排序的主要思路：归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（DivideandConquer）的一个非常典型的应用。首先考虑下如何将将二个
u012161037·2013-09-18 15:00

POJ 2299 Ultra-QuickSort

逆序对问题，（单点更新，区间查询），从左到右扫已知的数有多少个比当前数大。/* Author:Speedcell Update:2013-05-30 Version:soppYcell2.2(a) */ #include #include #include #include #include #include #include #include #include #include #inclu
speedcell4·2013-09-06 15:00

POJ 2299 Ultra-QuickSort（归并排序）

题目链接:Ultra-QuickSort解题思路:之前一直没有自己动手写过归并排序，这个题目数据量很大归并排序平均复杂度为nlogn，又可以利用来求逆序数。这个题就是求逆序数（线性代数中有写）。
u010787640·2013-08-21 12:00

树状数组的离散化 Ultra-QuickSort

离散化，但数据范围太大是所借用的利器，举个例子，有四个数9999999911231583数据范围太大，而树状数组中的c数组开的范围是数据的范围，这时候就需要离散化，把四个数一次标号为1234（即第一个数，第二个数。。。），按键值排序之后依次为2341（即从小到大排序为第二个数，第三个数。。。），所以，第二个数是最小的，即f[2]=1,f[3]=2,f[4]=3,f[1]=4,也就是把键值变为了1~
haha593572013·2013-08-19 18:00

poj 2299 Ultra-QuickSort

点击打开poj2299思路:离散化+树状数组分析:1题目的意思就是要求逆序数对2题目的输入个数有500000的规模但是每个数的最大值为999999999，因此我们需要离散化这些数据3对于数据91054我们离散化成52143那么对于输入一个树a[i]我们去求一下它的离散化后的id，然后去求前面比这个id大的个数4由于getSum(x)函数的求和是求[1,x]而不是[x，MAXN),所以我们可以换成求
cgl1079743846·2013-08-12 16:00

POJ:2299 Ultra-QuickSort(归并排序/树状数组)

要移动元素的次数实质就是逆序对数。这个在入门经典上有详细解释，归并排序一改就ok了。这里我们首先应该明确一个问题，前后两段内部的元素位置并不影响两个分别来自前后两段元素的逆序性，简单点说，a来自前段，b来自后端，如果（a，b）是个逆序对，那无论a，b在其段内怎么移动，（a，b）仍是逆序对。所以这个问题的解法就是用前段的逆序对数加上后段的逆序对数，再加上合并之后的的逆序对数，很明显这是一个递归过程。
kkkwjx·2013-08-06 13:00

poj 2299 Ultra-QuickSort

Ultra-QuickSortTimeLimit: 7000MS MemoryLimit: 65536KTotalSubmissions: 33807 Accepted: 12101DescriptionInthisproblem,youhavetoanalyzeaparticularsortingalgorithm.Thealgorithmprocessesasequenceofndistinc
y5885922·2013-08-03 23:00

poj2299 - Ultra-QuickSort (求逆序数)

 题意：给出长度为n的序列，每次只能交换相邻的两个元素，问至少要交换几次才使得该序列为递增序列。我们需要知道：逆序数=在只允许相邻两个元素交换的条件下,得到有序序列的交换次数所以我们需要求数列的逆序数，O（N*N）的算法肯定会超时的，所有我们寻求较为高效的排序方法，归并排序就是充分利用分治法的而提高效率的排序方法。归并排序：#include #defineM500005 intn,s[M]; lo
shankeliupo·2013-07-28 15:00

POJ 2299 - Ultra-QuickSort 统计逆序对

 可以交换相邻的数，问最少交换几次后数列变成非降的.. 对于每个数若小于左边的数与左边的数交换..大于右边的数与右边的数交换...如此可以推出所求的答案等价为这个数列的逆序数... 如果暴力查找逆序数是O(n^2)的...对于此题数据.不可接受... 采用分治的思想...在归并排序的过程中边排序边统计逆序数的个数...Program:#include #include #include #incl
kk303·2013-07-20 16:00

poj2299 Ultra-QuickSort

........................................................................................................................................................................................................
u010138811·2013-07-14 23:00

poj 2299 Ultra-QuickSort (树状数组解法)

Ultra-QuickSortTimeLimit: 7000MS MemoryLimit: 65536KTotalSubmissions: 32746 Accepted: 11691DescriptionInthisproblem,youhavetoanalyzeaparticularsortingalgorithm.Thealgorithmprocessesasequenceofndistinc
u010228612·2013-06-09 10:00

Hdu 1394 Minimum Inversion Number、Poj 2299 Ultra-QuickSort

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1394题意：求某种规定序列中的最小逆序数。递推比较最小那部分比较简单，就不说了。主要想说：求逆序数可以用构建线段树的方法来做。其实思想和计数排序的思想差不多。每次处理a[i]时，先统计一下已经被计数的前几个数的计数和。（比较的是值。）然后再更新这个计数和。这道题的数据范围和下标范围是一样的，所以可以直接
niuox·2013-06-06 17:00

数据结构

==================================[排序与查找]==================================归并排序与逆序数POJ2299:Ultra-QuickSort
l383137093·2013-05-18 19:00

POJ2299:Ultra-QuickSort

点击打开题目链接Ultra-QuickSortTimeLimit: 7000MS MemoryLimit: 65536KTotalSubmissions: 32289 Accepted: 11493DescriptionInthisproblem,youhavetoanalyzeaparticularsortingalgorithm.Thealgorithmprocessesasequenceof
l383137093·2013-05-04 21:00

poj 2299 Ultra-QuickSort 求逆序数 树状数组解法

题目链接   逆序的概念大家都知道，一个数到逆序数就是该数左边大于它到数的个数。   很多没学过数据结构的人一上来肯定就是一个个数了，看看数据量500k，显然这种暴力的方法是行不通的。   我们换种想法，可以在输入过程中对每个数的逆序数求解，建一个vis数组（初始化为0），只要输入一个数，在它的位置标记为1，然后计算出它的左边一共有多少数被标记了就可以知道多少个数比他小了，当然逆序数也就知道了，求
xindoo·2013-04-25 16:00

POJ2299《Ultra-QuickSort》方法：归并排序找逆序数

题目大意：求一个数的逆序数，比如54321的逆序数为4+3+2+1+0=10，逆序数=在只交换相邻两数的前提下，需要的交换次数。解题思路：因为这题数据量为50W，时间限制为7000ms，用冒泡排序找相邻交换次数肯定超时，因此用归并排序找相邻交换次数。之所以不用快速排序，是因为它不符合相邻元素交换的要求。//3748k2454ms#includeusingnamespacestd;constinti
相门码农·2013-03-22 13:56

POJ 2299 Ultra-QuickSort 【归并排序 || 树状数组求逆序对数】

原题链接：http://poj.org/problem?id=2299Ultra-QuickSortTimeLimit: 7000MS MemoryLimit: 65536KTotalSubmissions: 31043 Accepted: 11066DescriptionInthisproblem,youhavetoanalyzeaparticularsortingalgorithm.Theal
Cfreezhan·2013-03-08 21:00

POJ 2299 Ultra-QuickSort

大意：将无序的序列通过两两交换最少需要几次才能有序。思路：可以证明即数列的逆序对数，于是归并排序求解。#include #include #include #include #include usingnamespacestd; constintMAXN=500010; intn; typedeflonglongLL; LLA[MAXN],T[MAXN]; voidmerge_sort(
Wall_F·2013-02-18 14:00

【一题三解】POJ2299 Ultra-QuickSort （归并排序法）

题目：点击打开链接这个题给出了500000个样例组，数据最大到1E，求这一串序列的逆序数。逆序数的定义不多说，详见线性代数。表示有好几种方法可以解决这个问题，如树状数组、线段树、归并排序等。归并排序是最接近模板法的，因为排序的结构决定了它是在相邻两个数之间进行的比较。很容易MLE的，如果数组开的过大或者过小的话。部分参阅了标准模板。/************************ *Functi
mig_davidli·2013-01-24 17:00

POJ 2299 Ultra-QuickSort

求快排的交换次数，也就是逆序数写个归并排序来算就ok了，注意逆序数会超int#include #include #include #include usingnamespacestd; longlonga[500100],b[500100]; longlongMergeSort(longlongs,longlonge) { longlongmid,cnt,t1,t2,i; if(
sssogs·2012-11-17 02:00

poj 2299 Ultra-QuickSort（线段树，离散化求逆序数）

题目链接：http://poj.org/problem?id=2299分析与总结：一看到这题的第一反应就觉得是求逆序数==|先用归并排序求逆序数AC之，这应该是速度最快的一种求逆序数方法，391MS然后用树状数组做，因为每个元素范围0≤a[i]≤999,999,999， 太大了，所以我用map离散化了，结果超时了...后来发现，其实不需要用map来映射，之所以用map是应为元素的值太大了，但是其实
shuangde800·2012-11-13 22:00

poj 2299 Ultra-QuickSort（线段树，离散化求逆序数）

题目链接： http://poj.org/problem?id=2299 分析与总结： 一看到这题的第一反应就觉得是求逆序数 = =| 先用归并排序求逆序数AC之，这应该是速度最快的一种求逆序数方法，391MS 然后用树状数组做，因为每个元素范围0 ≤ a[i] ≤ 999,999,999， 太大了，所以我用map离散化了，结果超时了... 后来发现，其实不需要用map来映射，之所
king_tt·2012-11-13 22:00

poj2299 Ultra-QuickSort

#include #include #include #include usingnamespacestd; intn; structnode { intval; intnum;//编号 }inPut[500050];//用于处理输入的数组 inta[500050];//离散化后的数组 intc[500050];//数状数组 intlowbit(inti) { returni&(-1*i); }
zhangwei1120112119·2012-10-27 23:00

POJ 2299 - Ultra-QuickSort

——byACodeRabbitDescription输入一个序列，求序列的逆序数。TypeMergeSortAdvancedDataStructures:: SegmentTreeAdvancedDataStructures:: BinaryIndexedTreeAnalysis求逆序数，用树状数组来做。不过求逆序数的题目按惯例说应该用归并排序比较正宗。况且这道题用树状数组还需要离散化，离散化也需
Ra_WinDing·2012-09-15 16:00

POJ2299 Ultra-QuickSort

原题传送：http://poj.org/problem?id=2299归并排序求逆序数，nlog(n)，500多ms。答案最大可以达到n*(n+1)/2，要开longlong。ViewCode1#include 2#include 3#defineN500005 4#defineLL__int64 5LLa[N],b[N]; 6intn; 7 8LLcal(LLs,LLt) 9{
·2012-09-14 12:00

[树状数组] PKU 2299 Ultra-QuickSort

[树状数组]PKU2299Ultra-QuickSort维护名次即可（不需要离散化）。# include # include # include using namespace std;# define N 500005typedef long long int LL;int n;LL a[N];int r[N], s[N], c[N];/*****************************
CSniper·2012-09-02 17:00

POJ 2299 Ultra-QuickSort

DescriptionInthisproblem,youhavetoanalyzeaparticularsortingalgorithm.Thealgorithmprocessesasequenceofndistinctintegersbyswappingtwoadjacentsequenceelementsuntilthesequenceissortedinascendingorder.Fort
ultimater·2012-08-26 10:00
上一页 1 2 3 4 5 下一页
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他