USACO-Section2.1 Hamming Codes（深度优先搜索）

2017-8-15

题目描述

找出 N 个由0或1组成的编码，每个编码有 B 位，使得两两编码之间至少有 D 个单位的  “Hamming距离”

解答

使得值最小，0必然包括，从小至大往后找

代码

/*
ID: 18795871
PROG: hamming
LANG: C++
*/
#include<iostream>
#include<fstream>
#include<cstring>
using namespace std;
const int M = 8,K = 256;

ifstream fin("hamming.in");
ofstream fout("hamming.out");

int N,B,D;
int cnt=1,r[65];

bool cal(int a,int b){
    int x,y,i,j,s=0;
    for (i=1;i<=B;i++){
        x=a%2;
        a/=2;
        y=b%2;
        b/=2;
        if (x!=y) s++;
    }
    if (s>=D) return true;
    return false;
}

bool res(int m){
    for (int i=1;i<cnt;i++){
        if (!cal(r[i],m)) return false;
    }
    return true;
}

int main()
{
    fin>>N>>B>>D;
    int i;
    for (i=0;i<K;i++){
        if (res(i)) r[cnt++]=i;
        if (cnt>N) break;
    }
    for (i=1;i<cnt-1;i++){
        if (i%10==0) fout<<r[i]<<endl;
        else fout<<r[i]<<" ";
    }
    fout<<r[i]<<endl;
    return 0;
}

说实话，很好奇自己之前是怎么AC所有的测试数据的，可能它给的测试数据刚好满足顺着求就是它们要的解吧！我之前觉得0一定是的，那么这里我们只要顺序找就可以，找到第一个与0 ” 距离 ” 大于d的即可，再继续往下找，找到第一个与0和刚刚求得的数的 ” 距离 ” 大于d的，就这么顺序往下找，一直找到n个就是我们要的解了。
好像并不是完全正确的思路，难道是因为题目要求我们 ” 使得这个N个数从第一数开始比较是最小的 “？！存在说若顺着找到的最大数大于我们给定的b个字节吗？！

我的想法是用递归求解这一题，step表示当前来到了第几个，那么我们每次应该考虑选择谁的问题了，由于我们要求的是一个升序的序列，那么我用p表示当前应该从那一个开始选择，即比上一步的值加一，如果说这个值与之前的值的 ” 距离 ” 都大于d的话，那么我们就可以选择它了 ，当我们选择完毕即step==n的时候，就标记flag为true，即我们已经得到我们想要的解了。需要注意的是，我在进dfs之前已经对t数组的值进行赋值过了，那么可能会更改我们之前的值，所以我用了r数组来存储我们最后得到的值。

/*
ID: 18795871
PROG: hamming
LANG: C++
*/
#include <iostream>
#include <fstream>
using namespace std;

ifstream fin("hamming.in");
ofstream fout("hamming.out");

const int N = 256;
int x[N+1][N+1],r[N+1],t[N+1];
int n,b,d,m;
bool flag;

int cal(int p,int q){
    int dif=0,i;
    for (i=0;i<b;i++){
        if ((p&1)!=(q&1)) dif++;
        p>>=1;q>>=1;
    }
    return dif;
}

void init(){
    m=1;flag=false;
    for (int i=0;i<b;i++){
        m*=2;
    }
}

void dfs(int step,int p){
    if (flag) return ;
    if (step>n) return ;
    if (step==n){
            for (int i=0;i<n;i++){
                r[i]=t[i];
            }   
            flag=true;
        return ;
    }
    int i,j;
    for (i=p;i<=m;i++){
        for (j=0;j<step;j++){
            if (x[t[j]][i]<d) break; 
        }
        if (j>=step){
            t[step]=i;
            dfs(step+1,i+1);
        }
    }
}

int main(){
    while (fin>>n>>b>>d){
        int i,j;
        init();
        for (i=0;i<m;i++){
            for (j=i+1;j<m;j++){
                x[i][j]=cal(i,j);
            }
        }
        dfs(0,0);
        int k=0; 
        for (i=0;i<n;i++){
            if (i%10==9||i==n-1) fout<<r[i]<<endl;
            else fout<<r[i]<<" ";
        }
    }
    return 0;
}

或者我们可以换一个思路，step表示我们当前来到了第几个数，那么此时我们就存在一个问题了，这个数我们选还是不选，如果说这个数满足与之前选的数的 ” 距离 ” 都在d以上的话，那么我们才有权力选择选或不选，否则的话，我们只能选择不选了！如果选择的话，当前的num数应该加一，因为我们需要满足条件的一共n个数。需要注意的是，除了最后一行我们每行只能输出十个。

/*
ID: 18795871
PROG: hamming
LANG: C++
*/
#include <iostream>
#include <fstream>
using namespace std;

ifstream fin("hamming.in");
ofstream fout("hamming.out");

const int N = 256;
int x[N+1][N+1],r[N+1],t[N+1];
int n,b,d,m;
bool flag;

int cal(int p,int q){
    int dif=0,i;
    for (i=0;i<b;i++){
        if ((p&1)!=(q&1)) dif++;
        p>>=1;q>>=1;
    }
    return dif;
}

void init(){
    m=1;flag=false;
    for (int i=0;i<b;i++){
        m*=2;
    }
}

void dfs(int step,int num){
    if (flag) return ;
    if (step>m) return ;
    if (step==m){
        if (num>=n){
            for (int i=0;i<=m;i++){
                r[i]=t[i];
            }   
            flag=true;
        }
        return ;
    }
    bool f=false;
    for (int i=0;i<step;i++){
        if (!t[i]) continue;
        if (x[i][step]<d){
            f=true;
            break;
        }
    }
    if (!f){
        t[step]=1;
        dfs(step+1,num+1);
        t[step]=0;
        dfs(step+1,num);
    }else{
        t[step]=0;
        dfs(step+1,num);
    }
}

int main(){
    while (fin>>n>>b>>d){
        int i,j;
        init();
        for (i=0;i<m;i++){
            for (j=i+1;j<m;j++){
                x[i][j]=cal(i,j);
            }
        }
        dfs(0,0);
        int k=0; 
        for (i=0;i<=m;i++){
            if (r[i]){
                if (k==n-1||k%10==9) fout<<i<<endl;
                else fout<<i<<" ";
                k++;
            }
        }
    }
    return 0;
}