洛谷P1092 （高斯消元+搜索/二进制状态压缩）

题目描述

所谓虫食算，就是原先的算式中有一部分被虫子啃掉了，需要我们根据剩下的数字来判定被啃掉的字母。来看一个简单的例子：

 43#9865#045
+  8468#6633
 44445509678

其中#号代表被虫子啃掉的数字。根据算式，我们很容易判断：第一行的两个数字分别是55和33，第二行的数字是55。

现在，我们对问题做两个限制：

首先，我们只考虑加法的虫食算。这里的加法是NN进制加法，算式中三个数都有NN位，允许有前导的00。

其次，虫子把所有的数都啃光了，我们只知道哪些数字是相同的，我们将相同的数字用相同的字母表示，不同的数字用不同的字母表示。如果这个算式是NN进制的，我们就取英文字母表午的前NN个大写字母来表示这个算式中的00到N-1N−1这NN个不同的数字：但是这NN个字母并不一定顺序地代表00到N-1N−1。输入数据保证NN个字母分别至少出现一次。

 BADC
+CBDA
 DCCC

上面的算式是一个4进制的算式。很显然，我们只要让ABCDABCD分别代表01230123，便可以让这个式子成立了。你的任务是，对于给定的NN进制加法算式，求出NN个不同的字母分别代表的数字，使得该加法算式成立。输入数据保证有且仅有一组解。

输入格式

包含四行。
第一行有一个正整数N(N \le 26)N(N≤26)。

后面的三行，每行有一个由大写字母组成的字符串，分别代表两个加数以及和。这3个字符串左右两端都没有空格，从高位到低位，并且恰好有NN位。

输出格式

一行，即唯一的那组解。

解是这样表示的：输出NN个数字，分别表示A,B,C,…A,B,C,…所代表的数字，相邻的两个数字用一个空格隔开，不能有多余的空格。

输入输出样例

输入 #1复制

5
ABCED
BDACE
EBBAA

输出 #1复制

1 0 3 4 2

说明/提示

对于30％的数据，保证有N \le 10N≤10；

对于50％的数据，保证有N \le 15N≤15；

对于全部的数据，保证有N \le 26N≤26。

noip2004提高组第4题

思路：

首先，假设我们有n进制的加法算式a + b = c

对于第i位的加法运算，考虑上一位的加法的进位di-1和本位加法进位，有ai + bi = ci + di-1 + n*di

即，每一位的进位di只能取1或0，当然，d0只能为0，本题中dn也只能为0。

将ci移至等式的右边，得

至此，如果我们将A，B，C,.....,Z分别记为x1，x2，x3,……,x26，那么我们便可列出方程，利用高斯消元求解增广矩阵了。

由于di只能为0或1，所以我们可以对di进行枚举，但是，高斯消元的复杂度是n3的，搜索或枚举+高斯消元，这种方法的复杂度爆了，是2^n * n3，所以，我们可以先将得到的增广矩阵左边利用高斯消元，求解出，然后再对di进行枚举，判断解的合法性，这样的复杂度是n^3 + 2^n*n^2的。

二进制状压：

#include <cstdio>
#include <stack>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <iostream>
#include <map>
#include <vector>
#include <queue>
#include <set>
#define eps 1e-8
typedef long long ll;
const double PI = acos(-1.0);
const int maxn = 1005;
const int INF = 0x3f3f3f;
const ll linf = 0x3f3f3f3f3f3f3f3f;
using namespace std;
int a[maxn][maxn],g[maxn][maxn];
int d[maxn],x[maxn];
int vis[maxn];
int n;
string s[3];
int equ,var;
int gcd(int a, int b)
{
    return b == 0?a:gcd(b,a%b);
}
void gauss()
{
    int row,col,mxr,lcm;
    for(row = col = 1;row<=equ&& col<=var; row++,col++)
    {
        mxr = row;
        for(int i = row+1; i<=equ; i++)
        {
            if(abs(a[i][col])>abs(a[mxr][col]))
                mxr = i;
        }
        if(mxr != row)
        {
            swap(a[row],a[mxr]);
            swap(g[row],g[mxr]);
        }
        if(!a[row][col])
        {
            row--;
            continue;
        }
        for(int i = 1; i<=equ; i++)
        {
            if(i!=row && a[i][col])
            {
                lcm = a[i][col]/gcd(a[i][col],a[row][col])*a[row][col];
                int t1 = lcm/a[i][col];
                int t2 = lcm/a[row][col];
                for(int j = 1; j<=var; j++)
                {
                    g[i][j] = t1*g[i][j] - t2*g[row][j];
                    a[i][j] = t1*a[i][j] - t2*a[row][j];
                }
            }
        }
    }
}
int check()
{
    memset(vis,0,sizeof vis);
    for(int i = 1; i<=n; i++)
    {
        x[i] = 0;
        for(int j = 1; j<=n; j++)
            x[i] += g[i][j]*d[j];
        //判断最终解出的x[i]/a[i][i]是否合法
        //x[i]/a[i][i]应该为0~n-1的整数，且各不相同
        if(x[i]%a[i][i] ||  x[i]/a[i][i]<0)
            return 0;
        if(x[i]/a[i][i]>=n || vis[x[i]/a[i][i]])
            return 0;
        x[i] /= a[i][i];
        vis[x[i]] = 1;
    }
    return 1;
}
void solve()
{
    for(int i = 0; i<(1<<n); i++)
    {
        for(int j = 0; j<n; j++)
        {
            if(i&(1<<j))
                d[j+1] = 1;
            else
                d[j+1] = 0;
        }
        if(check())
        {
            for(int j = 1; j<=n; j++)
                cout<<x[j]<<" ";
            cout<<endl;
        }
    }
}
int main()
{
    cin>>n;
    for(int i = 0; i<3; i++)
        cin>>s[i];
    for(int  i = 0; i<n; i++)
    {
        for(int j = 0; j<2; j++)
            a[n-i][s[j][i]-'A'+1]++;
        a[n-i][s[2][i]-'A'+1]--;
    }
    for(int i = 1; i<=n; i++)
    {
        g[i][i] = n;
        g[i][i-1] = -1;
    }
    g[1][0] = 0;
    equ = var = n;
    gauss();
    solve();
    return 0;
}

搜索：

#include <cstdio>
#include <stack>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <iostream>
#include <map>
#include <vector>
#include <queue>
#include <set>
#define eps 1e-8
typedef long long ll;
const double PI = acos(-1.0);
const int maxn = 1005;
const int INF = 0x3f3f3f;
const ll linf = 0x3f3f3f3f3f3f3f3f;
using namespace std;
int a[maxn][maxn],g[maxn][maxn];
int d[maxn],x[maxn];
int vis[maxn];
int n;
string s[3];
int equ,var;
int gcd(int a, int b)
{
    return b == 0?a:gcd(b,a%b);
}
void gauss()
{
    int row,col,mxr,lcm;
    for(row = col = 1;row<=equ&& col<=var; row++,col++)
    {
        mxr = row;
        for(int i = row+1; i<=equ; i++)
        {
            if(abs(a[i][col])>abs(a[mxr][col]))
                mxr = i;
        }
        if(mxr != row)
        {
            swap(a[row],a[mxr]);
            swap(g[row],g[mxr]);
        }
        if(!a[row][col])
        {
            row--;
            continue;
        }
        for(int i = 1; i<=equ; i++)
        {
            if(i!=row && a[i][col])
            {
                lcm = a[i][col]/gcd(a[i][col],a[row][col])*a[row][col];
                int t1 = lcm/a[i][col];
                int t2 = lcm/a[row][col];
                for(int j = 1; j<=var; j++)
                {
                    g[i][j] = t1*g[i][j] - t2*g[row][j];
                    a[i][j] = t1*a[i][j] - t2*a[row][j];
                }
            }
        }
    }
}
int check()
{
    memset(vis,0,sizeof vis);
    for(int i = 1; i<=n; i++)
    {
        x[i] = 0;
        for(int j = 1; j<=n; j++)
            x[i] += g[i][j]*d[j];
        if(x[i]%a[i][i] ||  x[i]/a[i][i]<0)
            return 0;
        if(x[i]/a[i][i]>=n || vis[x[i]/a[i][i]])
            return 0;
        x[i] /= a[i][i];
        vis[x[i]] = 1;
    }
    return 1;
}
void dfs(int pos)
{
    if(pos == n)
    {
        if(check())
        {
            for(int i = 1; i<n; i++)
                cout<<x[i]<<" ";
            cout<<x[n]<<endl;
        }
        return;
    }
    d[pos] = 1;
    dfs(pos+1);
    d[pos] = 0;
    dfs(pos+1);
}
int main()
{
    cin>>n;
    for(int i = 0; i<3; i++)
        cin>>s[i];
    for(int  i = 0; i<n; i++)
    {
        for(int j = 0; j<2; j++)
            a[n-i][s[j][i]-'A'+1]++;
        a[n-i][s[2][i]-'A'+1]--;
    }
    for(int i = 1; i<=n; i++)
    {
        g[i][i] = n;
        g[i][i-1] = -1;
    }
    g[1][0] = 0;
    equ = var = n;
    gauss();
    dfs(1);
    return 0;
}