SRM DIV2 575 TheNumberGameDivTwo

【题意】：两个人玩游戏，给定一个数，减去他的因子（除了1和他本身外）得到一个新数，两个人轮流玩游戏.最后谁无数可减即为失败。  

【算法】根据N/P分析：

1.标记出1-1000所有的质数，这都是必败点P

2.从小到大，如果不是质数，则根据N/P关系判断他是N还是P。

3.直到n为止。

一个P/N分析的例子http://blog.sina.com.cn/s/blog_87ad13a10100y3ay.html

【编码调试BUG】

1.49行，生成prime数组的时候，循环结束条件应该是i<=n/2，少考虑了等号的情况；

2.23行，j<i-1写成了j<i，忽略掉了1。

 

【Java代码】来自菜鸟 

import java.util.*;
import java.util.regex.*;
import java.text.*;
import java.math.*;


public class TheNumberGameDivTwo
{
    boolean[] prime;
    public String find(int n)
    {
        int i,j,temp;
        boolean[] p = new boolean[n+1];
        
        getPrimes(n);
        //init all primes to P
        for(i=1;i<=n;i++)
            p[i]=prime[i];
        
        for(i=1;i<=n;i++){
            if(p[i])
                continue;
            for(j=2;j<i-1;j++){
                if(p[j]){
                    temp=i-j;
                    if(i%temp==0)
                        break;//p[i] is N
                }
            }
            if(j==i+1)
                p[i]=true;//p[i] is P
        }
        if(p[n])
            return "Brus";
        else
            return "John";
    }
    
    public void getPrimes(int n){
        prime = new boolean[n+1];
        int i,j;
        
        for(i=1;i<=n;i++)
            prime[i]=true;
        
        prime[0]=prime[1]=false;
        
        for(i=2;i<=n/2;i++){
            if(!prime[i])
                continue;
            for(j=i+i;j<=n;){
                prime[j]=false;
                j+=i;
            }
        }        
    }
}
//Powered by KawigiEdit 2.1.4 (beta) modified by pivanof!

【改进版1】

【算法】

1.从小到大，则根据N/P关系判断他是N还是P（类似动态规划的填表）。

2.直到n为止。

【分析】

1.无需求出prime，因为算法可以保证所有的prime都为P。

import java.util.*;
import java.util.regex.*;
import java.text.*;
import java.math.*;


public class TheNumberGameDivTwo
{
    public String find(int n)
    {
        int i,j;
        boolean[] p = new boolean[n+1];
        
        p[1]=true;
        for(i=2;i<=n;i++){
            for(j=2;j<i;j++){
                if(i%j==0){
                    if(p[i-j]==true){
                        p[i]=false;
                        break;
                    }
                }
            }
            if(j==i)
                p[i]=true;

        }
        if(p[n])
            return "Brus";
        else
            return "John";
    }
    

}
//Powered by KawigiEdit 2.1.4 (beta) modified by pivanof!

【改进版2】实现时有点小区别，算法不变

import java.util.*;
import java.util.regex.*;
import java.text.*;
import java.math.*;


public class TheNumberGameDivTwo
{
    public String find(int n)
    {
        int i,j;
        boolean[] p = new boolean[n+1];
        
        
        for(i=1;i<=n;i++){
            for(j=i/2;j<i-1;j++){
                if(p[j]){
                    if(i%(i-j)==0)
                        break;//p[i] is N
                }
            }
            if(j==i-1)
                p[i]=true;//p[i] is P
        }
        if(p[n])
            return "Brus";
        else
            return "John";
    }
}
//Powered by KawigiEdit 2.1.4 (beta) modified by pivanof!

【Java代码】来自大神

【分析】

1.大神采用的是动态规划的递归实现。

2.P问题对应memo[i]=0,N问题对应memo[i]=1。

3.divisors(n)方法用于获取n的所有除数。

【学习】

1.Arrays.fill()这个方法不错啊，有点像C里的memset。

import java.util.*; 

public class TheNumberGameDivTwo { 

  ArrayList<Integer> divisors(int n) { 
    ArrayList<Integer> res = new ArrayList<Integer>(); 
    for (int i = 2; i * i <= n; i++) { 
      if (n % i == 0) { 
        res.add(i); 
        if (!res.contains(n / i)) 
          res.add(n / i); 
      } 
    } 
    return res; 
  } 

  int[] memo; 

  public int can(int n) { 
    if (n == 1 || n == 2 || n == 3) 
      return 0; 
    if (memo[n] != -1) 
      return memo[n]; 
    int res = 0; 
    ArrayList<Integer> divs = divisors(n); 
    for (int i = 0; i < divs.size(); i++) { 
      res |= can(n - (int)(divs.get(i))) ^ 1; 
    } 
    return memo[n] = res; 
  } 

  public String find(int n) { 
    memo = new int[n + 2]; 
    Arrays.fill(memo, -1); 
    return can(n) > 0 ? "John" : "Brus"; 
  } 

} 



// Powered by FileEdit
// Powered by moj 4.17 [modified TZTester]
// Powered by CodeProcessor

【C++代码】来自大神

【分析】

1.大神也是DP的递归实现。

2.代码好简洁，好帅气！

#include<iostream>
#include<string>
#include<map>
#include<vector>
#include<queue>
#include<stack>
#include<set>
#include<algorithm>
#include<sstream>
#include<iomanip>
#include<cstring>
#include<bitset>
#include<fstream>
#include<cmath>
#include<cassert>
#include <stdio.h>
#include<ctype.h>
#include<ctime>
using namespace std ;
#define rep(i,n,m) for( int i = (int) n ; i < (int) m ; ++i )
 
#define mems(arr,v) memset(arr,v,sizeof arr)
 
class TheNumberGameDivTwo {
public:
  string find(int n);
};
int dp[10001];
int rec(int n) {
  if(n == 1)
    return false;
  if(dp[n] != -1)
    return dp[n];
  rep(i, 2, n)
    if(n % i == 0 && !rec(n - i))
      return dp[n] = true;
  return dp[n] = false;
}
string TheNumberGameDivTwo::find(int n) {
  mems(dp, -1);
  return rec(n) ? "John" : "Brus" ;
}
 
 
 
//Powered by KawigiEdit 2.1.8 (beta) modified by pivanof!
//With unused code cleaner (beta) by ahmed_aly

 

【总结】

1.N/P属于博弈论范畴，应该用DP实现。