约数倍数选卡片

问题描述

　　闲暇时，福尔摩斯和华生玩一个游戏：
　　在N张卡片上写有N个整数。两人轮流拿走一张卡片。要求下一个人拿的数字一定是前一个人拿的数字的约数或倍数。例如，某次福尔摩斯拿走的卡片上写着数字“6”，则接下来华生可以拿的数字包括：
　　1，2，3, 6，12，18，24 ....
　　当轮到某一方拿卡片时，没有满足要求的卡片可选，则该方为输方。
　　请你利用计算机的优势计算一下，在已知所有卡片上的数字和可选哪些数字的条件下，怎样选择才能保证必胜！
　　当选多个数字都可以必胜时，输出其中最小的数字。如果无论如何都会输，则输出-1。

输入格式

　　输入数据为2行。第一行是若干空格分开的整数（每个整数介于1~100间），表示当前剩余的所有卡片。
　　第二行也是若干空格分开的整数，表示可以选的数字。当然，第二行的数字必须完全包含在第一行的数字中。

输出格式

　　程序则输出必胜的招法！！

样例输入

2 3 6
3 6

样例输出

3

样例输入

1 2 2 3 3 4 5
3 4 5

样例输出

4

---

Algorithm

最开始这样想，我们先选一个数，然后列举出所有可能的情况。最后这是一棵树......

所以就准备广搜，搜了很久之后发现，广搜好像不行，因为每个点广搜只经过一次，但是我们的数字如果这样不会输可能还会拿来下一次进行下一次的方案中选取。

我没能想到很好的方法来进行标记。

而深搜就不一样了，每当这个数用过之后我们可以将它还原，以便于下一次接着用。

值得注意一点的地方是去重，和将数字排序一下。以及我们标记数字时，应该标记它还有几个可以用，比如这里有两个2和两个3，那么应标记它出现了两次，而不是出现过。

去重的加速可能不太可观，但是排序便于我们选取。

我还看到了从大到小进行搜索的方法，理由是，大数的约数倍数更少，但是有个问题是，我们是要输出最小的必赢的值......

这个程序递归的地方有点不好理解。先给自己记一笔......

这是我参考了诸多博客才实现的，有必要仔细研究一下。

---

AC

/*
* 万能的搜索... 
*/ 
#include<iostream>
#include<string>
#include<queue>
#include<vector>
#include<sstream>
#include<algorithm>
#include<cstring>

using namespace std;

const int MAX = 109;
vector<int> v[MAX];
vector<int> c;
// 这里的状态标记不能这样标记, 应标记出现多少次 
int book[MAX];

bool DFS(int n)
{    // 寻找 n 的约数倍数, 如果没有, 就会直接返回true(赢了) 
    // 1;
    for(int i=v[n].size()-1;i>=0;i--){
        int now = v[n].at(i);
        if(book[now]){    // 判断当前数有没有用完 
            book[now]--;
            bool win = DFS(now);
            book[now]++;
            if(win) return false;
        }
    }
    
    return true;
}

int main()
{
    int x;
    string s;
    
    getline(cin, s);
    stringstream ss(s);
    // 统计每个数出现的次数 
    while(ss>>x) book[x]++; 
    getline(cin, s);
    stringstream str(s);
    // 我们可以选择的数 
    while(str>>x) c.push_back(x);
    // 排序, 方便从小到大搜, 搜到的第一个就是最小的值 
    sort(c.begin(), c.end());
    // 预处理可选数的约数和倍数 
    for(int i=1;i<MAX;i++)
        if(book[i])
            for(int j=1;j<MAX;j++)
                if(book[j] && (i%j == 0 || j%i == 0))
                    v[i].push_back(j);
    // 搜索 
    for(int i=0;i<c.size();i++){
        int now = c.at(i);
        if(book[now]){
            book[now]--;
            if(DFS(now)){
                cout<<now<<'
';
                return 0;
            }
            // 用完之后一定要还, 不然下一次没法搜
            book[now]++;  
        }
    }
    cout<<-1<<'
';
    
    return 0;
}


/*
void Init(int *a, int *b, int la, int lb)
{    // 先把 a 约数倍数处理一下 
    // 想办法去重...  
    sort(a, a+la);
    // int *end = unique(a, a+la);
    // la = end - a;
    // a[i] 的约数和倍数是 a[j] 
    for(int i=0;i<la;i++)
        for(int j=0;j<la;j++){
            if(i == j)
                continue;
            else if(i > 0 && a[i] == a[i-1])
                continue;
            else if(a[i]%a[j] == 0 || a[j]%a[i] == 0)
                v[a[i]].push_back(a[j]);
        }
            
    return;
}

int DFS(int start, int step)
{    cout<<"DFS:"<<step<<endl;
    // 发现可以赢就返回了..., 万一输了判断不了啊... 
    if(book[start] == 0){
        // 如果一共进行了 奇数 次行动, 那么获胜 
        return (step&1 == 1)?1:0;
    }
    book[start]--;
    int t = v[start].size();
    for(int i=0;i<t;i++){
        int num = v[start].at(i);
        if(book[num] == 0)
            continue;
        // book[num]--;
        DFS(num, step++);
        book[num]++; 
    }
}

int BFS(int start)
{    // 突然发现, 广搜好像不好做, 因为标记这关不太好处理
    // 可能会多次用到, 但是我们无法很好地还原前面一个点 
    queue<int> q;
    q.push(start);
    while(!q.empty())
    {
        int t = q.front();
        book[t]--;
        q.pop();
        int len = v[t].size();
        for(int i=0;i<len;i++){
            if(book[v[t].at(i)] == 0) 
                continue;    // 这个数已经用完了
            if(len > 1 && i != 0 && v[t].at(i) == v[t].at(i-1))
                continue;    // 这个数已经进过一次队了
            int x = v[t].at(i);
            q.push(x);
            book[x]--;
        break;    
             
        }
        
        
        break;
    }
    
    
    return -1;
}

void fun(int *a, int *b, int la, int lb)
{
    sort(b, b+lb);
    memset(book, 0, sizeof(book));
    for(int i=0;i<la;i++)
        book[a[i]]++;

    int ret = 999;
    Init(a, b, la, lb);
    int c = 999;
    for(int i=lb-1;i>=0;i--){
        memset(book, 0, sizeof(book));
        c = DFS(b[i], 1);
        cout<<b[i]<<":->"<<c<<endl;
    }
    cout<<(c == 999)?-1:ret<<'
';
    return;
}

int main()
{
    string s1, s2;
    int i = 0, j = 0;
    
    getline(cin, s1);
    stringstream ss1(s1);
    while(ss1>>a[i++]);
    
    getline(cin, s2);
    stringstream ss2(s2);
    while(ss2>>b[j++]);
    
    fun(a, b, i-1, j-1);
    
    return 0;
}

*/

 2019-02-24

16:29:08