poj 2188 Cow Laundry

Cow Laundry

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 1058		Accepted: 694

Description

The cows have erected clothes lines with N (1 <= N <= 1000) wires upon which they can dry their clothes after washing them. Having no opposable thumbs, they have thoroughly botched the job. Consider this clothes line arrangement with four wires: 

牛们用N (1 <= N <= 1000)根电线组了个晒衣绳用来晒衣服。由于没有对生手指（好吧，反正翻译是这么说的，牛没有，人有），他们没办法很好的完成这个任务。用四根电线拉成的晒衣绳如下

   Wire slot: 1   2    3    4

              ---------------   <-- the holder of the wires

              \    \  /    /

               \    \/    /

                \   /\   /       

                 \ /  \ /       <-- actual clothes lines

                  /    \

                 / \  / \

                /   \/   \

               /    /\    \

              /    /  \    \

              ---------------   <-- the holder of the wires

   Wire slot: 1   2    3    4

The wires cross! This is, of course, unacceptable.
电线纠缠到一起了！当然，这是很糟糕的......（我已经不知道在翻译神马了啊.....）
The cows want to unscramble the clothes lines with a minimum of hassle. Even their bovine minds can handle the notion of "swap these two lines". Since the cows have short arms they are limited to swapping adjacent pairs of wire endpoints on either the top or bottom holder. 

牛们希望用最少步骤来整理晾衣绳。好吧，牛似乎能够理解的概念就是“交换这些线其中的两条”。也就是说每次只能交换相邻的两条线
In the diagram above, it requires four such swaps in order to get a proper arrangement for the clothes line: 

在上面显示的那种混乱中，一共需要4次交换就能整理好晾衣绳如下。。

              1   2   3   4

              -------------   <-- the holder of the wires

              |   |   |   |

              |   |   |   |

              |   |   |   |

              |   |   |   |

              |   |   |   |

              |   |   |   |

              |   |   |   |

              |   |   |   |

              |   |   |   |

              -------------   <-- the holder of the wires

              1   2   3   4

Help the cows unscramble their clothes lines. Find the smallest number of swaps that will get the clothes line into a proper arrangement.
帮助牛们整理晾衣绳，并找到最少的交换次数。
You are supplied with clothes line descriptions that use integers to describe the current ordering of the clothesline. The lines are uniquely numbered 1..N according to no apparent scheme. You are given the order of the wires as they appear in the N connecting slots of the top wire holder and also the order of the wires as they appear on the bottom wire holder.

提供给你的是晾衣绳的上端数据和下端数据，数据排列从1...N。

Input

* Line 1: A single integer: N
第一行：一个单独的整数，N
* Lines 2..N+1: Each line contains two integers in the range 1..N. The first integer is the wire ID of the wire in the top wire holder; the second integer is the wire ID of the wire in the bottom holder. Line 2 describes the wires connected to top slot 1 and bottom slot 1, respectively; line 3 describes the wires connected to top and bottom slot 2, respectively; and so on.
第二行..N+1:每一行有两个整形数据从1..N。第一个整形是位于上边的电线ID，第二个就是下面的电线头ID。第一组数据就是说4号电线对应着1号电线。

Output

* Line 1: A single integer specifying the minimum number of adjacent swaps required to straighten out the clothes lines.

一个整形数据输出最小的交换次数。

Sample Input

4
4 1
2 3
1 4
3 2

Sample Output

4

Source

USACO 2003 Fall Orange

 

这道题的叙述很符合美国一贯的作风......繁杂不过好像蛮有趣，由于是交换相邻两条，于是顺理成章的变成了逆序数的问题。只要先把对应位置找好，然后就计算一下逆序数就可以了......
 

#include <iostream>
#include <cmath>
#include <algorithm>
#include <stdio.h>
#include <string.h>

#define MAXINT 1111
#define LENGTH 1111

void Merge_sort(int a[LENGTH], int p, int r);
void Merge(int a[LENGTH], int p, int q, int r);

int inve_sum = 0;

int main(void)
{
	int top[LENGTH], bottom[LENGTH], a[LENGTH];
	int N;

	//freopen("in.txt", "r", stdin);
	//freopen("out.txt", "w", stdout);

    while(scanf("%d", &N)!= EOF){
    	for (int i = 0;i < N;i ++){
        	scanf("%d %d", &top[i], &bottom[i]);
    	}
    	for (int i = 0;i < N;i ++){
        		for (int j = 0;j < N;j ++){
            		if (top[i] == bottom[j]){
                			a[i] = j;
				break;
			}
        		}
    	}
	inve_sum = 0;
    	Merge_sort(a, 0, N - 1);
    	printf("%d\n", inve_sum);
    }
    return 1;
}

void Merge_sort(int a[LENGTH], int p, int r){
    int q;
    if (p < r){
        q = (p + r) >> 1;
        Merge_sort(a, p, q);
        Merge_sort(a, q + 1, r);
        Merge(a, p, q, r);
    }
}

void Merge(int a[LENGTH], int p, int q, int r){
    int L[(LENGTH >> 1) + 1], R[(LENGTH >> 1) + 1];
    int n1 = 0, n2 = 0;

    for (int i = p;i <= q;i ++){
        L[n1++] = a[i];
    }
    L[n1] = MAXINT;

    for (int i = q + 1;i <= r;i ++){
        R[n2++] = a[i];
    }
    R[n2] = MAXINT;

    n1 = 0, n2 = 0;
    for (int k = p;k <= r; k++){
        if (L[n1] <= R[n2]){
            a[k] = L[n1];
            n1++;
        }else{
            a[k] = R[n2];
            inve_sum += q - p + 1 - n1;
            n2++;
        }
    }
}