2018研究生推免上机考试

区间内的真正素数

考察点：

• 素数筛选（埃式筛法如下）：

void get_prime(){
    is_prime[0] = is_prime[1] = 0;
    for(int i=2; i

• 数的转置：

int reverse_num(int x){
    int res = 0;
    do{
        res = res*10 + x%10;
        x/=10;
    }while(x!=0);
    return res;
}

简单密码：

考察点

• 带空格字符串的输入：

#include 
using namespace std;

int main(){
    string s;
    while(getline(cin, s)){   //cin 在前
        cout << s << endl;
    }
}

拯救公主

考察点：广搜

• 搜索空间：（x,y,v）
• 状态扩展规则
  • 移动规则：上下左右移动， 时间加一。
  • 跳跃规则：按能量跳跃，跳出墙了落在靠墙的地方，且时间不变。
  • 可以选择跳也可以不跳。
• 有效状态：
  • 不出墙
  • 跳跃后不是陷阱
• 标记：三维flag标记
• 有效状态数：max_n * max_n * max_v

最佳加法表达式

考察点：

• 动态规划：

  • 状态：dp[i][j]:前j个数字放i个加号所能达到最小值。
  • 目标：dp[m][n]
  • 状态转移: 令dp[i][j]的最后一个加号放在第k个数字后。循环考察所有可能的k。我们有 dp[i][j] = min({dp[i-1][k] + num(k+1,j) | k = 1…j-1}).
  • 初态
    • dp[0][i], i=1…length = num(1,i).
    • dp[i][j] = inf.（不可达状态）i>=j.（这个可以在循环过程中在赋值）
  • 状态转移示意图：
    
    可以看到，状态转移始终只依赖于左上角部分，因此可以采用行优先遍历更新。

• 大数实现：
  首先先了解java对象赋值
  java大数类常用操作
  第一次做此类题，贴完整代码

import java.math.BigInteger;
import java.util.*;

public class Main{
	
	public static void main(String[] args){
		int m;
		BigInteger number;
		final int max_n = 80;
		BigInteger inf = new BigInteger("9999999999999999999999999999999999");
		Scanner cin = new Scanner(System.in);
		BigInteger[][] dp = new BigInteger[max_n][max_n];
		BigInteger tmp, mm;
		while(cin.hasNext()){
			m = cin.nextInt();
			number = cin.nextBigInteger();
			
			//初始化
			int length = number.toString().length();
		
			for(int i=1; i<=length; i++){
				dp[0][i] = new BigInteger(number.toString().substring(0, i));
			}
			dp[0][0] = inf;
			
			for(int i=1; i<=m; i++){
				for(int j=1; j<=length; j++){
					dp[i][j] = inf;
					if(i >= j)
						continue;
					mm = inf;
					for(int k=i; k<=j-1; k++){
						if(dp[i-1][k].equals(inf))
							continue;
						tmp = dp[i-1][k].add(new BigInteger(number.toString().substring(k, j)));
						dp[i][j] = dp[i][j].min(tmp);
					}
				}
			}
			
			System.out.println(dp[m][length]);
		}
		cin.close();
		
	}
	
}

热血格斗场

分析：由于每个人的战斗力不同，因此我们可以使用map做power2id的映射。
然后根据map.lower_bound来确定需要挑战的人。
知识点.

• map配合lower_bound的使用,使用示意图如下
  
• 注意：迭代器不可以使用 pos+1/-1，只能使用pos++.
• 引入包
• 声明迭代器map:: iterator pos;
  第一次使用map+lower_bound（）:贴源码:

#include 
#include 
#include 

Bug’s life

分析：满足带权并查集的问题求解条件，使用带权并查集,分析见此
代码：

#include 
#include 
#include 
using namespace std;

const int max_n = 2000+5;
int father[max_n];
int r[max_n];

void init(){
    memset(father, -1 ,sizeof(father));
    memset(r, 0, sizeof(r));
}

int find_father(int x){
    if(father[x] == -1) return x;
    int tmp = find_father(father[x]);
    r[x] = r[father[x]]^r[x]; // 与普通并查集区别，而且这里不能写反了！！！！！
    father[x] = tmp;
    return tmp;
}
int main(){
    int T;
    scanf("%d", &T);
    int n,m,a, b, fa, fb, flag;
    for(int i=1; i<=T; i++){
        init();
        flag = 1;
        scanf("%d%d", &n, &m);
        for(int j=0; j