USACO training chapter1 入门/section1.6

第一章终于完结了，撒花。

Number Triangles（DP）

经典的数字三角形，一般用来入门动态规划。
把三角形存储在矩阵里，每行下标从0开始存。
$dp[i][j]$ 代表到第i行第j个数字的最大数字和。
状态转移：
$dp[i][j]=max([dp[i-1][j],dp[i-1][j-1])$

/*
ID: b1703011
TASK: numtri
LANG: C++                 
*/
#include <iostream>
using namespace std;
int s[1010][1010];
int dp[1010][1010];

int main(){
	freopen("numtri.in", "r", stdin);
	freopen("numtri.out", "w", stdout);

    int N;	cin >> N;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < i+1; j++) {
            cin >> s[i][j];
        }
    }

    dp[0][0] = s[0][0];
    int res = 0;
    for (int i = 1; i < N; i++) {
        for (int j = 0; j < i+1; j++) {
            dp[i][j] = dp[i-1][j] + s[i][j];
            if (j - 1 >= 0) dp[i][j] = max(dp[i][j], dp[i-1][j-1] + s[i][j]);
            res = max(res, dp[i][j]);
        }
    }
    cout << res << endl;
    return 0;
}

Prime Palindromes（埃筛）

判断给定范围内的回文质数。
首先数字范围很大，直接上筛法（筛法是用来求一个范围内所有素数的常用方法，又称埃氏筛法）。但是直接把数组开到最大还是会爆。
这个时候就要百度了，发现回文质数的一些性质
1）回文质数末尾不可能是偶数。
2）除了11，偶数位的数不存在回文质数。
所以好说了，题目给的范围1e8，末尾是偶数，所以缩小范围，但是1e7-1e8 的数都是偶数位数，不予考虑，所以只考虑到1e6到1e7这么大就行了，也就是说数组开到1e7这个量级就可以了。

/*
ID: b1703011
TASK: pprime
LANG: C++                 
*/
#include <iostream>
#include <cstring>
using namespace std;
const int max_n = 10000010;
bool prime[max_n];
int a, b;

void getPrime() {
	//筛法得到素数表
    for (int i = 2; i <= b; i++) prime[i] = 1;
    for (int i = 2; i <= b; i++) {
        if(!prime[i]) continue;
        for (int j = 2 * i; j <= b; j += i)
            prime[j] = 0;
    }
}

bool isPal(int s) {
	//判断一个数字是否是回文。
   int now = s, tmp = 0;
   while (s) {
       int t = s % 10;
       tmp = tmp * 10 + t;
       s /= 10;
   }
   return now == tmp;
}

int main() {
    freopen("pprime.in", "r", stdin);
    freopen("pprime.out", "w", stdout);
    
    cin >> a >> b;
    if (a % 2 == 0) a++; // 从奇数开始
    if (b >= 10000000) b = 9999999; // 缩小范围
    getPrime();
    // 从奇数开始只需要考虑所有的奇数，所以每次➕2。
    for (int i = a; i <= b; i+=2) {
        if (prime[i] && isPal(i)) 
            cout << i << endl;
    }
    return 0;
}

SuperPrime Rib（dfs）

不错的一道题，还是判断素数。
我第一想法还是筛法，但是无奈数据范围又又超了。8位数。
所以换个方法来做，之前USACO的TEXT里面提到过这个题可用dfs，
确实。但是直接dfs的话肯定会超时的，和循环也没得差。
那么该如何优化？首先我们用dfs来生成一个数字，那么如果对于每一位数都从1到9这么生成，最后又一个一个判断，肯定很慢。但是稍加观察就会发现，如果要在一个数的末尾加上一位使得形成的数仍然是素数，那么加的这个数就只能1，3，7，9，这个是显而易见的。所以我们每次只考虑加这几个数，在判断是不是素数，如果不是就停止接下来的dfs，换一个数字重新考虑。于是我们在开始时只需要枚举第一个数就好了，就是2，3，5，7。

/*
ID: b1703011
TASK: sprime
LANG: C++                 
*/

#include <iostream>
#include <cmath>
using namespace std;
int n;
bool prime[12] = {0, 0, 1, 1, 0, 1, 0, 1, 0, 0}; //素数表
int endd[] = {1, 3, 7, 9}; // 加在末尾的数

bool isPrime(int num) {
    for (int i = 2; i * i <= num; i++) {
        if (num % i == 0) return false;
    }
    return true;
}

void dfs(int num, int pos) {
// pos代表到了第pos位数。
    if(pos <= n) {
        for (int i = 0; i < 4; i++) {
            int nw = num * 10 + endd[i];
            if(!isPrime(nw)) continue;
            //如果不是素数就停止dfs。
            dfs(nw, pos+1);
        }
    } 
    else cout << num << endl;
}

int main() {
	freopen("sprime.in", "r", stdin);
	freopen("sprime.out", "w", stdout);
	
    cin >> n;
    for (int i = 2; i < 10; i++) {
        if (!prime[i]) continue;
        dfs(i, 2);        
    }
        
    return 0;
}