2017年浙江中医药大学程序设计竞赛 Solution

训练地址

A：

树剖板子题

求最小值的时候要注意值是不是有负数，如果有，初值要置为$-INF$

#include <bits/stdc++.h>
using namespace std;
 
#define N 30010
#define INF 0x3f3f3f3f
int n, q, arr[N];
vector <int> G[N];
 
int fa[N], deep[N], sze[N], son[N], top[N], p[N], fp[N], cnt;
void DFS(int u)
{
    sze[u] = 1;
    for (auto v : G[u]) if (v != fa[u])
    {
        fa[v] = u;
        deep[v] = deep[u] + 1;
        DFS(v);
        sze[u] += sze[v];
        if (!son[u] || sze[v] > sze[son[u]]) son[u] = v;
    }
}
 
void getpos(int u, int sp)
{
    top[u] = sp;
    p[u] = ++cnt;
    fp[cnt] = u;
    if (!son[u]) return;
    getpos(son[u], sp);
    for (auto v : G[u]) if (v != fa[u] && v != son[u])
        getpos(v, v);
}
 
namespace SEG
{
    struct node
    {
        int Max, sum;
        node () {}
        node (int Max, int sum) : Max(Max), sum(sum) {}
        node operator + (const node &other) const { return node(max(Max, other.Max), sum + other.sum); }
    }a[N << 2], res;
    void build(int id, int l, int r)
    {
        if (l == r)
        {
            a[id] = node(arr[fp[l]], arr[fp[l]]);
            return;
        }
        int mid = (l + r) >> 1;
        build(id << 1, l, mid);
        build(id << 1 | 1, mid + 1, r);
        a[id] = a[id << 1] + a[id << 1 | 1];
    }
    void update(int id, int l, int r, int pos, int val)
    {
        if (l == r)
        {
            a[id] = node(val, val);
            return;
        }
        int mid = (l + r) >> 1;
        if (pos <= mid) update(id << 1, l, mid, pos, val);
        else update(id << 1 | 1, mid + 1, r, pos, val);
        a[id] = a[id << 1] + a[id << 1 | 1];
    }
    void query(int id, int l, int r, int ql, int qr)
    {
        if (l >= ql && r <= qr)
        {
            res = res + a[id];
            return;
        }
        int mid = (l + r) >> 1;
        if (ql <= mid) query(id << 1, l, mid, ql, qr);
        if (qr > mid) query(id << 1 | 1, mid + 1, r, ql, qr);
    }
}
 
void query(int u, int v)
{
    while (top[u] != top[v])
    {
        if (deep[top[u]] < deep[top[v]]) swap(u, v);
        SEG::query(1, 1, n, p[top[u]], p[u]);
        u = fa[top[u]];
    }
    if (deep[u] > deep[v]) swap(u, v);
    SEG::query(1, 1, n, p[u], p[v]);
}
 
int main()
{
    while (scanf("%d%d", &n, &q) != EOF)
    {
        cnt = 0;
        memset(son, 0, sizeof son);
        for (int i = 1; i <= n; ++i) scanf("%d", arr + i), G[i].clear();
        for (int i = 1, u, v; i < n; ++i)
        {
            scanf("%d%d", &u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        DFS(1); getpos(1, 1); SEG::build(1, 1, n);
        for (int i = 1, op, x, y; i <= q; ++i)
        {
            scanf("%d%d%d", &op, &x, &y);
            if (op == 2) SEG::update(1, 1, n, p[x], y);
            else
            {
                SEG::res = SEG::node(-INF, 0);
                query(x, y);
                printf("%d\n", op == 0 ? SEG::res.Max : SEG::res.sum);
            }  
        }
    }
    return 0;
}

 

B：

$b^2 = 2 \cdot a \cdot (a + 1) ^ 2$

$b = \sqrt{2 \cdot a} \cdot (a +1)$

所以a一定是个平方数的两倍

即$a = 2 \cdot i^2 $

枚举出答案，再二分查找

#include <bits/stdc++.h>
using namespace std;
 
#define ull unsigned long long
#define N 6000020
ull res[N];
 
int main()
{
    for (int i = 0; i < N; ++i)
        res[i] = (ull)2 * i * ((ull)2 * i * i + 1);
    //cout << res[N - 1] << endl;
    int t; cin >> t;
    while (t--)
    {
        ull n; scanf("%llu", &n);
        int pos = lower_bound(res, res + N, n) - res;
        printf("%llu\n", res[pos]); 
    }
    return 0;
}

 

C：

$倒着推过来$

$对于'u' 记录一下最近的位置$

$对于'm'，记录一下离他最近的'u'的位置$

$对于'c' ， 记录一下离(离他最近的'm'的)最近的'z'的位置$

$对于'z'，可以直接求答案$

#include <bits/stdc++.h>
using namespace std;
 
#define N 100010
#define INF 0x3f3f3f3f
char s[N];
int f[4];
 
int main()
{
    while (scanf("%s", s + 1) != EOF)
    {  
        memset(f, INF, sizeof f);
        for (int i = strlen(s + 1); i >= 1; --i)
        {
            if (s[i] == 'u') f[3] = i;
            else if (s[i] == 'm')
            {
                if (f[3] != INF)
                    f[2] = min(f[2], f[3] - 1);
            }
            else if (s[i] == 'c')
            {
                if (f[2] != INF)
                    f[1] = min(f[1], f[2] - 1);
            }
            else if (s[i] == 'z')
            {
                if (f[1] != INF)
                    f[0] = min(f[0], f[1] - i - 1);
            }
        }
        printf("%d\n", f[0] == INF ? -1 : f[0]);
    }
    return 0;
}

 

D：

贪心

考虑所有物品都要放进去

那么肯定先放$a_i <= b_i的物品，因为这些物品放进去背包会扩容$

那么放这些物品的时候按照$a_i从小到大的顺序排放$

$因为如果小的都放不下，那么大的肯定放不下，但是大的可以等小的放进去扩容之后可能就可以放下$

那么剩下的物品按照$(a_i - b_i)从小到大的顺序排放$

$因为我们要放一件物品要尽量使得背包缩小的体积较小，这样对后面物品的影响也较小$

#include <bits/stdc++.h>
using namespace std;
  
#define ll long long
#define N 100010
int t, n; ll v;
struct node
{
    int a, b;
    node () {}
    node (int a, int b) : a(a), b(b) {}
};
vector <node> p, q;
  
bool ok()
{
    for (auto it : p)
    {
        if (v < it.a) return false;
        v += it.b - it.a;
    }
    for (auto it : q)
    {
        if (v < it.a) return false;
        v += it.b - it.a;
    }
    return true;
}
  
int main()
{
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d%lld", &n, &v);
        p.clear(), q.clear();
        for (int i = 1, a, b; i <= n; ++i)
        {
            scanf("%d%d", &a, &b);
            if (a <= b) p.emplace_back(a, b);
            else q.emplace_back(a, b);
        }
        sort(p.begin(), p.end(), [](node x, node y) { return x.a < y.a; });
        sort(q.begin(), q.end(), [](node x, node y) { return x.a - x.b > y.a - y.b; });
        puts(ok() ? "yes" : "no");
    }
    return 0;
}

 

E：

签到。

#include <bits/stdc++.h>
using namespace std;
 
#define ll long long
int t;
ll n, k;
 
int main()
{
    scanf("%d", &t);
    while (t--)
    {
        scanf("%lld%lld", &n, &k);
        printf("%lld\n", k);
    }
    return 0;
}

 

F：

题意：

给出一个循环节，求这个循环节上的哪些位置，使得从这个位置出发

不论到达哪个位置，前缀1的个数都大于前缀0的个数

思路：

刚开始的想法是线段树的$O(nlogn)做法$

维护处前缀0的个数和前缀1的个数，然后枚举起始位置，两个起始位置之间$O(logn)转移，T了$

然后又考虑了单调队列的做法，$维护一个lazy， O(n)，过了$

最后看了看别人的代码，答案是$1的个数-0的个数，晕了$

感觉，首先复杂度没有算法，很明显的需要线性做法，却要硬刚带$log的$

再考虑一下，答案为什么是$1的个数-0的个数$

首先，所有0所处的位置都不可能作为起始位置

再考虑，有哪些1是不可以的

我们考虑连续的0，如果有一段连续的$x个0，那么这x个0往前数x个1，这x个1都是不可以的$

因为肯定至少存在一个位置不满足要求

$再考虑离散的0，那么离散的0直接理解为连续的1个0即可$

#include <bits/stdc++.h>
using namespace std;
 
#define N 200010
int t, n, a[N], sum[N], dq[N];
 
int main()
{
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n);
        for (int i = 1; i <= n; ++i)
        {
            scanf("%d", a + i);
            a[i + n] = a[i];
        }
        int l = 1, r = 0;
        for (int i = 1, tmp = 0; i <= n; ++i)
        {
            tmp += a[i];
            sum[i] = 2 * tmp - i;
            while (l <= r && sum[dq[r]] > sum[i]) --r;
            dq[++r] = i;   
        }
        int res = 0, lazy = 0;
        for (int i = 1; i <= n; ++i)
        {
            while (l <= r && dq[l] < i) ++l;
            if (sum[dq[l]] + lazy > 0) ++res;
            sum[i + n] = sum[i + n - 1] + 1 * (a[i + n] ? 1 : -1);
            while (l <= r && sum[dq[r]] > sum[i + n]) --r;
            lazy += 1 * (a[i] ? -1 : 1);
            dq[++r] = i + n;
        }
        printf("%d\n", res);
    }
    return 0;
}

 

G：

签到。

#include <bits/stdc++.h>
using namespace std;
 
int main()
{
    int t; cin >> t;
    while (t--)
    {
        long long n, m;
        scanf("%lld%lld", &n, &m);
        printf("%lld\n", m - n);
    }
    return 0;
}

 

H：

题意：

将一个n * n矩形分成两个相同的部分，求方案数

思路：

n 为奇数 答案为0

然后从中间开始搜，对称标记

#include <bits/stdc++.h>
using namespace std;
 
int t, ans[11], res, n;
int used[20][20];
int Move[][2] =
{
    0, -1,
    0,  1,
    1,  0,
   -1,  0,
};
 
void DFS(int x, int y)
{
    if (x == 0 || y == 0 || x == n || y == n)
    {
        ++res;
        return;
    }
    for (int i = 0; i < 4; ++i)
    {
        int nx = x + Move[i][0];
        int ny = y + Move[i][1];
        if (used[nx][ny] == 0)
        {
            used[nx][ny] = 1;
            used[n - nx][n - ny] = 1;
            DFS(nx, ny);
            used[nx][ny] = 0;
            used[n - nx][n - ny] = 0;
        }
    }
}
 
 
int main()
{
    for (int i = 1; i < 10; ++i)
    {
        if (i & 1) ans[i] = 0;
        else
        {
            memset(used, 0, sizeof used);
            res = 0; n = i;
            used[i / 2][i / 2] = 1;
            DFS(i / 2, i / 2);
            ans[i] = res / 4;
        }
    }
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n);
        printf("%d\n", ans[n]);
    }
    return 0;
}

 

I：

按题意模拟即可。

#include <bits/stdc++.h>
using namespace std;
 
#define N 10010
int t, n;
string str;
string var[N], save[N];
int Size[N], Len[N];
map <string, int> mp;
 
void getName(int i, int len)
{
    string name = "";
    for (; i < len; ++i)
    {
        if (str[i] == '[')
        {
            ++i;
            break;
        }
        name += str[i];
    }
    int big = 0;
    for (; i < len; ++i)
    {
        if (str[i] == ']') break;
        big = big * 10 + str[i] - '0';
    }
    ++n;
    mp[name] = n;
    var[n] = name;
    save[n] = "";
    Size[n] = big;
    Len[n] = 0;
}
 
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
    cin >> t; getline(cin, str);
    while (t--)
    {
        n = 0;
        mp.clear();
        while (1)
        {
            getline(cin, str);
            if (str == "return 0;") break;
            if (str[0] == 'c' && str[1] == 'h')
            {  
                for (int i = 0, len = str.size(); i < len; ++i) if (str[i] == ' ')
                    getName(i + 1, len);               
            }
            else if (str[0] == 'g')
            {
                string name = "";
                str += "\n";
                int i = 0, len = str.size();
                for (; i < len; ++i) if (str[i] == ' ') 
                {
                    ++i;
                    break;
                }
                for (; i < len; ++i)
                {
                    if (str[i] == ' ')
                    {
                        ++i;
                        break;
                    }
                    name += str[i];
                }          
                int id = mp[name];
                Len[id] = len - i; 
                string s = "";
                for (int j = 0; i < len && j < Size[id]; ++i, ++j)
                    s += str[i];
                save[id] = s;
            }
            else
            {
                string name = "";
                int i = 0, len = str.size();
                for (; i < len; ++i) if (str[i] == ' ')
                {
                    ++i;
                    break;
                }
                for (; i < len; ++i) name += str[i];
                int id = mp[name];
                string res = save[id];
                int remind = Len[id] - Size[id];
                for (int i = id + 1; remind > 0 && i <= n; ++i)
                {
                    res += save[i];
                    remind -= Size[i] - Len[i]; 
                }
                if (res.end()[-1] != '\n') res += "\n";
                cout << res;
            }
        }
    }
    return 0;
}

 

 

j：

考虑如果没有$gcd(x, y) != 1 的限制$

那么直接处理处b[a[i]]

再对于$a[b[i]] 直接求答案$

有这个限制我们可以考虑容斥，可以直接用莫比乌斯函数来容斥

#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define N 100010
int n;
int a[N], b[N];
bool check[N]; int mu[N], prime[N];
void Moblus()
{
    memset(check, false, sizeof check);
    mu[1] = 1;
    int tot = 0;
    for (int i = 2; i < N; ++i)
    {
        if (!check[i])
        {
            prime[++tot] = i;
            mu[i] = -1;
        }
        for (int j = 1; j <= tot; ++j)
        {
            if (i * prime[j] >= N) break;
            check[i * prime[j]] = true;
            if (i % prime[j] == 0)
            {
                mu[i * prime[j]] = 0;
                break;
            }
            else
            {
                mu[i * prime[j]] = -mu[i];
            }
        }
    }
}

ll vis[N];
ll f(int t)
{
    ll res = 0;
    for (int i = t; i <= n; i += t) ++vis[b[a[i]]];
    for (int i = t; i <= n; i += t) res += vis[a[b[i]]];
    for (int i = t; i <= n; i += t) --vis[b[a[i]]];
    return res;
}

int main()
{
    Moblus();
    while (scanf("%d", &n) != EOF)
    {
        memset(vis, 0, sizeof vis);
        for (int i = 1; i <= n; ++i) scanf("%d", a + i);
        for (int i = 1; i <= n; ++i) scanf("%d", b + i);
        ll res = 0;
        for (int i = 1; i <= n; ++i)
            res += mu[i] * f(i);
        printf("%lld\n", res);        
    }
    return 0;
}