bupt summer training for 16 #1 ——简单题目

D.What a Mess

给n个数，求其中能满足 a[i] % a[j] == 0 的数对之和

n = 1W，max_ai = 100W 不是很大，所以就直接筛就可以了

计算可得最高复杂度 < 1kW

...考场上写了这个解法，结果把 j += i 写成了 j ++ ...

我还以为是单个测试点case太多...多么痛的领悟...

#include <bits/stdc++.h>

using namespace std;

int Case, n, m, k, a[10010], b[1000010];

int main() {
    scanf("%d", &Case);
    while(Case --) {
        m = 0, k = 0;
        scanf("%d", &n);
        for(int i = 1;i <= n;i ++) scanf("%d", &a[i]), b[a[i]] ++, k = max(k, a[i]);
        for(int i = 2;i <= k;i ++) {
            if(!b[i]) continue;
            m += b[i] * (b[i] - 1) / 2;
            for(int j = i << 1;j <= k;j += i)
                m += b[j] * b[i];
        }
        printf("%d
", m);
        for(int i = 1;i <= n;i ++) b[a[i]] --;
    }
    return 0;
}

H.Paint it really, really dark gray

之前写过...但因为清楚记得之前调了一段时间...最后时间不是很多就去看D了...迷

假如递归过程中，当前节点的子节点都是叶子节点，那么只要访问一下需要染色的节点再回来就可以了

这样它的子节点都满足要求了，那么当前节点就可以看作是叶子节点了，然后处理上一层...

#include <bits/stdc++.h>

using namespace std;

int n, a[200010], v[200010];

vector <int> e[200010], ans;

bool d[200010];

void dfs(int x) {
    a[x] = d[x] = (a[x] == -1), v[x] = 1;
    for(int i = 0;i < e[x].size();i ++) {
        if(v[e[x][i]]) continue;
        dfs(e[x][i]);
        d[x] |= d[e[x][i]];
    }
}

void dfs_(int x, int f) {
    a[x] ^= 1, ans.push_back(x);
    for(int i = 0;i < e[x].size();i ++) {
        if(e[x][i] == f) continue;
        if(d[e[x][i]]) dfs_(e[x][i], x), ans.push_back(x), a[x] ^= 1;
    }
    if(a[x] && x != 1) ans.push_back(f), ans.push_back(x), a[f] ^= 1, a[x] ^= 1; 
}

int main() {
    ios::sync_with_stdio(false);
    cin >> n;
    for(int i = 1;i <= n;i ++) cin >> a[i];
    int u, v;
    for(int i = 1;i < n;i ++) {
        cin >> u >> v;
        e[u].push_back(v);
        e[v].push_back(u);
    }
    dfs(1), dfs_(1, 0);
    for(auto it : ans) printf("%d ", it);
    if(!a[1]) printf("%d 1 %d", e[1][0], e[1][0]);
    return 0;
}

A.Treasure Island

数据范围其实不大，对于不止一种解的解决办法

就暴力测试每一个 '?' 就可以了

#include <bits/stdc++.h>

#define rep(i, j, k) for(int i = j;i <= k;i ++)

int n, m, sx, sy, cnt, lcnt, last;

char s[60][60];

int mmp[60][60];

const int xx[] = {0, 0, 1, -1};
const int yy[] = {1, -1, 0, 0};

void dfs(int x, int y, int nx = 0, int ny = 0) {
    cnt ++;
    rep(i, 0, 3) {
        nx = x + xx[i], ny = y + yy[i];
        if(nx > 0 && nx <= n && ny > 0 && ny <= m && s[nx][ny] != '#' && !mmp[nx][ny]) {
            mmp[nx][ny] = 1;
            if(s[nx][ny] == '?') s[nx][ny] = '!';
            dfs(nx, ny);
        }
    }
}

int main() {
    scanf("%d %d", &n, &m);
    rep(i, 1, n) scanf("%s", s[i] + 1);
    rep(i, 1, n) rep(j, 1, m) 
        if(s[i][j] == '.' && !mmp[i][j]) {
            lcnt ++, sx = i, sy = j;
            if(lcnt == 2) {
                puts("Impossible");
                return 0;
            }
            mmp[i][j] = 1, dfs(i, j);
        }
    last = cnt;
    rep(i, 1, n) rep(j, 1, m) {
        if(s[i][j] == '?') s[i][j] = '#';
        else if(s[i][j] == '!') {
            s[i][j] = '#', cnt = 0;
            memset(mmp, 0, sizeof mmp);
            mmp[sx][sy] = 1, dfs(sx, sy);
            if(cnt + 1 == last) {
                puts("Ambiguous");
                return 0;
            }
            else s[i][j] = '.';
        }
    }
    rep(i, 1, n) puts(s[i] + 1);
    return 0;
}