1394 motherboard

return ; - intMid= (first+end) >>1; -Build (rt1, first,mid); -Build (rt1|1, mid+1, end); + } - intQuary (intRtintFirstintEndintLeftintRight ) + { A if(Leftend) at returnSum[rt]; - intMid= (first+end) >>1; - intans=0; - if(leftmid) -Ans+=quary (rt1, first,mid,left,right); - if(right>mid) inAns+=quary (rt1|1, mid+1, end,left,right); - returnans; to } + voidUpdateintRtintFirstintEndinta) - { the if(first==end) * { $sum[rt]++;Panax Notoginseng

the number of reverse order in its own sequence, and then determine whether each element is placed in the last one when the number of reverse order is less than the number of reversed sequence, successive updates. #include #includestring.h>#includeusing namespacestd;Const intinf=0x3f3f3f3f;Const intn=5010;structnode{intLeft , right, num;} no[4*N];intMin;voidBulid (intLeftintRightintroot) { intmid; No[root].left=Left ; No[root].right=Right ; No[root].num=0; if(left = right)return ; Mid= (left

initial sequence number, the reverse number of the next sequence is handed out 1. When traversing to the current sequence element, the query from this element to the n-1 interval of the reverse and, that is, the element is greater than the element has appeared several (inverse reverse, but the result The node and its parent node are then updated.　　Traversing to the end, you can find out the reverse order of the sequence. 2. Since it is starting from 0 consecutive numbers for reverse order, so,

arrangement of length n (composed of 0 to n-1), each time you can put the first element to the last surface, then will produce the reverse number, a permutation of the number of reverse is equal to the permutation of all the numbers in the inverse number of the sum. So, this problem, can be solved with the line segment tree, we first establish an empty tree, that is, the sum==0 of each node in the tree, representing all 0, and then, each time we insert a number, in the corresponding position of

Test instructions: There is a sequence of length n, the number of the sequence is a 0~n-1 composition, and then this sequence can be considered as a ring, then there is n a sequence of n length, ask the number of the smallest in the n sequence.First, the initial sequence of the reverse number of the calculation, and then move each start number A to the back, the reverse number of changes is larger than a number of numbers plus one, less than a small number of reverse order minus one, so accordin

DescriptionThe inversion number of a given number sequence A1, A2, ..., is the number of pairs (AI, AJ) that satisfy I For a given sequence of numbers a1, A2, ..., an, if we move the first m >= 0 numbers to the end of the seqence, we'll Obtain another sequence. There is totally n such sequences as the following:A1, A2, ..., An-1, an (where m = 0-the initial seqence)A2, A3, ..., an, A1 (where m = 1)A3, A4, ..., an, A1, A2 (where m = 2)...An, A1, A2, ..., an-1 (where m = n-1)You is asked to write

], the number of inverse sequence will be reduced t[i], corresponding increase n (t[i]+1)If the violence, the estimate will time out, so just use the number of line segments, note that line tree is just a tool,!!On the code:#include #include using namespace STD;Const intmaxn=5005;intNUM[MAXN];struct{intL, R, Num;} tree[4*MAXN];voidBuildintRootintLintR) {tree[root].l=l; Tree[root].r=r; tree[root].num=0;if(L = = r)return;intMid= (L + R) >>1; Build (root1, L, mid); Build (root1|1, mid+1, r);}voi

); in } the the intQueryintLintRintLintRintRT) About { the if(lR) the { the returnSum[rt]; + } - intM= (l+r) >>1; the intret=0;Bayi if(lquery (L,r,lson); the if(r>m) ret+=query (L,r,rson); the returnret; - } - the intX[MAXN]; the intMain () the { the //Read (); - intN; the while(~SCANF ("%d",N)) the { theBuild0, N-1,1);94 intans=0; the for(intI=0; i) the { thescanf"%d",x[i]);98Ans+=query (x[i],n-1,0, N-1,1); Abou

number can be introduced its next sequence of reverse number. The inverse number of the next sequence is regular sum = the previous Sum-a[i]-1-a[i]; If you come up with something like:Sequence 3 6 9 0 8 5 7 4 2 1 Move 3 to the back, then it will reduce the number of reverse order by 3 (0 2 1) but also increase n-a[i]-1.How many times do you ask for it to occur in 1? Specifically, the update function principle is that, from the beginning of the update, each loss of a number in its corresponding

: first use the line tree or tree array to pre-process the original reverse order and, and then launch one by one. The New Reverse Order and generated after each operation, for example, the reverse order at the beginning is 22. If you set 1 to the end, in the past, there was one number smaller than 1 after 1, and this number is 0. When 1 is adjusted to the next, there were eight numbers bigger than 1 before 1, if it is 3, 6, 9, 8, 5, 7, 4, 2, then the reverse order of the new sequence is 22-1 +

Question link: Http://acm.hdu.edu.cn/showproblem.php? PID = 1, 1394 Question: For the number of N numbers composed of the N numbers 0-n-1, define a number in reverse order (the number above is greater than the number below ). Move the first number to the last position to obtain a new sequence and a new number of reverse orders. You can move n-1 times in total to obtain n reverse orders and ask what the minimum number of these N reverse orders is. So

Http://acm.hdu.edu.cn/showproblem.php? PID = 1, 1394 The line segment tree calculates the reverse order number. First, the reverse order number (n logn) of the initial array is obtained, and then O (1) releases other Reverse orders. Because the input is 0 -- n-1, the build starts from 0. Code: # Include # Include # Include # Include # Include # Include # Include # Include # Include # Include # Include # Include # Include # Include # Include # Include

HDU 1394 Minimum Inversion Number (tree array) Analysis:First, this is the problem of solving the reverse order number. First, we need to know what the reverse order number is? In an arrangement, if the front and back positions of a pair of numbers are in the opposite order of size, that is, the front number is greater than the back number, they are called a reverse order. The total number of reverse orders in an arrangement is called the number of

HDU 1394 Minimum Inversion Number (tree array | Line Segment tree) Question link: Click the open link For the problem of calculating the number of reverse orders, we usually use a line segment tree or a tree array for maintenance. The tree array code is short and easy to write. Try to write a tree array. First, find the number of reverse orders in the original arrangement. For each operation, because the first number in the current arrangement is obta

HDOJ 1394 Minimum Inversion Number calculates the Minimum Number of reverse orders of cyclic strings (violent line segment tree)Minimum Inversion NumberTime Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)Total Submission (s): 14879 Accepted Submission (s): 9082Problem Description The inversion number of a given number sequence a1, a2,..., an is the number of pairs (ai, aj) that satisfy I For a given sequence of numbers a1,

Address: HDU 1394 You can use the line segment tree to calculate the number of reverse orders. The maintenance information of this question indicates whether each number has been displayed. After each input, the query is performed from the value of the point to n-1. Each time a number is found, because it is found after the number, this number must be larger than this number. That is, a pair of reverse orders, and then the number of reverse orders +

one, at this time the total number of Reverse Order increased the n-1-a-a; I think there are two ways to think of it: 1. Normal search, but the test data is 5000, too large, and every time you look for the number of reverse orders, you have to move one back, Tl, it is highly probable. Give up on this idea. 2 "Line Segment tree, you only need to find the reverse Number of the initial array, You Can recursive the reverse number of other series (according to the above technique ); AC by SWS Que

{ the inti,j,ans,min; + while(cin>>t) - { $ans=0; $Memset (c,0,sizeof(c)); - for(i=1; i) - { thescanf"%d",num[i].val); -num[i].tag=i;Wuyi } theSort (num+1, num+t+1, CMP); - for(i=1; i) Wu { -R[num[i].tag]=i;//be discretized About } $ for(i=1; i) - { - Update (r[i]); -ans=ans+i-s (r[i]); A } +min=ans; the for(i=1; i) - { $ans=ans-r[i]+1+t-R[i]; theMin=ansans:min; the } theprintf"%d\n"

smallest number of reverse order is how manyExercisesAh, the largest number is N, the first number is thrown to the end, then the number of reverse order reduced num[i]-1, but increased the n-num[i], then just do it!Code://Qscqesze#include #include#include#include#include#include#includeSet>#include#include#include#include#include#includetypedefLong Longll;using namespacestd;//freopen ("d.in", "R", stdin);//freopen ("D.out", "w", stdout);#defineSspeed ios_base::sync_with_stdio (0); Cin.tie (0)#

the environment is too humid, the motherboard is very easy to deform and resulting in poor contact and other problems, affecting your normal use. In addition, in the assembly of computers, fixed the motherboard screws do not tighten too tightly, each screw should be the same intensity, if screwed too tightly also easy to make the motherboard deformation. Genera