历届试题 约数倍数选卡片
时间限制：1.0s 内存限制：256.0MB
- 锦囊1
- 博弈论。
问题描述
闲暇时，福尔摩斯和华生玩一个游戏：
在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
分析：
参考链接https://blog.csdn.net/qq_33729889/article/details/68541092
博弈论的理论就是，对手的必败态就是我的必胜态。需要注意的是只要某个选择可以导致对手出现必败态，则这个选择就是正确的，可以直接返回；而当我所有选择走了一遍之后，发现并没有返回，即并没有对手的必败态，才可以说明这是我的必败态。
1. 原始错误代码：
import java.util.Arrays;
import java.util.Scanner;
public class Main {
static int a[];
static int b[];
static int n , flag = 0, n2;
static boolean vis[];
public static void main(String[] args) {
Scanner sca = new Scanner(System.in);
String str1[] =sca.nextLine().split(" ");
n = str1.length;
a = new int[n];
vis = new boolean[n];
for(int i = 0; i < n; i ++) {
a[i] = Integer.parseInt(str1[i]);
}
String str2[] =sca.nextLine().split(" ");
n2 = str2.length;
b = new int[n2];
int t = 0;
for(int i = 0; i < n2; i ++) {
flag = 0;
b[i] = Integer.parseInt(str2[i]);
t = find(b[i]);
vis[t] = true;
Nim(b[i], 1 , 1);
vis[t] = false;
if(flag == 0) {
System.out.println(b[i]);
return;
}
}
System.out.println(-1);
}
private static int find(int t) {
for(int i = 0; i < n; i ++) {
if(!vis[i] && t == a[i]) {
return i;
}
}
return -1;
}
/**
* 递归选数
* @param nt 当前被选数
* @param ns 当前共选择数目
* @param f 当前轮到谁选数 1 ： 华生 -1： 福尔摩斯
*/
private static void Nim(int nt, int ns , int f) {
//跳出循环
if(ns == n || flag != 0) {
return;
}
int flag2 = 0;
for(int i = 0; i < n; i ++) {
if(!vis[i] && (a[i] % nt == 0 || nt % a[i] == 0)) {
vis[i] = true;
Nim(a[i], ns + 1, -f);
vis[i] = false;
flag2 = 1;
}
if(flag2 == 0 && i == n- 1) {
if(f == -1) {
flag = 1;
}
}
}
}
}
原因：这种方法当福尔摩斯选择的时候并不是最优方法，而是随意选择的第一个符合条件的进行。所以答案会出现错误，运行结果为0分。所以说并没有体现博弈的真正原理。
2 博弈在这里的应用
分析：
- 当福尔摩斯选后，如果华生没有选择的话结果返回-1，福尔摩斯当前选择必胜
- 当福尔摩斯选后，如果华生有选择的话，进入福尔摩斯再选：
-
福尔摩斯若无选择则返回-1时，那么当前华生胜利，最终返回1
-
福尔摩斯若有选择，如果华生没有选择的话结果返回-1，福尔摩斯当前返回1，华生进行下一个选择
- 如此递归下去.......
反正注意的是华生是可以进行下一次选择
超时代码：
/**
*@author 杨雨婷
*@date 2019年5月11日
*/
package 约数倍数选卡片;
import java.util.Scanner;
public class Main {
static int a[];
static int b[];
static int n , n2;
static boolean vis[];
public static void main(String[] args) {
Scanner sca = new Scanner(System.in);
String str1[] =sca.nextLine().split(" ");
n = str1.length;
a = new int[n];
vis = new boolean[n];
for(int i = 0; i < n; i ++) {
a[i] = Integer.parseInt(str1[i]);
}
String str2[] =sca.nextLine().split(" ");
n2 = str2.length;
b = new int[n2];
int t = 0;
for(int i = 0; i < n2; i ++) {
b[i] = Integer.parseInt(str2[i]);
t = find(b[i]);
vis[t] = true;
int flag = Nim(b[i], 1 );
vis[t] = false;
if(flag == -1) {
System.out.println(b[i]);
return;
}
}
System.out.println(-1);
}
private static int find(int t) {
for(int i = 0; i < n; i ++) {
if(!vis[i] && t == a[i]) {
return i;
}
}
return -1;
}
/**
递归选数
* @param nt 当前被选数
* @param ns 当前共选择数目
* @return 当前轮到华生选数 1 ： 选到 -1： 选不到
*/
private static int Nim(int nt, int ns) {
int t = 0;
int flag2 = 0;
for(int i = n - 1; i >= 0; i --) {
if(!vis[i] && (a[i] % nt == 0 || nt % a[i] == 0)) {
vis[i] = true;
t = Nim(a[i], ns + 1);
vis[i] = false;
flag2 = 1;
if(t == -1) {
return 1;
}
}
}
return -1;
}
}
时间空间花费：
错误分析：
每当福尔摩斯去自己的数的时候都要判断自己的上在a的下标，而且但进行递归的时候每次都要对a进行扫描遍，所以说会大大增加工作量，下面方法可以跑满分。
3 增加数组缓存
参考答案：
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class 答案 {
/**
* 在被选数中取走start
* @param numA 所有被选数
* @param listA 所有被选数中的约数和倍数
* @param start 取走start
* @return -1 华生输 1 夏洛克输
*/
public static int dfs(int[] numA, ArrayList<Integer>[] listA, int start) {
for(int i = listA[start].size() - 1;i >= 0;i--) { //从后向前取数
if(numA[listA[start].get(i)] > 0) { //被选数还有可取输，则取出
numA[listA[start].get(i)]--;
int t = dfs(numA, listA, listA[start].get(i));
numA[listA[start].get(i)]++;
if(t == -1)
return 1;
}
}
return -1;
}
/**
* 计算结果
* @param A 所有被选数
* @param B 夏洛克可选数
*/
public static void getResult(String A, String B) {
int[] numA = new int[105]; //存放所有被选数
@SuppressWarnings("unchecked")
ArrayList<Integer>[] listA = new ArrayList[105];
for(int i = 1;i < 105;i++)
listA[i] = new ArrayList<Integer>();
ArrayList<Integer> listB = new ArrayList<Integer>();
String[] arrayA = A.split(" ");
String[] arrayB = B.split(" ");
for(int i = 0;i < arrayA.length;i++) {
int a = Integer.valueOf(arrayA[i]);
numA[a]++;
}
for(int i = 1;i <= 100;i++) {
if(numA[i] != 0) { //从被选数中选择一个数
numA[i]--;
for(int j = 1;j <= 100;j++) //将其约数和倍数加入到集合listA[i]中
if(numA[j] != 0 && (i % j == 0 || j % i == 0))
listA[i].add(j);
numA[i]++;
}
}
for(int i = 0;i < arrayB.length;i++) {
int b = Integer.valueOf(arrayB[i]);
listB.add(b);
}
Collections.sort(listB); //对b进行排序
for(int i = 0;i < listB.size();i++) {
numA[listB.get(i)]--; //将所有被选数中的对应的b数取走
int t = dfs(numA, listA, listB.get(i));
numA[listB.get(i)]++;
if(t == -1) {
System.out.println(listB.get(i));
return;
}
}
System.out.println("-1");
return;
}
public static void main(String[] args) {
答案 test = new 答案();
Scanner in = new Scanner(System.in);
String A = in.nextLine();
String B = in.nextLine();
test.getResult(A, B);
}
}此答案满分
时间空间消耗：
500
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
