extend_gcd求解不定方程／膜线性方程／乘法(模)逆元

形如a*x+b*y=c

为不定方程，a,b>0其实无所谓，因为gcd(a,b)=gcd(|a|,|b|)   //gcd为最大公约数

由数论的定理所知，当c%gcd==0，不定方程有解,现在我们来求这个解.

gcd=gcd(a,b);a*b=gcd*lcm;  //lcm为最小公倍数

a'=a/gcd;b'=b/gcd;c'=c/gcd; a'目前与b'互质  

令c''=1=a'*x+b'*y;

利用extend_gcd求出一组特解。(x0,y0)

(x0*c'.y0*c')为 a'*x+b'*y=c'的一组特解

由方程解的思想求出其通解;x=x0*c'+b'*t;    y=y0*c'-a'*t;再用通解去求解题目

今天花了一晚上时间纠结了一个显而易见的问题。果然当局者迷。

我现在就想大笑一场。哈哈哈哈哈哈哈哈

UVA,10413

题目意思：t个case，n个野人，C,P,L分别代表初始洞穴，隔天移动洞穴数，存活天数。

问：最小的洞穴数，使得在n个野人在各自存活期不遇见。

数据：1*10^6 可以接受，所以此题以初值为野人中初始洞穴最大数，枚举就可以过了。

源代码：

#include <iostream>
#include <algorithm>
#include <cstdio>

using namespace std;

int x,y,gcd,n;
int C[20],P[20],L[20];

void extend_gcd(int a,int b)
{
    if(b==0)
    {
        x=1;
        y=0;
        gcd=a;
        return;
    }
    extend_gcd(b,a%b);
    int tmp=x;
    x=y;
    y=tmp-a/b*y;
    return;
}

bool solve(int i,int j,int m)
{
    int c=C[i]-C[j];
    int b=m;
    int a=P[j]-P[i];
    extend_gcd(a,b);
    if(c%gcd) return false;
    x*=c/gcd;
    if(gcd<0) gcd=-gcd;
//因为x=x+b/gcd*k,所以x中包含了若干个b/gcd的代数和差
//因此用x对b/gcd取模，注意负数得x的最小正值
    x=(x%(b/gcd)+b/gcd)%(b/gcd);
    if(x<=L[i] && x<=L[j])
        return true;
    return false;
}
bool test(int m)
{
    for(int i=0;i<n-1;i++)
        for(int j=i+1;j<n;j++)
        {
            if(solve(i,j,m)) return false;
        }
    return true;
}


int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        int lb=0;
        for(int i=0;i<n;i++)
        {
            scanf("%d %d %d",C+i,P+i,L+i);
            lb=max(lb,C[i]);
            C[i]--;
        }
        while(lb<=1000000)
        {
            if(test(lb)) break;
            lb++;
        }
        printf("%d
",lb);
    }
    return 0;
}
//提供测试数据
Sample Input
2
3
1 3 4
2 7 3
3 2 1
5
1 2 14
4 4 6
8 5 9
11 8 13
16 9 10
Sample Output
6
33

补充膜逆元／／

a≡a^-1(mod n) 表示a同余n于a^-1    变式子:a*a^-1≡1(mod n)  即a^-1为a的膜逆元   有解的充分必要条件为a与n互质

若膜逆元存在，可以转换为a*b≡1(mod n)利用extend_gcd求不定方程的解来得到乘法逆元的通解。

a*b+n*y=1  extend_gcd(a,n)  解出一个b(mod n)取其最小值（正负特别考虑）

一般的：a*b+n*y=g   a与n互质,g!=0则无解

因为:(a*b+n*y)(mod n)=g(mod n)  a*b(mod n)=g(mod n)(g<n)  g mod n !=1

则a*b!=1即b不是a的模逆元

欧拉定理中的模逆元    

a与n为两个互质的正整数,a^f(n)≡1(mod n) f(n)为小于n且与n互质的正整数个数

a^f(n)=a*a^(f(n)-1)≡1(mod n)即a^(f(n)-1)为a的模n之逆元

 中国剩余定理

x≡a1(mod m1)

x≡a2(mod m2)

...

x≡ai(mod mi)

m1,m2....mi互质，则对任意的a1,a2...ai方程组有解

且通解为:x=a1*t1*M1+a2*t2*M2+....+ai*ti*Mi+k*M (Mi=M/mi,  M=m1*m2*...*mi)

具体证明及例子参考wiki

uva 11754

 

大致题意：

给你两个元素C,S  C为行数，也代表互质元的个数，S代表要输入的最小的S个解。

接着的X,k为质数元，k代表要求的n对X取余之后的存在的余数个数，（这里n不唯一，所以对X有多个余数，

申明：一个数n对另一个数m取余数有且仅有一个）

具体想法：由于k为(1,100)当有C=9个k的时候dfs去搜的话会爆掉。

所以用特殊枚举法，当total=k[0]*k[1]*....*k[i]<10000的时候用dfs去搜

否则 找到一个基元s 用t*X[s]+Y[s][j]去枚举。  //这里s为当k/x最小的时候所取的值

//因为k越小，x越大，代表余数个数越小，除数越大,所以枚举所需要的次数越少。

//详细解释－重点：  n=t*X[s]+Y[s][j] (t=0,1.....,)(j=0,1....k[s])因为n%X[s]=Y[s][j]。

//即无论要求多少个n，都能够从一个X[s]和其余数得出来。所以选择需要枚举次数最小的那一组(X[s],Y[s][j])(j=0,1...k[s])速度最快。

源代码：//写了一下午，终于干掉了，进步了不少，继续加油！

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <set>
#include <vector>

using namespace std;

typedef long long ll;
const int maxc=15;
const int maxs=105;
const int limit=10000;

ll total;
int C,S,bestc;
int X[maxc],k[maxc],Y[maxc][maxs];

void init()
{
    total=1;
    bestc=0;
    for(int i=0;i<C;i++)
    {
        scanf("%d %d",&X[i],&k[i]);
        total*=k[i];
        for(int j=0;j<k[i];j++)
            scanf("%d",&Y[i][j]);
        sort(Y[i],Y[i]+k[i]);
        if(X[bestc]*k[i]<X[i]*k[bestc])
            bestc=i;
    }
}

set<int> vis[maxc];
void solveEnum(int s)
{
    for(int i=0;i<C;i++)
    {
        if(i==s)
            continue;
        vis[i].clear();
        for(int j=0;j<k[i];j++)
            vis[i].insert(Y[i][j]);
    }
    for(int t=0;S;t++)
    {
        for(int i=0;i<k[s];i++)
        {
            ll n=(ll)X[s]*t+Y[s][i];
            if(n==0)
                continue;
            bool flag=true;
            for(int j=0;j<C;j++)
            {
                if(j==s)
                    continue;
                if(!vis[j].count(n%X[j]))
                {
                    flag=false;
                    break;
                }
            }
            if(flag)
            {
                printf("%lld
",n);
                if(--S==0)
                    break;
            }
        }
    }
}

void extend_gcd(ll a,ll b,ll& d,ll& x,ll& y)
{
    if(!b)
    {
        x=1;
        y=0;
        d=a;
        return;
    }
    extend_gcd(b,a%b,d,y,x);
    y-=a/b*x;
    return;
}

vector<int> sol;
int a[maxc];
int China(int n,int* s,int* m)
{
    ll M=1,d,y,x=0;
    for(int i=0;i<n;i++)
        M*=m[i];
    for(int j=0;j<n;j++)
    {
        ll w=M/m[j];
        extend_gcd(m[j],w,d,d,y);
        x=(x+y*w*a[j])%M;
    }
    return (x+M)%M;
}

void dfs(int dep)
{
    if(dep==C)
        sol.push_back(China(C,a,X));
    else
    {
        for(int i=0;i<k[dep];i++)
        {
            a[dep]=Y[dep][i];
            dfs(dep+1);
        }
    }
}

void solveChina()
{
    sol.clear();
    dfs(0);
    sort(sol.begin(),sol.end());
    ll M=1;
    for(int i=0;i<C;i++)
        M*=X[i];
    for(int t=0;S;t++)
    {
        for(int j=0;j<sol.size();j++)
        {
            ll n = M*t+sol[j];
            if(n>0)
            {  printf("%lld
",n);
                if(--S==0)
                    break;
            }
        }
    }
}
int main()
{
    while(scanf("%d %d",&C,&S) == 2 && C+S)
    {
        init();
        if(total>limit)
            solveEnum(bestc);
        else
            solveChina();
        puts("
");
    }
    return 0;
}