蓝桥杯 约数倍数选卡片

思路：

搜索、博弈论。

实现的时候一个剪枝是从较大的数开始选，因为较大的数约数或倍数少一些，搜索的层数少。

还可以预处理出每个数的约数和倍数，这样搜索的时候不用扫描所有的数。

实现：

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <sstream>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXN = 105;
int a[MAXN], b[MAXN], m = 0;
vector<int> ok[MAXN];

bool check(int x, int y)
{
    int p = min(x, y);
    int q = max(x, y);
    return !(q % p);
}

void init()
{
    for (int i = 1; i < MAXN; i++)
    {
        if (a[i])
        {
            for (int j = 1; j < MAXN; j++)
            {
                if (a[j] && check(i, j))
                    ok[i].push_back(j);
            }
        }
    }
}

bool dfs(int last)
{
    for (int i = ok[last].size() - 1; i >= 0; i--)
    {
        int tmp = ok[last][i];
        if (a[tmp])
        {
            a[tmp]--;
            bool res = dfs(tmp);
            a[tmp]++;
            if (!res)
                return true;
        }
    }
    return false;
}

int main()
{
    string x;
    int t;
    stringstream s;
    getline(cin, x);
    s << x;
    while (s >> t)  a[t]++;
    init();
    s.clear();
    getline(cin, x);
    s << x;
    while (s >> b[m++]);
    m--;
    sort(b, b + m);
    int * end = unique(b, b + m);
    bool flag = true;
    for (int i = 0; i < end - b; i++)
    {
        a[b[i]]--;
        bool res = dfs(b[i]);
        a[b[i]]++;
        if (!res)
        {
            cout << b[i] << endl;
            flag = false;
            break;
        }
    }
    if (flag)
        cout << -1 << endl;
    return 0;
}

总结：

 必败点：前一个选手将取胜的位置称为必败点。

 必胜点：下一个选手将取胜的位置称为必胜点。

 必胜点和必败点属性：

 （1）所有终结点是必败点。

 （2）从任何必胜点操作，至少有一种方法可以进入必败点。

 （3）无论如何操作，从必败点都只能进入必胜点。

 可以采用递归或递推实现。

 注意函数参数的值传递的过程。

 回溯的时候不要影响标记状态的全局变量，要及时归位。