Codeforces Round #243 (Div. 2)

题目链接：CF|Round243|Div2

这套题目中规中矩， 不过可以学到一些比赛的技巧。

A：简单题， 求出所有的和并且减去最大的数。 时间复杂度 ：O(n)

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 110;
int a[N];

int main(){
    int n, s;
    scanf("%d %d", &n, &s);
    int sum = 0, max = -1;
    for(int i = 0; i < n; ++i){
        int x;
        scanf("%d", &x);
        sum += x;
        if(x > max) max = x;
    }
    if(sum - max <= s) printf("YES\n");
    else printf("NO\n");
    return 0;
}

B：简单题。 求一个矩阵的最小“子矩阵”， 不断递归判断即可。 时间复杂度：O(m*n)

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 110;
int a[N][N];
int m, n;

int gao(int l, int r){
    if((r - l + 1) & 1) return r - l + 1;
    int m = (l + r) >> 1;
    bool suc = 1;
    for(int i = l; i <= m; ++i){
        for(int j = 1; j <= n; ++j){
            if(a[i][j] != a[l + r - i][j]){
                suc = 0;
                break;
            }
        }
        if(suc == 0) break;
    }
    if(suc) return gao(l, m);
    else return r - l + 1;
}

int main(){
    scanf("%d%d", &m, &n);
    for(int i = 1; i <= m; ++i){
        for(int j = 1; j <= n; ++j)
            scanf("%d", &a[i][j]);
    }
    if(m & 1){
        printf("%d\n", m);
        return 0;
    }
    int ans = gao(1, m);
    printf("%d\n", ans);
    return 0;
}

C：逗比题。数组a，其中的数最多可以交换K次，求最大连续子序列和。

这题除了暴力枚举以外的算法是很难想出来的吧？ 考虑到数组的长度 N <= 200， 我们可以枚举最大连续子序列在交换后所在的区间[l, r]， 然后将区间外跟区间内的数组分别排序， 用区间外的最大的数去交换区间内的最小的数字即可。 时间复杂度：O(n^3*logn)， 能够接受。

获得经验值：一定要好好预估算法的时间复杂度。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 201;
int a[N], b[N], c[N];

int main(){
    int n, t;
    scanf("%d %d", &n, &t);
    for(int i = 1; i <= n; ++i) scanf("%d", &a[i]);
    int ans = -1e9;
    for(int i = 1; i <= n; ++i){
        for(int j = i; j <= n; ++j){
            int sum = 0;
            for(int k = i; k <= j; ++k){
                b[k - i] = a[k];
                sum += a[k];
            }
            int p = 0;
            for(int k = 1; k < i; ++k)
                c[p++] = a[k];
            for(int k = j + 1; k <= n; ++k)
                c[p++] = a[k];

            sort(b, b + j - i + 1);
            sort(c, c + p);

            int p1 = 0, p2 = p - 1;
            int cnt = 0;
            while(cnt < t){
                if(p1 == (j - i + 1)) break;
                if(p2 == -1) break;
                if(b[p1] >= c[p2]) break;
                sum += c[p2] - b[p1];
                ++p1, --p2;
                ++cnt;
            }
            if(sum > ans) ans = sum;
        }
    }
    printf("%d\n", ans);
    return 0;
}

D：思维题。 这道题用到了一种算法分类复合的思想。

题意是一个m*n大小的0/1矩阵， 可以对其中的某一个点进行翻转， 最多允许翻K（k <= 10）次， 问可不可以翻转出一个矩阵：这个矩阵是由一个个小的矩阵块构成的， 且每一个矩阵块内部数字相同， 且与周边的矩阵块数字不同， 如果有求出最小的翻转次数。

首先要知道的是： 达到要求的矩阵， 相邻行之间要么是完全相同要么是完全相反， 列之间也是这样的关系。 

1.  如果n <= 10 ，那么对第一行的状态进行枚举， 这样以后各行的状态就可以由第一行的状态确定， 要么与之相同要么与之相反。进行统计比较即可。

2.  如果n > 10,  按照上面的那种方法枚举第一行的状态显然状态过多， 这时候我们考虑k， 因为最多翻转K次，且K <= 10, 那么可以确定的是： 至少有一列是不会被翻转的。这样我们可以枚举不会被翻转的那一列， 进行统计比较。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 101;
int a[N][N], b[N][N];
int m, n, LIM;
int ans;

void gao(){
    int ans = 1e9;
    for(int sta = 0; sta < (1 << n); ++sta){
        int tot = 0;
        for(int i = 0; i < m; ++i){
            int cnt = 0;
            for(int j = 0; j < n; ++j){
                if(a[i][j] == 0 && ((sta & (1 << j)) == 0))
                    ++cnt;
                if(a[i][j] && (sta & (1 << j)))
                    ++cnt;
            }
            if(n - cnt < cnt) tot += n - cnt;
            else tot += cnt;
        }
        if(tot < ans) ans = tot;
    }
    if(ans <= LIM) printf("%d\n", ans);
    else printf("-1\n");
}

void gaoAgain(){
    for(int i = 0; i < m; ++i){
        for(int j = 0; j < n; ++j){
            for(int k = 0; k < n; ++k){
                if(a[i][j] == a[i][k])
                    ++b[j][k];
            }
        }
    }

    int ans = 1e9;
    for(int i = 0; i < n; ++i){
        int cnt = 0;
        for(int j = 0; j < n; ++j){
            cnt += ((b[i][j] > (m - b[i][j]) ? m - b[i][j] : b[i][j]));
        }
        if(cnt < ans) ans = cnt;
    }
    if(ans <= LIM) printf("%d\n", ans);
    else printf("-1\n");
}

int main(){
    scanf("%d %d %d", &m, &n, &LIM);
    for(int i = 0; i < m; ++i){
        for(int j = 0; j < n; ++j)
            scanf("%d", &a[i][j]);
    }
    if(n <= 10) gao();
    else gaoAgain();
    return 0;
}

E：待补。