2019 Multi-University Training Contest 4

我又变菜了。。

1001 - AND Minimum Spanning Tree

分析：每个数接在二进制下第一个0的权值下，如果大于n就接在1上面。

#include <bits/stdc++.h>

using namespace std;
const int maxN = 2e5 + 7;
int N, ans[maxN];

int main() {
    int Cas;
    scanf("%d", &Cas);
    while (Cas--) {
        scanf("%d", &N);
        int Ans = 0;
        int tmp = log2(1. * N);
        tmp = 1 << tmp;
        for (int i = 2; i <= N; i++) {
            if (i % 2 == 0) ans[i] = 1;
            else {
                int cnt = 0;
                int x = i;
                while(x){
                    if(x&1){
                        x>>=1;
                        cnt++;
                    }
                    else break;
                }
                if((1<<cnt)<=N)
                ans[i] = 1<<cnt;
                else {
                    Ans++;
                    ans[i]=1;
                }
            }
        }
        printf("%d\n", Ans);
        for (int j = 2; j <= N; ++j) {
            printf("%d%c", ans[j], (j == N ? '\n' : ' '));
        }
    }
}

1003 - Divide the Stones

分析：判断n*(n+1)/2是否可以整除K。然后可以把n分成n/k个块，每组从每个块里面拿一个。

如果块是偶数的话，那么直接从两边取就可以了。

如果块是奇数的话，那么k一定是奇数。

n/k是奇数，那么n+1一定是偶数，n为奇数，要n能整除k，那么k一定不是偶数，所以k是奇数。

所以对于块为奇数的，先将前面的块当作偶数块处理，最后剩下3个块，按照如下方式进行分配：

第一个块的起始位置为第一个元素，第二块的起始位置为中间的元素，第三个块的起始位置为最后一个元素

然后第一个块从1到mid，第二个块从mid到最后一个，第三个块每次减2。

然后第一个块从mid+1到最后，第二个块从1到mid，第三个块从倒数第二个，每次减2。

然后最后特判一下n==k和n==1的情况就可以了，没判WA掉了GG。

#include "bits/stdc++.h"

using namespace std;
vector<int> v[100004];

int main() {
    int t;
    cin >> t;
    while (t--) {
        long long n, k;
        scanf("%lld%lld", &n, &k);
        long long sum = (n + 1) * n / 2;
        if (n == k && n == 1) {
            puts("yes");
            puts("1");
        } else if (n == k)puts("no");
        else if (sum % k != 0)puts("no");
        else {
            for (int i = 0; i <= k; ++i) {
                v[i].clear();
            }
            bool ok = 1;
            long long num = n / k;
            if ((num & 1) && (k % 2 == 0))ok = 0;
            else if (num & 1) {
                for (int i = 1; i + 3 <= num; i += 2) {
                    for (int j = 1; j <= k; ++j) {
                        v[j].push_back(k * (i - 1) + j);
                        v[j].push_back((i + 1) * k - j + 1);
                    }
                }
                for (int j = 1; j <= (k + 1) / 2; ++j) {
                    int id = num - 2;
                    v[j].push_back((id - 1) * k + j);
                    id++;
                    v[j].push_back((id - 1) * k + j + k / 2);
                    id++;
                    v[j].push_back(id * k - (j - 1) * 2);
                }
                for (int i = (k + 1) / 2 + 1; i <= k; ++i) {
                    int id = num - 2;
                    v[i].push_back((id - 1) * k + i);
                    id++;
                    v[i].push_back((id - 1) * k + i - (k + 1) / 2);
                    id++;
                    v[i].push_back((id) * k - (i - (k + 1) / 2) * 2 + 1);
                }
            } else {
                for (int i = 1; i <= num; i += 2) {
                    for (int j = 1; j <= k; ++j) {
                        v[j].push_back(k * (i - 1) + j);
                        v[j].push_back((i + 1) * k - j + 1);
                    }
                }
            }
            if (ok) {
                puts("yes");
                for (int i = 1; i <= k; ++i) {
                    for (int j = 0; j < v[k].size(); ++j) {
                        printf("%d%c", v[i][j], (j == v[k].size() - 1 ? '\n' : ' '));
                    }
                }
            } else puts("no");
        }
    }
}

1007 - Just an Old Puzzle

分析：判断逆序对（判断的时候忽略0）和0的纵向移动距离 的奇偶性是否相同，因为0水平移动是不会改变逆序对的数量，只有纵向移动才会。

#include <bits/stdc++.h>

using namespace std;
const int maxN = 2e5 + 7;
int a[20][20];

int main() {
    int t;
    cin >> t;
    while (t--) {
        int ans = 0;
        int x, y;
        for (int i = 1; i <= 4; ++i) {
            for (int j = 1; j <= 4; ++j) {
                scanf("%d", &a[i][j]);
                if (a[i][j] != 0)
                    for (int ii = 1; ii <= i; ++ii) {
                        int maxn = 5;
                        if (ii == i)maxn = j;
                        for (int jj = 1; jj < maxn; ++jj) {
                            if (a[ii][jj] > a[i][j])ans++;
                        }
                    }
                else {
                    x = i, y = j;
                }
            }
        }
        int temp = 4 - x;
        ans %= 2;
        temp %= 2;
        if (ans == temp)puts("Yes");
        else puts("No");

    }
}

1008 - K-th Closest Distance

分析：考虑二分答案，即找[p-x,p+x]这个区间内的数是否大于等于K，然后就没了。主席树维护一下就可以了。

#include "bits/stdc++.h"

using namespace std;
struct node {
    int ls, rs, sum;
} t[20000004];
int root[1000004], cnt;

void init() {
    root[0] = cnt = t[0].ls = t[0].rs = t[0].sum = 0;
}

int upd(int pre, int l, int r, int w) {
    int pos = ++cnt;
    t[pos] = t[pre];
    t[pos].sum++;
    if (l == r)return pos;
    int mid = l + r >> 1;
    if (w <= mid)t[pos].ls = upd(t[pos].ls, l, mid, w);
    else t[pos].rs = upd(t[pos].rs, mid + 1, r, w);
    return pos;
}

int qu(int l, int r, int L, int R, int ql, int qr) {
    if (l >= ql && r <= qr)return t[R].sum - t[L].sum;
    int mid = l + r >> 1;
    int res = 0;
    if (ql <= mid)res += qu(l, mid, t[L].ls, t[R].ls, ql, qr);
    if (qr > mid)res += qu(mid + 1, r, t[L].rs, t[R].rs, ql, qr);
    return res;
}

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n, m;
        cin >> n >> m;
        init();
        int x;
        for (int i = 1; i <= n; ++i) {
            scanf("%d", &x);
            root[i] = upd(root[i - 1], 1, 1000000, x);
        }
        int l, r, p, k, las = 0;
        for (int i = 1; i <= m; ++i) {
            scanf("%d%d%d%d", &l, &r, &p, &k);
            l ^= las, r ^= las, p ^= las, k ^= las;
            int L = 0, R = 1000000, ans = -1;
            while (L <= R) {
                int mid = L + R >> 1;
                int num = qu(1, 1000000, root[l - 1], root[r], p - mid, p + mid);
                if (num >= k) {
                    R = mid - 1;
                    ans = mid;
                } else L = mid + 1;
            }
            printf("%d\n", ans);
            las = ans;
        }
    }
}

1010 - Minimal Power of Prime

分析：因为只需要求指数的最小值，所以我们先把1000以内的质数都除掉，可以得到一个答案。

考虑最坏的情况，在不计算存在幂为1的质数的时候，剩下的数可能是

（1）由某个数的2次幂和另外一个数的3次幂构成，即1e15左右，可能存在

（2）由某个数的2次幂组成，1e6以上，可能存在

（3）由某个数的3次幂组成，1e9以上，可能存在

（4）由某个数的4次幂组成，1e12以上，可能存在

（5）由某个数的5次幂组成，1e15以上，可能存在

（6）由某个数的2次幂和另外一个数的2次幂构成

其余情况都不存在，于是我们预处理出情况，处理完1000以内的质数后直接查询就可以了。

两个不同数的二次幂直接开根判断一下就可以了。

如果以上都不存在的话就说明剩下的数是一个质数，或者存在一个质数的1次幂，更新答案就可以了。

#include "bits/stdc++.h"

using namespace std;
bool vis[1000004];
long long prim[1000004];
int cnt;
unordered_map<long long, bool> mp23, mp2, mp3, mp4, mp5;

void init() {
    memset(vis, 0, sizeof(vis));
    cnt = 0;
    for (int i = 2; i < 1000004; ++i) {
        if (!vis[i])prim[cnt++] = i;
        for (int j = 0; j < cnt && i * prim[j] < 1000004; ++j) {
            vis[i * prim[j]] = 1;
            if (i % prim[j] == 0)break;
        }
    }
    //这里简单算了下，大概跑1e7这个数量级的次数
    for (int i = 0; i < cnt; i++) {
        if (prim[i] < 1000)continue;
        if (prim[i] * prim[i] > 1e9)break;
        for (int j = 0; j < i; j++) {
            if (prim[j] < 1000)continue;
            if (prim[i] * prim[i] * prim[j] * prim[j] * prim[j] > 1e18)break;
            mp23[prim[i] * prim[i] * prim[j] * prim[j] * prim[j]] = 1;
        }
    }
    for (int i = 0; i < cnt; ++i) {
        long long t = prim[i];
        t = t * t;
        if (t > 1e18)break;
        mp2[t] = 1;
    }
    for (int i = 0; i < cnt; ++i) {
        long long t = prim[i];
        t = t * t * t;
        if (t > 1e18)break;
        mp3[t] = 1;
    }
    for (int i = 0; i < cnt; ++i) {
        long long t = prim[i];
        t = t * t * t * t;
        if (t > 1e18)break;
        mp4[t] = 1;
    }
    for (int i = 0; i < cnt; ++i) {
        long long t = prim[i];
        t = t * t * t * t * t;
        if (t > 1e18)break;
        mp5[t] = 1;
    }
}

int main() {
    int t;
    cin >> t;
    init();
    while (t--) {
        long long n;
        scanf("%lld", &n);
        int ans = 10000;
        for (int i = 0; i < cnt; ++i) {
            if (prim[i] > 1000)break;
            int sum = 0;
            while (n % prim[i] == 0) {
                sum++;
                n /= prim[i];
            }
            if (sum)ans = min(ans, sum);
        }
        if (mp2.count(n))ans = min(ans, 2);
        else if (mp3.count(n))ans = min(ans, 3);
        else if (mp4.count(n))ans = min(ans, 4);
        else if (mp5.count(n))ans = min(ans, 5);
        else if (mp23.count(n))ans = min(ans, 2);
        else if (n > 1) {
            long long t = sqrt(n);
            if (t * t == n)ans = min(2, ans);
            else ans = min(1, ans);
        }
        printf("%d\n", ans);
    }
}