解不定方程

原理如图所示：

解不定方程组的应用

例题一： The Balance(pku 2142)

现有一天平，质量为a和b的砝码，一直砝码数量不限且天平左右均可放砝码，现在要求在天平上称出质量为c的物品。

编程求一种可行方案。要求：放置的砝码数量尽可能少；当放置的砝码数量相同时，总质量尽可能的少。

输入：输入数据有多组，每组占一行，从左到右依次为a,b,c；其中a!=b,a<=10 000,b <=10 000,c<=50 000.输入数据以0，0，0终止

输出：对应每组输入输出满足题目要求的两个数据x, y,分别代表质量为a的砝码的数量和质量为b的砝码的数量。

输出样例：

Sample Input

700 300 200
500 200 300
500 200 500
275 110 330
275 110 385
648 375 4002
3 1 10000
0 0 0

Sample Output

1 3
1 1
1 0
0 3
1 1
49 74
3333 1

分析：

问题可以转化为求ax+by=c的一组整数解(x,y)。要求|x|+|y|尽可能小，若相等，则a|x|+b|y|尽可能小(x<0,表示砝码和物体放在同一侧)。

利用扩展欧几里得算法先求出不定方程的一组特解(x0,y0),l令g=gcd(a,b).  a0=b/g,  b0=a/g. 则通解为

x=x₀ + b/gcd*t

y=y₀ — a/gcd*t

我们可以得到这样的函数 |x|+|y|=|x₀ + b/gcd*t|+|y₀ — a/gcd*t| 因为我们知道a>b,所以x₀加得比y₀减得比慢。因此y₀占主导地位，

故当y₀ - a/gcd*t=0时|x|+|y|最小。我们可以枚举求解，寻找最小就行。

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
#define maxint 0x3f3f3f
long long abs(long long x)///取绝对值的函数
{
    if(x<0)
        return -x;
    return x;
}
long long exgcd(long long a,long long b,long long &x,long long &y)
{
    if(b==0)
    {
        x=1;
        y=0;
        return a;
    }
    long long ans=exgcd(b,a%b,x,y);
    long long temp=x;
    x=y;
    y=temp-a/b*y;
    return ans;
}
int main()
{
    long long a,b,c,temp;
    while(scanf("%lld%lld%lld",&a,&b,&c)!=EOF)
    {
        if(a==0&&b==0&&c==0)
            break;
        bool ifsub=0;///记录a,b是否交换
        if(a<b)
        {
            ifsub=1;
            temp=a;
            a=b;
            b=temp;
        }
        long long x0,y0;
        long long g=exgcd(a,b,x0,y0);///a,b的最大公因数
        x0=x0*(c/g);///求出二元一次方程组的特解
        y0=y0*(c/g);///(并非最小正整数解)
        long long t=y0*g/a;///|y0-a/g*t|==0时t的值
        long long min=maxint,ans,anst;///ans记录|x0|+|y0|的最小值，anst记录此时的t的取值
        for(long long i=t-10; i<=t+10; i++)
        {
            if(abs(x0+b/g*i)+abs(y0-a/g*i)<min)
            {
                ans=a*abs(x0+b/g*i)+b*abs(y0-a/g*i);
                anst=i;
                min=abs(x0+b/g*i)+abs(y0-a/g*i);
            }
            else if(abs(x0+b/g*i)+abs(y0-a/g*i)==min)///相等时比较总质量
            {
                if(a*abs(x0+b/g*i)+b*abs(y0-a/g*i)<ans)
                {
                    ans=a*abs(x0+b/g*i)+b*abs(y0-a/g*i);
                    anst=i;
                    min=abs(x0+b/g*i)+abs(y0-a/g*i);
                }
            }
        }
        if(ifsub==0)///ifsub==0表示a,b没有交换
        {
            printf("%lld %lld\n",abs(x0+b/g*anst),abs(y0-a/g*anst));
        }
        else///如果交换了，a前面的未知数变为y，所以此时y为a的数量
        {
            printf("%lld %lld\n",abs(y0-a/g*anst),abs(x0+b/g*anst));
        }
    }
    return 0;
}

例题二  跳蚤（pku 1091）

Z城市居住着很多只跳蚤。在Z城市周六生活频道有一个娱乐节目。一只跳蚤将被请上一个高空钢丝的正中央。钢丝很长，可以看作是无限长。节目主持人会给该跳蚤发一张卡片。卡片上写有N+1个自然数。其中最后一个是M，而前N个数都不超过M，卡片上允许有相同的数字。跳蚤每次可以从卡片上任意选择一个自然数S，然后向左，或向右跳S个单位长度。而他最终的任务是跳到距离他左边一个单位长度的地方，并捡起位于那里的礼物。
比如当N=2，M=18时，持有卡片(10, 15, 18)的跳蚤，就可以完成任务：他可以先向左跳10个单位长度，然后再连向左跳3次，每次15个单位长度，最后再向右连跳3次，每次18个单位长度。而持有卡片(12, 15, 18)的跳蚤，则怎么也不可能跳到距他左边一个单位长度的地方。
当确定N和M后，显然一共有M^N张不同的卡片。现在的问题是，在这所有的卡片中，有多少张可以完成任务。

输入：两个整数N和M(N <= 15 , M <= 100000000)。

输出：可以完成任务的卡片数。

分析：

假设卡片上的标号依次为a1,a2,a3,a4,......an,M,跳蚤对应号的次数分别为x1,x2,x3...,xn(x1为跳蚤跳了a1的次数),跳M个单位长度的次数为Xn-1,那么满足已知条件只需满足方程a1x1+a2x2+a3x3+.....+an*xn+M*xn-1=1有解，即gcd(a1,a2,.......an,M)=1,接下来对M 进行分解，然后排除公因子非1的情况即可。

公式为：ans=M^N-(有奇数个公因数的n元组)+(有偶数个公因数的n元组)。拿上面的例子来说就是

ans=m^n-( 有公因数2的n元组)- (有公因数3的n元组)- (有公因数5的n元组)+ (有公因数2，3的n元组) +(有公因数2，5的n元组)+ (有公因数3，5的n元组)- (有公因数2，3，5的n元组).

有公因数d的n元组，每个位置上有 (m/d)个选择（1 ~ m里面有m/d个d的倍数），根据乘法原理，可以得出有公因数d的n元组有 (m/d)^n 个.

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
#define N 64
int factor[N];///存储m的素因子
int total;///记录m的素因子的个数
void divide(int m)///求m的质因子
{
    int i;
    total=0;
    for(i=2;i*i<=m;i++)
    {
        if(m%i==0)
        {
            total++;
            factor[total]=i;
        }
        while(m%i==0)
        {
            m/=i;
        }
    }
    if(m!=1)
    {
        total++;
        factor[total]=m;
    }
}
long long quick_multi(long long a,long long b)
{                    ///快速求a^b;
    long long ans=1;
    while(b)
    {
        ans=ans*a;
        b--;
    }
    return ans;
}

int num[N];///存储需要的质因子
int m,n;
long long ans;
long long temp;///存储每次不符合条件的数量
void dfs(int a,int b,int c)///a，数组的初始位置；b，记录已经存储的质因子的个数
{                          ///c，公因子的上限
    int i,x;
    if(b==c)
    {
        x=m;
        for(i=1;i<=c;i++)
            x/=num[i];///包含质因子num[i]的小于x的数的个数
            temp+=quick_multi(x,n);
            return ;
    }
    for(i=a;i<=total;i++)
    {
        num[b+1]=factor[i];
        dfs(i+1,b+1,c);
    }
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        ans=total=0;
        divide(m);
        for(int i=1;i<=total;i++)
        {
            temp=0;
            dfs(1,0,i);///初始位置为1，还没有记录质因子，所以为0
            if(i&1)///质因子的个数为奇数时
                ans+=temp;
            else///质因子的个数为偶数时
                ans-=temp;
        }
        ans=quick_multi(m,n)-ans;
        printf("%lld\n",ans);
    }
    return 0;
}