【CQMTC2015#1】兔子

Description

有一片无限大的草地，其可以用平面直角坐标系的第一象限表示，坐标系的其余部分均为沙漠，沙漠很危险所以兔子们都不能去。草地上有 n 只兔子和 n个兔穴，每个兔穴仅能容纳一只兔子。狼是兔子们最大的天敌。每天，每只兔子会在草地上的某个特定位置吃草，当狼来捕食时，兔子们便开始逃跑。当前处在(x,y)的兔子，下一步可以到达(x-y,y),(x,y-x),(x+y,y),(x,x+y)这四个位置中的任意一个。任何时刻兔子都不能到达沙漠区域，即不能到达在坐标轴上或其他象限内的位置。如果兔子所在的位置下有空着的兔穴，兔子就可以钻进兔穴里，从而躲避狼的追击。古人云“狡兔三窟” ，兔子们很聪明，虽然他们没有挖到更多的兔穴，但是他们已经商量好，当狼来捕食的时候，不必逃到自己的兔穴，可以临时躲到其它兔子的兔穴。经过不断实践，兔子们发现，当所有兔子到达兔穴的步数总和最小时，兔子们是最安全的，尽管有的兔子可能要跑较多的步数。给出 n 只兔子吃草的位置和 n 个兔穴的位置，请你求出所有兔子到达兔穴的最小步数和。

Input

第一行为一个正整数 n，为兔子的数目和兔穴的数目。
接下来 n 行，每行两个正整数，描述一只兔子吃草的位置坐标。
接下来 n 行，每行两个正整数，描述一个兔穴的位置坐标。
数据保证任意的一只兔子都可以到的任意的兔穴。

Output

输出仅一行，为一个整数，即所有兔子到达兔穴的最小步数和。

Sample Input

2
4 1
3 2
1 3
3 4

Sample Output

4

Hint

【样例解释】

第一只兔子从(4,1)跳到(3,1)再跳到(3,4)，到达其中一个兔穴；
第二只兔子从(3,2)跳到(1,2)再跳到(1,3)，到达另一个兔穴。
步数为 2+2=4，不难验证最优性。

【数据范围】

设最远的一对兔子兔穴相距 K 步。
测试点 1-2：n=1，K≤60；
测试点 3-4：n=1，K≤2*10^9；
测试点 5-7：n=200，K≤60；
测试点 8-10：n=200，K≤2*10^9；
测试点 11-15：n=10000，K≤60；
测试点 16-20：n=10000，K≤2*10^9。
对于所有测试点，所有坐标都在 1 到 10^18
之间，坐标可能有重复。

Source

from nodgd

Solution

第一眼看到移动方法，怎么长得这么像更相减损术……往下拉，差点没被数据范围吓到。仔细想想，首先，所有数除一个最大公约数，然后，显然的是，我们让兔子和兔穴都能动，最后都能走到(1,1)，当然，有可能还没到(1,1)就遇上了，遇上前一定有一个坐标是相等的。所以，我们可以用一次辗转相除法，在 O(logx+logy) 的时间复杂度内算出某一只兔子到某一个洞穴所需步数，仔细一看，有50分n<=200，暴力枚举可以算出来。然后再考虑后面的做法，怎么总感觉有点像个二分图最优匹配……
想到这里我就发现我想偏了，因为标解明显不是这么做，又回到移动这一步，发现对于每一个坐标，按照更相减损术的方式往(1,1)走明显只有唯一的一条路径，而全部n个点放在一起明显是颗树，有50分K<=60，意味着暴力建树是有50分的，剩下50分K<= 2∗109 ，这之中明显有很多废点，要是能跳过去，有效点还是只有60个。
假设我们建好了树，因为题目求的是步数和，显然满足一个贪心，那就是，如果某颗子树上只有一只兔子和一个兔穴，如果不让这只兔子去这个兔穴，这一决策明显是不优的。如果有两只兔子和一个兔穴，那么就还有一只兔子要从这颗子树往根节点，也就是(1,1)的方向继续走，这明显是一个很NOIP普及组难度的树型DP。
好了，思路理清，开始敲代码，输入没什么问题，输完了随便找个点做一个gcd，然后所有点一起除。
输入完开始建树，先找有效点，如果当前点是(1,10)，九步后跳到(1,1)，对于这一个点，(1,2)到(1,9)明显是没什么用的，所以就把每个点的坐标做一次辗转相除法，把每一步的坐标记下来，注意前后顺序不能换，因为(1,2)和(2,1)是两个不同的点，所以一共有 n∗(logx+logy) 个点。
点找完开始建树，开始建树，建树，树……我去，怎么建，我好像建不来，这气氛有点尴尬，我是逃不掉爆零的命运了？看来我要破产了/(ㄒoㄒ)/~~
并没有什么思路，没事做，那就先sort一遍吧，先按x排，排完按y排。不排不知道，一排吓一跳。好像排完就可以建了，编号小的点不会再编号大的点为根的子树中，而建树过程只需给每个节点找它的爸爸。
取当前点的坐标，做辗转相除法的一步(语文不及格，不知道怎么表述)，得到一个父亲节点的坐标，然而我不知道编号，当然，这很简单，二分，hash，set……反正差不多，找到就行。找到就完了吗，当然没有！因为当前点跳到父节点的路上有可能有其他点会并进来，例如：当前点是(7,3)，要跳到(1,3)，同时又有个点(4,7)跳到了(4,3)，根据上面的贪心，(4,3)作为一个有效点，(7,3)显然是不能跳过它的，但我们的算法又只能得到(1,3)。这怎么办呢?显然的是，(4,3)一定在(7,3)前被访问到，如果(7,3)跳到(1,3)图中有其它点，我可以在访问到(7,3)之前处理一下，因为(7,3)到(1,3)可以视为一条很长的链，而从(1,3)发出的，不拐弯的链只有两条：(x,y)→(x+y,y)并一直重复或(x,y)→(x,x+y)并一直重复。所以，我们记下每个点(x,y)发出的两条链上出现过的最晚的那个点，如果在这条链上再来一个点，一定是被加在末端，而新加入点的实际父节点就是记下的最晚出现的点，然后新加入点又成为新的最晚出现的点。再然后，记下每个点到父节点需要的步数，树就建完了。
对于每只兔子，在对应节点上记下兔子数+1，对于每个兔穴，在对应节点上记下兔子数-1，从叶子节点往根节点跑一遍DP，每个节点的兔子数加给它的父节点，即每个节点记以该点为根的子树的兔子数，全局再记一个ans。对于每个节点如果兔子数不为0，无论正负，最优解一定有该点兔子数的绝对值这么多次经过该点到父节点这条边，每个点累加，就得到了最后的答案。
整个程序的核心是在建树，总共有 n∗(logx+logy) 个点，如果不是hash，每个点要花 O(log(n∗(logx+logy))) 的时间复杂度找到父亲节点的编号，总时间复杂度近似认为是 O(nlog2n) 。

#include
#include
#include
#include
using namespace std;
struct node{long long a,b,c1,c2,d,f,v;} a[3000000],a1[10002],a2[10002];
int n,cnt,i,j,l,r,m;
long long ans,x,y,z;
bool cmp(node a,node b)
{
    if(a.a==b.a) return a.b.b;
    return a.a.a;
}
int main()
{
    scanf("%d",&n);
    for(i=1;i<=n;i++) scanf("%lld%lld",&a1[i].a,&a1[i].b);
    for(i=1;i<=n;i++) scanf("%lld%lld",&a2[i].a,&a2[i].b);
    x=a1[1].a;
    y=a1[1].b;
    while(y)
    {
        z=x%y;
        x=y;
        y=z;
    }
    for(i=1;i<=n;i++)
    {
        a1[i].a/=x;
        a1[i].b/=x;
        a2[i].a/=x;
        a2[i].b/=x;
    }
    cnt=1;
    a[1].a=1;
    a[1].b=1;
    for(i=1;i<=n;i++)
    {
        x=a1[i].a;
        y=a1[i].b;
        do
        {
            cnt++;
            a[cnt].a=x;
            a[cnt].b=y;
            if(x>=y) x%=y;
            else y%=x;
        }while(x&&y);
    }
    for(i=1;i<=n;i++)
    {
        x=a2[i].a;
        y=a2[i].b;
        do
        {
            cnt++;
            a[cnt].a=x;
            a[cnt].b=y;
            if(x>=y) x%=y;
            else y%=x;
        }while(x&&y);
    }
    sort(a+1,a+cnt+1,cmp);
    for(i=1,j=0;i<=cnt;i++)
    {
        if(a[i].a!=a[i-1].a||a[i].b!=a[i-1].b)
        {
            j++;
            a[j].a=a[i].a;
            a[j].b=a[i].b;
        }
    }
    cnt=j;
    a[1].c1=a[1].c2=1;
    for(i=2;i<=cnt;i++)
    {
        a[i].c1=a[i].c2=i;
        x=a[i].a;
        y=a[i].b;
        if(x>y) x%=y;
        else y%=x;
        l=1;
        r=i-1;
        while(l>1;
            if(a[m].a==x)
            {
                if(a[m].b>=y) r=m;
                else l=m+1;
            }
            else
            {
                if(a[m].a>x) r=m;
                else l=m+1;
            }
        }
        if(a[i].a>a[i].b)
        {
            a[i].f=a[r].c1;
            a[r].c1=i;
        }
        else
        {
            a[i].f=a[r].c2;
            a[r].c2=i;
        }
        if(a[i].a==a[a[i].f].a) a[i].v=(a[i].b-a[a[i].f].b)/a[i].a;
        else a[i].v=(a[i].a-a[a[i].f].a)/a[i].b;
    }
    for(i=1;i<=n;i++)
    {
        l=1;
        r=cnt;
        while(l>1;
            if(a[m].a==a1[i].a)
            {
                if(a[m].b>=a1[i].b) r=m;
                else l=m+1;
            }
            else
            {
                if(a[m].a>a1[i].a) r=m;
                else l=m+1;
            }
        }
        a[r].d++;
    }
    for(i=1;i<=n;i++)
    {
        l=1;
        r=cnt;
        while(l>1;
            if(a[m].a==a2[i].a)
            {
                if(a[m].b>=a2[i].b) r=m;
                else l=m+1;
            }
            else
            {
                if(a[m].a>a2[i].a) r=m;
                else l=m+1;
            }
        }
        a[r].d--;
    }
    for(i=cnt;i>1;i--)
    {
        ans+=a[i].v*abs(a[i].d);
        a[a[i].f].d+=a[i].d;
    }
    cout<;
    return 0;
}