[Offer收割]编程练习赛33

矩阵游戏II

把每列的数字加起来当一行处理。因为每次操作两列，所以最后最多剩下一个负数。如果负数的个数是偶数，直接所有数字的绝对值加起来即可；若负数个数为奇数，把所有数的绝对值加起来减去其中最小的绝对值的两倍即可。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int a[][];
int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    int n;
    scanf("%d", &n);
    for (int i = ; i < n; i++) {
        for (int j = ; j < n; j++) {
            scanf("%d", &a[i][j]);
        }
    }
    for (int i = ; i < n; i++) {
        for (int j = ; j < n; j++) {
            a[][j] += a[i][j];
        }
    }
    int cnt = , ans = , min = ;
    for (int i = ; i < n; i++) {
        if (a[][i] < ) {
            cnt++;
            a[][i] = - * a[][i];
        }
        ans += a[][i];
        if (a[][i] < min) {
            min = a[][i];
        }
    }
    if (cnt %  != ) {
        ans -=  * min;
    }
    printf("%d\n", ans);
    return ;
}

是二叉搜索树吗？

先判断树：首先判断是不是只有一个点没有父亲，然后判断从这个没有父亲的点dfs能否访问到其他所有的点。

二叉树：每个点最多两个儿子就可以了。

二叉搜索树：左子树最大的点小于根节点，右子树最小的点大于根节点。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
using namespace std;
vector<int> G[];
bool f[];
int n, t;
int max_[], min_[];
bool erchashucuowu() {
    for (int i = ; i <= n; i++) {
        if (G[i].size() > ) {
            return true;
        }
    }
    return false;
}
void dfsmax(int r) {
    int ret = r;
    for (int i = ; i < G[r].size(); i++) {
        dfsmax(G[r][i]);
        if (max_[G[r][i]] > ret) {
            ret = max_[G[r][i]];
        }
    }
    max_[r] = ret;
}
void dfsmin(int r) {
    int ret = r;
    for (int i = ; i < G[r].size(); i++) {
        dfsmin(G[r][i]);
        if (min_[G[r][i]] < ret) {
            ret = min_[G[r][i]];
        }
    }
    min_[r] = ret;
}
bool bushisousuoshu(int r) {
    if (G[r].size() == ) {
        return false;
    }
    if (G[r].size() == ) {
        if (G[r][] < r) {
            if (max_[G[r][]] > r) {
                return true;
            }
        } else {
            if (min_[G[r][]] < r) {
                return true;
            }
        }
        return bushisousuoshu(G[r][]);
    }
    if (max_[G[r][]] > r) {
        return true;
    }
    if (min_[G[r][]] < r) {
        return true;
    }
    return (bushisousuoshu(G[r][]) || bushisousuoshu(G[r][]));
}
void dfs(int r) {
    printf("(");
    printf("%d", r);
    if (G[r].size() == ) {
        printf("()()");
    }
    if (G[r].size() == ) {
        if (G[r][] < r) {
            dfs(G[r][]);
            printf("()");
        } else {
            printf("()");
            dfs(G[r][]);
        }
    }
    if (G[r].size() == ) {
        dfs(G[r][]);
        dfs(G[r][]);
    }
    printf(")");
}
void jianchashu(int r) {
    if (f[r]) {
        return;
    }
    f[r] = true;
    for (int i = ; i < G[r].size(); i++) {
        jianchashu(G[r][i]);
    }
}
bool jianchashushu() {
    for (int i = ; i <= n; i++) {
        if (!f[i]) {
            return false;
        }
    }
    return true;
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    scanf("%d", &t);
    while (t--) {
        scanf("%d", &n);
        for (int i = ; i <= n; i++) {
            G[i].clear();
        }
        memset(f, true, sizeof(f));
        for (int i = ; i < n; i++) {
            int a, b;
            scanf("%d%d", &a, &b);
            G[a].push_back(b);
            f[b] = false;
        }
        for (int i = ; i <= n; i++) {
            sort(G[i].begin(), G[i].end());
        }
        int cnt = , id = -;
        for (int i = ; i <= n; i++) {
            if (f[i]) {
                cnt++;
                id = i;
            }
        }
        if (cnt != ) {
            printf("ERROR1\n");
            continue;
        }
        memset(f, false, sizeof(f));
        jianchashu(id);
        if (!jianchashushu()) {
            printf("ERROR1\n");
            continue;
        }
        if (erchashucuowu()) {
            printf("ERROR2\n");
            continue;
        }
        dfsmax(id);
        dfsmin(id);
        if (bushisousuoshu(id)) {
            printf("ERROR3\n");
            continue;
        }
        dfs(id);
        printf("\n");
    }
    return ;
}

方格取数

动态规划：dp[i][j][k]表示走到第i个斜行，两条路分别位于第i斜行的第j和第k个方格。为保证不相交，设j<k。j和k分别可能由上一行的格子向右或向下走到，共4种前状态，取其中最大值加上jk两个方格中的数字即可。

因为n最大为400，数组开全会MLE。考虑到每次状态转移的时候只会用到i-1中的值，所以可以把dp开成[2][400][400]，两个数组轮换使用。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int a[][], dp[][][];
int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    int n;
    scanf("%d", &n);
    for (int i = ; i <= n; i++) {
        for (int j = ; j <= n; j++) {
            scanf("%d", &a[i][j]);
        }
    }
    memset(dp, , sizeof(dp));
    dp[][][] = a[][];
    for (int i = ; i <  * n - ; i++) {
        int m = i < n ?  i :  * n - i;
        for (int j = ; j < m; j++) {
            for (int k = j + ; k <= m; k++) {
                int x1, x2, y1, y2, tmp = , last = (i - ) % ;
                if (i <= n) {
                    x1 = i - j + ;
                    y1 =  + j - ;
                    x2 = i - k + ;
                    y2 =  + k - ;
                    if (dp[last][j][k] > tmp) {
                        tmp = dp[last][j][k];
                    }
                    if (dp[last][j - ][k - ] > tmp) {
                        tmp = dp[last][j - ][k - ];
                    }
                    if (dp[last][j][k - ] > tmp) {
                        tmp = dp[last][j][k - ];
                    }
                    if (dp[last][j - ][k] > tmp) {
                        tmp = dp[last][j - ][k];
                    }
                } else {
                    x1 = n - j + ;
                    y1 = i - n + j;
                    x2 = n - k + ;
                    y2 = i - n + k;
                    if (dp[last][j][k] > tmp) {
                        tmp = dp[last][j][k];
                    }
                    if (dp[last][j + ][k + ] > tmp) {
                        tmp = dp[last][j + ][k + ];
                    }
                    if (dp[last][j][k + ] > tmp) {
                        tmp = dp[last][j][k + ];
                    }
                    if (dp[last][j + ][k] > tmp) {
                        tmp = dp[last][j + ][k];
                    }
                }
                dp[ - last][j][k] = tmp + a[x1][y1] + a[x2][y2];
            }
        }
    }
    printf("%d\n", dp[][][] + a[n][n] *  + a[][]);
    return ;
}

单词接龙

这题思路是想好了，代码实现起来太费时间，手太慢不写了。

设f[i]表示以第i个单词开始能往后构造的长度。

从单词s开始可以把26个字母分别加在左边或右边，共52种可能的接龙方式。从这52个f值中选一个最大的加1即可。因为顺序没法确定，所以用dfs来算：for (int i=0;i<n;i++) dfs(i);

题目中直说单词总长度小于1000000，没说每个单词最大长度，很讨厌。

每个单词的52种扩展中不一定全在字典里，所以要用一个Trie树来判断。因为单词很长，所以不能一个词一个词的分开存，只能全存在一个数组里然后记录各个端点，用的时候sscanf。