不定方程详解

最新推荐文章于 2023-10-11 09:28:39 发布

羊博士粉丝团代理团长

最新推荐文章于 2023-10-11 09:28:39 发布

阅读量1.2k

点赞数 1

分类专栏：数论文章标签：算法

本文链接：https://blog.csdn.net/weixin_43956585/article/details/104214923

版权

数论专栏收录该内容

5 篇文章 3 订阅

订阅专栏

二元一次不定方程

定义： $a ， b ， c$ 是整数， $a b \neq = 0$ ，那么形如 $a x + b y = c$ 的方程称为二元一次不定方程。
定理：设 $a ， b$ 是整数，且 $d = (a, b)$ ，如果 $d ∣ c$ ，那么方程存在无数多个整数解，否则方程不存在整数解。 $((a, b) = g c d (a, b))$
二元一次不定方程和同余方程之间可以相互转换的，例如在 $a > 0, b > 0$ 的条件下，求解二元一次不定方程 $a x + b y = c$ 与求解同余方程 $ax≡c(mod\ b)$ 是相同的。
求解同余方程使用扩展欧几里得算法，二元一次不定方程同样可以使用扩展欧几里得算法。
由扩展欧几里得可知：设 $a$ 和 $b$ 不全为0，则存在整数 $x ， y$ ，使得：
$g c d (a, b) = a x + b y$
所以当 $d ∣ c$ 时， $a x + b y = c$ 存在整数解。
通过扩展欧几里得算法求出特解 $x_0,y_0$ ，那么通解为 $x_0+n\times\frac{b}{d},y_0-n\times\frac{a}{d}\ (n∈Z)$ .

void exgcd(int a,int b,int&d,int&x,int&y)//扩展欧几里得算法
{
    if(b==0)
    {
        x=1,y=0;
        d=a;
    }
    else 
    {
        exgcd(b,a%b,d,x,y); 
        int t=x;
        x=y;
        y=t-a/b*y ;
    }
}

$n$ 元一次不定方程

定理： $n$ 元一次不定方程 $a_1x_1+a_2x_2+...+a_nx_n=c(a_1,a_2,...,a_n,c∈N)$ ，有解的充分必要条件是 $a_1,a_2,...,a_n)|c$ .
解 $n$ 元一次不定方程可以转化为求二元一次不定方程， $n$ 元一次不定方程 $a_1x_1+a_2x_2+...+a_nx_n=c$ ，可以转为为下面形式：
$S\left\{ \begin{aligned} &a_1x_1+a_2x_2=d_1t_1&\\ &d_1t_1+a_3x_3=d_2t_2&\\ &d_2t_2+a_4x_4=d_3t_3&\\ &\ \ \ \ .&\\ &\ \ \ \ .&\\ &\ \ \ \ .&\\ &d_{n-1}t_{n-1}+a_nx_n=c&\\ \end{aligned} \right.$
$d_{n-1},an)=(a_1,a_2,...,a_n)$ ，所以上述定理成立。
求出最后一个方程的解，然后代入倒数第二个方程，依此类推可以求出方程的所有解。
对于 $m$ 个 $n$ 元一次不定方程组成的方程组，其中 $m < n$ ，可以消去 $m - 1$ 个未知数，从而消去 $m - 1$ 个不定方程，将方程组转化为一个 $n - m + 1$ 元的一次不定方程。然后依照 $n$ 元一次不定方程求解。

解不定方程简单应用

The Balance(poj 2142)

有一天平，两个质量为 $a$ 和 $b$ 的砝码，数量不限，且两边都可以放，要求称出质量为 $c$ 的物品，即两边平衡。尽量少的使用砝码，当砝码数量相同时总重量最小。
输入为 $a ， b ， c$ .
思路：如果a小于b交换a，b。显然可以构造不定方程 $a x + b y = c$ ，此时 $x$ 和 $y$ 不一定为正整数，可以先求出一组特解 $x_0,y_0$ ，通解就为 $x_0+n\times\frac{b}{d},y_0+n\times\frac{a}{d}\ (n∈Z)$ .因为要求砝码数尽量少，即 $m i n (∣ x ∣ + ∣ y ∣)$ ，代入通解为 $min(|x_0+n\times\frac{b}{d}|+|y_0-n\times\frac{a}{d}|)$ ，因为 $a > b$ ，显然最小值应在 $\frac{y_0d}{a}$ 附近，可以for循环枚举前后的几个值，然后取 $m i n (∣ x ∣ + ∣ y ∣)$ ，当 $m i n (∣ x ∣ + ∣ y ∣)$ 相等时 $m i n (a ∣ x ∣ + b ∣ y ∣)$
代码如下：

#include <iostream>
#include <algorithm>
#include <math.h>
using namespace std;
typedef long long ll;
const int maxx=1e6+7;
void exgcd(ll a,ll b,ll&d,ll&x,ll&y)
{
	if(!b)
	{
		x=1,y=0;
		d=a;
	}
	else
	{
		exgcd(b,a%b,d,x,y);
		ll temp=x;
		x=y;
		y=temp-a/b*y;
	}
}
int main()
{
    ll a,b,c,d,x0,y0;
	ios::sync_with_stdio(false);
	while(cin>>a>>b>>c&&(a||b||c))
	{
	    ll x=0x3f3f3f3f,y=0x3f3f3f3f,flag=0;
	    if(a<b) {swap(a,b);flag=1;}
		exgcd(a,b,d,x0,y0);
        a=a/d;
        b=b/d;
        x0=x0*c/d;
        y0=y0*c/d;
        for(ll i=y0/a-10;i<=y0/a+10;i++)
        {
            ll q=x0+i*b,p=y0-i*a;
            q=q<0?(-q):q; p=p<0?(-p):p;
            if(q+p<x+y)
                x=q,y=p;
            else if(q+p==x+y&&(q*a+p*b)<(x*a+y*b))
                    x=q,y=p;
        }
        if(!flag)
        cout<<x<<" "<<y<<endl;
        else cout<<y<<" "<<x<<endl;
    }
}

跳骚（poj 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)。

思路：假设卡片上面数字为 $a_1，a_2,...a_n,M$ ，跳骚选择卡片的次数为 $x_1,x_2,...x_n,x_{n+1}$ ，那么有不定方程 $a_1x_1+a_2x_2+...+a_nx_n+Mx_{n+1}=1$ ，即 $a_1,a_2,...,a_n,M)=1$ ，可以计算出 $a_1,a_2,...,a_n,M)≠1$ 的所有情况，然后用 $M^n$ 减去即可。计算 $a_1,a_2,...,a_n,M)≠1$ 的所有情况可以使用容斥定理计算，如果gcd不等于1的话，那么这些数肯定都至少有一个M的质因子，假设d是M的一个质因子，那么小于M的可以整除d的数个数量就是 $\frac{M}{d}$ 个，从其中任选n个，因为可以重复选择，所以数量就是 $\frac{M}{d}^n$ 。
所以 $ans=\bigcup\limits_{i=1}^{r}\frac{M}{d_i}^n\ (r为M的质因子数量)$
由容斥原理可知：
$\left|\bigcup\limits_{i=1}^{n}S_i\right|=\sum\limits_{C\subseteq M}^{n}(-1)^{size(C)-1}\left|\bigcap\limits_{T\subseteq C}T\right|$

#include <iostream>
#include <algorithm>
#include <math.h>
using namespace std;
typedef long long ll;
const int maxx=1e6+7;
ll n,m,p[35],cnt,sum,ans;
ll qpow(ll a,ll b)
{
    ll ans=1;
    while(b)
    {
        if(b&1)
            ans=ans*a;
        a=a*a;
        b>>=1;
    }
    return ans;
}
void dfs(int now,int id,int over,ll product)
{
    if(now==over)
    {
        sum+=qpow(m/product,n);
        return;
    }
    for(int i=id;i<=cnt;i++)
    {
        dfs(now+1,i+1,over,product*p[i]);
    }
}
int main()
{
    ios::sync_with_stdio(0);
    cin>>n>>m;
    ll a=m;
    for(int i=2;i*i<=a;i++)
        if(a%i==0)
        {
            p[++cnt]=i;
            while(a%i==0)
                a/=i;
        }
    if(a>1) p[++cnt]=a;
    for(int i=1;i<=cnt;i++)
    {
        sum=0;
        dfs(0,1,i,1);
        if(i&1)
            ans+=sum;
        else ans-=sum;
    }
    cout<<qpow(m,n)-ans<<endl;
}

特殊的不定方程

毕达哥拉斯定理：平面上的一个直角三角形中，两个直角边边长的平方加起来等于斜边长的平方。如果设直角三角形的两条直角边长度分别是 $a$ 和 $b$ ，斜边长度是 $c$ ，那么可以用数学语言表达： $a^2+b^2=c^2$ .
满足上面这个方程的正整数三元组被称为毕达哥拉斯三元组。
如果一个毕达哥拉斯三元组 $x ， y ， z$ ，满足 $(x, y, z) = 1$ ，那么这个毕达哥拉斯三元组被称为本原的毕达哥拉斯三元组。
定理：正整数 $a ， b ， c$ 构成一个本原毕达哥拉斯三元组且y为偶数，当且仅当存在互质的正整数 $m ， n （ m > n ）$ 其中 $m$ 为奇数， $n$ 为偶数；或者 $n$ 为奇数， $m$ 为偶数，并且满足：
1. $a=m^2+n^2$
2. $b = 2 m n$
3. $c=m^2-n^2$
费马大定理：方程 $x^n+y^n=z^n$ 无非0整数解，其中 $n$ 为整数且 $n \geq 3$ .
佩尔方程：形如 $x^2-dy^2=1$ ( $d > 1$ 且不为完全平方数)的不定方程称为佩尔方程。
佩尔方程当 $d$ 为完全平方数时， $(x+\sqrt{d}y)(x-\sqrt{d}y)=1$ ，显然方程无解。
解佩尔方程：
若佩尔方程最小特解是(x_1,y_1)，那么可有迭代公式：
$x_n=x_{n-1}x_1+dy_{n-1}y_1$
$y_n=x_{n-1}y_1+y_{n-1}x_1$
即：
$\begin{bmatrix} x_k\\ y_k\\ \end{bmatrix}={\begin{bmatrix} x_1&dy_1\\ y_1&x_1\\ \end{bmatrix}}^{k-1}\begin{bmatrix} x_1\\ y_1\\ \end{bmatrix}$
我们可以通过矩阵快速幂求出第k个解。
对于特解可以暴力求解：
由 $x^2-dy^2=1$ ，得 $x^2=dy^2+1$ ，即 $x=\sqrt{dy^2+1}$ ，那么令 $y = 1$ ，代入求解 $x$ ，然后判断是否满足，否则就 $y = y + 1$ ，直到求出满足的特解。

void find()
{
	int x,y=1;
	while(1)
	{
			x=(long long)sqrt(d*y*y+1);
			if(x*x-d*y*y==1)
				break;
			y++;
	}
}

特殊的不定方程的应用

Street Numbers（poj 1320）
题意：求前十组两个整数不相等 $n ， m$ ，满足 $（ n < m ）$ ,使得：
$1 + 2 + . . . + (n - 1) = (n + 1) + . . . + m$
思路：
$\frac{n(n-1)}{2}=\frac{(m-n)(m+n+1)}{2}$ ,化简可得 $2m+1)^2-8n^2=1$
佩尔方程递推求解即可。

#include <iostream>
#include <algorithm>
using namespace std;
const int maxx=1e6+7;
int main()
{
    ios::sync_with_stdio(0);
    int x0=3,y0=1,px=3,py=1,d=8,x,y;
    for(int i=1;i<=10;i++)
    {
        x=px*x0+d*py*y0;
        y=px*y0+py*x0;
        cout<<y<<" "<<(x-1)/2<<endl;
        px=x,py=y;
    }
}

Right-angled Triangle（fzu 1669）
求满足以a、b为直角边，c为斜边，而且满足a + b + c <= L的直角三角形的个数。

思路：根据本原毕达哥拉斯三元组满足的条件枚举n，m，求出本原毕达哥拉斯三元组后这个三元组的倍数也是毕达哥拉斯三元组。枚举所有即可。

#include <iostream>
#include <algorithm>
using namespace std;
const int maxx=1e6+7;
int main()
{
    ios::sync_with_stdio(0);
    int l;
    while(cin>>l)
    {
        int ans=0;
        for(int i=1;i*i<=l;i++)
        {
            for(int j=i+1;j*j<=l;j++)
            {
                if(i%2!=j%2)
                {
                    int x=j*j-i*i,y=i*j*2,z=i*i+j*j;
                    if(__gcd(x,__gcd(y,z))==1)
                    {
                        for(int k=1;k*(z+y+x)<=l;k++)
                        {
                            ans++;
                        }
                    }
                }
            }
        }
        cout<<ans<<endl;
    }
}

No more tricks, Mr Nanguo (hdu 3292)
给出d和k，求满足 $x^2-dy^2=1$ 的第k小的x的值。

思路：佩尔方程先暴力求出最小解，然后矩阵快速幂求解即可。

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
typedef long long ll;
const int maxx=1e6+7,mod=8191;
struct matrix
{
    ll a[5][5];
}m;
matrix times(matrix x,matrix y,int n)
{
    matrix temp;
    memset(temp.a,0,sizeof temp);
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
    for(int k=1;k<=n;k++)
        temp.a[i][j]=(temp.a[i][j]+x.a[i][k]*y.a[k][j])%mod;
    return temp;
}
matrix qpow(matrix a,ll b,int n)
{
    matrix ans;
    memset(ans.a,0,sizeof ans.a);
    for(int i=1;i<=n;i++)
        ans.a[i][i]=1;
    while(b)
    {
        if(b&1) ans=times(ans,a,n);
        a=times(a,a,n);
        b>>=1;
    }
    return ans;
}
int main()
{
    ios::sync_with_stdio(0);
    int n,k;
    while(cin>>n>>k)
    {
        int temp=sqrt(n+0.0);
        if(temp*temp==n)
            cout<<"No answers can meet such conditions"<<endl;
        else
        {
            ll x,y=1;
            while(true)
            {
                x=(ll)sqrt(n*y*y+1);
                if(x*x-y*y*n==1)
                    break;
                y++;
            }
            m.a[1][1]=x%mod;
            m.a[1][2]=n*y%mod;
            m.a[2][1]=y%mod;
            m.a[2][2]=x%mod;
            matrix ans=qpow(m,k-1,2);
            x=x*ans.a[1][1]%mod+y*ans.a[1][2]%mod;
            cout<<x%mod<<endl;
        }
    }
}

羊博士粉丝团代理团长

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
不定方程详解

二元一次不定方程定义：a，b，ca，b，ca，b，c是整数，ab≠0ab≠0ab=0，那么形如ax+by=cax+by=cax+by=c的方程称为二元一次不定方程。定理：设a，ba，ba，b是整数，且d=(a,b)d=(a,b)d=(a,b)，如果d∣cd|cd∣c，那么方程存在无数多个整数解，否则方程不存在整数解。求解...
复制链接

扫一扫