CCPC-Wannafly Winter Camp Day1 (Div2, onsite)

 

 

Replay

---

 

Dup4：

• 要是不挂机，再多仔细想想就好了
• J确实自闭好久，一直在想正确性，最后数据错了，喵喵喵？
• 还是要保证充足的休息啊，中间睡了一小会儿，也不知道睡了多久，醒来他们就又过了一道
• 要发掘题目更多的性质和有用条件啊，算法和数据结构只是工具，不要总想着这是啥题这是啥题，我会不会，其实我啥都不会

X:

• 日常挂机时间久，感觉是个不好的习惯。
• 太久没写了，已经不会算复杂度了， TLE MLE到自闭，转身写了个dp就过了？
• 感觉太容易根据数据想算法了， 自导自演。
• 自导自演，顺便演了16的C，演技拉满

 

 

 

 

 

 

 

 

 

---

 

A：机器人

Upsolved.

思路：

考虑两种情况

第一种是$b区没有站点需要经过，并且在a区只有一侧有站点需要经过的话$

我们不需要走一个圈，直接从$s走出去到一个特殊点走回s即可$

还有一种就是走一个矩形

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

#define ll long long
#define INF 0x3f3f3f3f
#define INFLL 0x3f3f3f3f3f3f3f3f
int n, r, m, k, s;
vector <int> v[2], p; 

int main()
{
    while (scanf("%d%d%d%d%d", &n, &r, &m, &k, &s) != EOF)
    {
        v[0].clear(); v[1].clear(); p.clear();
        for (int i = 1, x, y; i <= r; ++i)
        {
            scanf("%d%d", &x, &y);
            v[y].push_back(x);
        }
        sort(v[0].begin(), v[0].end());
        sort(v[1].begin(), v[1].end());  
        for (int i = 1, x; i <= m; ++i)
        {
            scanf("%d", &x);
            p.push_back(x);
        }    
        p.push_back(1); p.push_back(n); 
        sort(p.begin(), p.end());
        p.erase(unique(p.begin(), p.end()), p.end());  
        int Max = 0; 
        int Min = INF;  
        if (!v[0].empty()) 
        {
            Max = max(Max, *v[0].rbegin()); 
            Min = min(Min, *v[0].begin());
        }
        if (!v[1].empty())
        {
            Max = max(Max, *v[1].rbegin());
            Min = min(Min, *v[1].begin()); 
        }
        int pos_Max = lower_bound(p.begin(), p.end(), Max) - p.begin();
        int pos_Min = upper_bound(p.begin(), p.end(), Min) - p.begin() - 1; 
        pos_Max = p[pos_Max];
        pos_Min = p[pos_Min];  
        ll res = INFLL;
        // b区不需要经过站点
        if (v[1].empty())
        {
            if (Max <= s) pos_Max = s;  
            if (Min >= s) pos_Min = s;  
            ll tmp = 2ll * (pos_Max - pos_Min);
            res = min(res, tmp);
        }
        // 走矩形路线
        if (!v[1].empty())  
        {
            ll tmp = 2ll * (pos_Max - pos_Min);
            if (!v[1].empty()) tmp += 2ll * k; 
            if (s < pos_Min)  
                tmp += 2ll * (pos_Min - s);
            if (s > pos_Max)
                tmp += 2ll * (s - pos_Max);
            res = min(res, tmp); 
        }    
        printf("%lld\n", res);  
    }
    return 0;
}

 

B：吃豆豆

Solved.

思路：

$dp[i][j][k]表示在(i, j)位置， 时间为t获得最多的糖果。$

$那么， 很显然有转移方程$

$dp[i][j][k] -> dp[i +1][j][k + 1]$

$dp[i][j][k] -> dp[i - 1][j][k + 1]$

$dp[i][j][k] -> dp[i][j + 1][k + 1]$

$dp[i][j][k] -> dp[i][j - 1][k + 1]$

$dp[i][j][k] -> dp[i][j][k + 1]$

$当时间k\%T[i][j] == 0时， dp[i][j][k]++$

$一共有n*m*c种状态， 复杂度是O(n*m*c)$

$然后我也不知道我为啥写了个滚动数组$

#include<bits/stdc++.h>

using namespace std;

const int maxn = 10 + 10;

int n, m, C;
int sx, sy, ex, ey;
int T[maxn][maxn];
int arr[maxn][maxn];
int brr[maxn][maxn];

int main()
{
    while(~scanf("%d %d %d", &n, &m, &C))
    {
        for(int i = 1; i <= n; ++i)
        {
            for(int j = 1; j <= m; ++j)
            {
                scanf("%d", &T[i][j]);
            }
        }
        scanf("%d %d %d %d", &sx, &sy, &ex, &ey);
        memset(arr, -1, sizeof arr);
        arr[sx][sy] = 0;
        int step = 1;
        for(step = 1; ; step++)
        {
            for(int i = 1; i <= n; ++i)
            {
                for(int j = 1; j <= m; ++j)
                {
                    brr[i][j] = arr[i][j];
                }
            }
            for(int i = 1; i <= n; ++i)
            {
                for(int j = 1; j <= m; ++j)
                {
                    if(i - 1 >= 1) arr[i][j] = max(arr[i][j], brr[i - 1][j]);
                    if(i + 1 <= n) arr[i][j] = max(arr[i][j], brr[i + 1][j]);
                    if(j - 1 >= 1) arr[i][j] = max(arr[i][j], brr[i][j - 1]);
                    if(j + 1 <= m) arr[i][j] = max(arr[i][j], brr[i][j + 1]);
                    if(step % T[i][j] == 0)
                    {
                        if(arr[i][j] >= 0) arr[i][j]++;
                    }
                }
            }
            if(arr[ex][ey] >= C) break;
        }
        printf("%d\n", step);
    }
    return 0;
}

 

 

C：拆拆拆数

Solved.

思路：

对于两个奇数，因为2和任意奇数都是互质的。

所以可以拆成A（2,A-2）,B（B-2,2）

当有偶数的时候，假设A是偶数

对于大于4的偶数，一定可以拆成一个奇质数和一个奇数之和，相应的将另一个数拆成一个2对应之前的奇数，剩下的只要做到与奇质数互质即可。

因为3*5*7*11*13*17*19*23*29*31*37*41*43*47*53>1e9，所以B-2在53之前一定有一个奇质数不是B-2的因子。

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

ll GCD(ll a, ll b)
{
    return b == 0 ? a : GCD(b, a % b);
}

ll a, b;
ll prime[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53};//15


int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%lld %lld", &a, &b);
        if(GCD(a, b) == 1)
        {
            puts("1");
            printf("%lld %lld\n", a, b);
            continue;
        }
        if(a == b)
        {
            if(a & 1)
            {
                ll ans1 = a / 2;
                ll ans2 = a - a / 2;
                puts("2");
                printf("%lld %lld\n", ans1, ans2);
                printf("%lld %lld\n", ans2, ans1);
            }
            else 
            {
                ll ans1 = a / 2 - 1;
                ll ans2 = a - ans1;
                puts("2");
                printf("%lld %lld\n", ans1, ans2);
                printf("%lld %lld\n", ans2, ans1);
            }
            continue;
        }
        if(a % 2 == 1 && b % 2 == 1)
        {
            ll ans1 = 2, ans2 = a - 2;
            ll ans3 = b - 2, ans4 = 2;
            puts("2\n");
            printf("%lld %lld\n", ans1, ans3);
            printf("%lld %lld\n", ans2, ans4);
        }
        else
        {
            int isswap = 0;
            if(b % 2 == 0)
            {
                swap(a, b);
                isswap = 1;
            }
            int flag = 0;
            ll ans1, ans2, ans3, ans4;
            ans3 = b - 2;
            ans4 = 2;
            for(int i = 1; i <= 15 && prime[i] + 2 <= a; ++i)
            {
                if((b - 2) % prime[i] != 0)
                {
                    flag = 1;
                    ans1 = prime[i];
                    ans2 = a - prime[i];
                    break;
                }
            }
            if(flag)
            {
                if(isswap) 
                {
                    swap(ans1, ans3);
                    swap(ans2, ans4);
                }
                puts("2");
                printf("%lld %lld\n", ans1, ans3);
                printf("%lld %lld\n", ans2, ans4);
                continue;
            }
            ans3 = b - b % a - 1;
            ans4 = b - ans3;
            for(int i = 0; i <= 15 && prime[i] + 2<= a; ++i)
            {
                ans1 = prime[i];
                ans2 = a - prime[i];
                if(GCD(ans1, ans3) == 1 && GCD(ans2, ans4) == 1)
                {
                    flag = 1;
                    break;
                }
            }
            if(flag)
            {
                if(isswap)
                {
                    swap(ans1, ans3);
                    swap(ans2, ans4);
                }
                puts("2");
                printf("%lld %lld\n", ans1, ans3);
                printf("%lld %lld\n", ans2, ans4);
            }
            else
            {
                puts("-1");
            }
        }
    }
    return 0;
}

 

好像直接暴力就行了?

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

#define ll long long
int t; ll a, b;

ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
void solve()
{
    for (int i = 2; i <= min(a, 1ll * 100); ++i) for (int j = 2; j <= min(b, 1ll * 100); ++j) if (gcd(i, j) == 1 && gcd(a - i, b - j) == 1)
    {
        puts("2");
        printf("%d %d\n", i, j);
        printf("%lld %lld\n", a - i, b - j);
        return;
    }
}

int main()
{
    scanf("%d", &t);
    while (t--)
    {
        scanf("%lld%lld", &a, &b);
        if (gcd(a, b) == 1) 
        {
            puts("1");
            printf("%lld %lld\n", a, b);
        }
        else solve();
    }
    return 0;
}

 

 

E：流流流动

Upsolved.

这些边连起来会形成一棵树、简单树形dp即可

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

#define N 210
int n, f[N], d[N];
vector <int> G[N];

int pre[N];
int find(int x) { return pre[x] == 0 ? x : pre[x] = find(pre[x]); }
void join(int x, int y)
{
    int fx = find(x), fy = find(y);
    if (fx != fy)
        pre[fx] = fy;
}

int dp[N][2];
void DFS(int u, int fa)
{
    dp[u][0] = 0;
    dp[u][1] = f[u];
    for (auto v : G[u]) if (v != fa)
    {
        DFS(v, u);
        dp[u][0] += max(dp[v][0], dp[v][1]);
        dp[u][1] += max(dp[v][0], dp[v][1] - d[min(u, v)]);
    }
}

int main()
{
    while (scanf("%d", &n) != EOF)
    {
        for (int i = 0; i <= n; ++i) G[i].clear();
        memset(pre, 0, sizeof pre);
        memset(dp, 0, sizeof dp); 
        for (int i = 1; i <= n; ++i) scanf("%d", f + i);
        for (int i = 1; i <= n; ++i) scanf("%d", d + i); 
        for (int i = 2; i <= n; ++i)
        {
            if (i & 1)
            {
                if (3 * i + 1 <= n)
                {
                    G[3 * i + 1].push_back(i);
                    G[i].push_back(3 * i + 1);
                    join(3 * i + 1, i);            
                }
            }
            else
            {
                G[i].push_back(i / 2);
                G[i / 2].push_back(i); 
                join(i, i / 2);
            }
        }
        for (int i = 1; i <= n; ++i) if (!pre[i])
        {
            G[0].push_back(i); 
            G[i].push_back(0);
        }
        DFS(0, 0); 
        printf("%d\n", max(dp[0][0], dp[0][1]));
    }
    return 0;
}

 

 

F：爬爬爬山

Solved.

思路：

考虑海拔和体力的关系，即最高可以爬的山为$h[1] + k$

那么对于其他高度不符合的山，我们就需要降低其高度

可以理解为点有点权，边有边权，经过边和点都要加上其权值，求最短路

将一个点拆成两个点，中间连条有向边，权值为该点点权，再跑最短路即可

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

#define ll long long
#define N 200010
#define INFLL 0x3f3f3f3f3f3f3f3f
int n, m, k, h[N];
ll d;
struct Graph
{
    struct node
    {
        int to, nx; ll w;
        node () {}
        node (int to, int nx, ll w) : to(to), nx(nx), w(w) {}
    }a[N << 3];
    int head[N], pos;
    void init()
    {
        memset(head, 0, sizeof head);
        pos = 0;
    }
    void add(int u, int v, ll w)
    {
        a[++pos] = node(v, head[u], w); head[u] = pos;
    }
}G;
#define erp(u) for (int it = G.head[u], v = G.a[it].to; it; it = G.a[it].nx, v = G.a[it].to)

struct node
{
    int to; ll w;
    node () {}
    node (int to, ll w) : to(to), w(w) {}
    bool operator < (const node &other) const { return w > other.w; }
};
ll dist[N]; bool used[N];
void Dijkstra()
{
    for (int i = 1; i <= 2 * n + 1; ++i) dist[i] = INFLL, used[i] = false;
    dist[2] = 0; priority_queue <node> pq; pq.push(node(2, 0));
    while (!pq.empty())
    {
        int u = pq.top().to; pq.pop();
        if (used[u]) continue;
        used[u] = true;
        erp(u) 
        {
            ll w = G.a[it].w;
            if (!used[v] && dist[v] > dist[u] + w)
            {
                dist[v] = dist[u] + w;
                pq.push(node(v, dist[v]));
            }
        }
    }
}

int main()
{
    while (scanf("%d%d%d", &n, &m, &k) != EOF)
    {
        G.init();  
        for (int i = 1; i <= n; ++i) scanf("%d", h + i);
        d = h[1] + k;
        for (int i = 1, u, v, w; i <= m; ++i) 
        {
            scanf("%d%d%d", &u, &v, &w);
            G.add(2 * u + 1, 2 * v, w);
            G.add(2 * v + 1, 2 * u, w);
        }
        for (int i = 1; i <= n; ++i)
        {
            ll w = 0;
            if (h[i] > d) w = 1ll * (h[i] - d) * (h[i] - d);
            G.add(2 * i, 2 * i + 1, w);
        }
        Dijkstra();
        printf("%lld\n", dist[2 * n + 1]);
    }
    return 0;
}

 

 

I：起起落落

Upsolved.

思路：

$f[i] 表示以i结尾的方案数$ 

$f[i] = \sum\limits_{j = 1}^{i - 1} [p[j] > p[i]] \cdot f[j] \cdot \sum\limits_{k = j + 1}^{i - 1} [p[k] < p[i]]$

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

#define ll long long
#define N 2010
const ll MOD = (ll)1e9 + 7;
int n, p[N];
ll f[N];

int main()
{
    while (scanf("%d", &n) != EOF)
    {
        for (int i = 1; i <= n; ++i) scanf("%d", p + i); 
        memset(f, 0, sizeof f);
        for (int i = 3; i <= n; ++i)
        {
            int cnt = p[i - 1] < p[i]; 
            for (int j = i - 2; j >= 1; --j)   
            {
                if (p[j] > p[i]) 
                    f[i] = (f[i] + (f[j] + 1) * cnt % MOD) % MOD;
                else
                    ++cnt; 
            }
        }
        ll res = 0;
        for (int i = 3; i <= n; ++i) res = (res + f[i]) % MOD; 
        printf("%lld\n", res);
    }
    return 0;
}

 

Div1：

用权值线段树来维护这个式子

 

我们考虑$f[x]的方案只会对 y > x \;并且\; p[y] < p[x] 的y产生贡献$

产生贡献的次数是$z \in [x + 1, y - 1] 中 p[z] < p[x] 的个数$

我们对于$z \in [x + 1, y - 1] 中，不管p[z] 与 p[x] 的大小关系$

全都把次数算上

再考虑删除多算的贡献

对于$z \in [x + 1, y - 1] 它多产生的贡献是 x \in [1, z] \;并且\; p[x] > p[z] 的 f[x] 之和$

$那就是权值线段树上的 区间更新 单点更新 区间查询的操作$

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

#define ll long long
#define N 100010
const ll MOD = (ll)1e9 + 7;
int n, p[N];

void up(ll &x) { if (x >= MOD) x -= MOD; }
namespace SEG
{
    struct node
    {
        ll base, v, lazy;
        node () {}
        node (ll base, ll v, ll lazy) : base(base), v(v), lazy(lazy) {}
        void init() { base = v = lazy = 0; }
        node operator + (const node &other) const
        {
            node res; res.init();
            res.base = (base + other.base) % MOD;
            res.v = (v + other.v) % MOD; 
            return res;
        }    
    }a[N << 2], res;
    void init() { memset(a, 0, sizeof a); }
    void pushdown(int id)
    {
        if (!a[id].lazy) return;
        up(a[id << 1].lazy += a[id].lazy);
        up(a[id << 1 | 1].lazy += a[id].lazy);
        a[id << 1].v = (a[id << 1].v + a[id].lazy * a[id << 1].base % MOD) % MOD;
          a[id << 1 | 1].v = (a[id << 1 | 1].v + a[id].lazy * a[id << 1 | 1].base % MOD) % MOD;
        a[id].lazy = 0;    
    }
    void update(int id, int l, int r, int ql, int qr, ll v)
    {
        if (l >= ql && r <= qr)
        {
            up(a[id].lazy += v);
            a[id].v = (a[id].v + a[id].base * v % MOD) % MOD;
            return;
        }
        int mid = (l + r) >> 1;
        pushdown(id);
        if (ql <= mid) update(id << 1, l, mid, ql, qr, v);
        if (qr > mid) update(id << 1 | 1, mid + 1, r, ql, qr, v);
        a[id] = a[id << 1] + a[id << 1 | 1];
    }
    void update2(int id, int l, int r, int pos, ll base, ll v)
    {
        if (l == r)
        {
            up(a[id].base += base);
            up(a[id].v += v);
            return;
        }
        int mid = (l + r) >> 1;
        pushdown(id);
        if (pos <= mid) update2(id << 1, l, mid, pos, base, v);
        else update2(id << 1 | 1, mid + 1, r, pos, base, v);
        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;
        pushdown(id); 
        if (ql <= mid) query(id << 1, l, mid, ql, qr);
        if (qr > mid) query(id << 1 | 1, mid + 1, r, ql, qr);
    }
}

int main()
{
    while (scanf("%d", &n) != EOF)
    {
        for (int i = 1; i <= n; ++i) scanf("%d", p + i);
        SEG::init();
        ll res = 0;
        for (int i = 1; i <= n; ++i)
        {
            SEG::res.init();
            SEG::query(1, 1, n, p[i] + 1, n); 
            up(res += SEG::res.v);
            SEG::update(1, 1, n, p[i] + 1, n, 1); 
            SEG::update2(1, 1, n, p[i], SEG::res.v + 1, (-SEG::res.base + MOD) % MOD); 
        }
        printf("%lld\n", res);   
    }
    return 0;
}

 

 

 

J：夺宝奇兵

Solved.

思路：

考虑居民拥有的最大宝物数为$m$

可以枚举这个值，贪心$check()$即可

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

#define ll long long
#define N 1010
int n, m;
vector <int> v[N];

ll check(int x)
{
    ll res = 0;
    int cnt = 0;
    priority_queue <int, vector <int>, greater <int> > q;
    for (int i = 1; i <= n; ++i)
    {
        int need = v[i].size() - x;
        for (auto it : v[i])
        {
            if (need > 0)
            {
                --need;
                res += it;
                ++cnt;
            }
            else 
                q.push(it);
        }
    }
    while (cnt <= x)  
    {
        ++cnt;
        res += q.top(); q.pop();    
    }
    return res;
}

int main()
{
    while (scanf("%d%d", &n, &m) != EOF)
    {
        for (int i = 1; i <= n; ++i) v[i].clear();
        for (int i = 1, a, c; i <= m; ++i) 
        {
            scanf("%d%d", &a, &c);
            v[c].push_back(a);
        }
        for (int i = 1; i <= n; ++i) sort(v[i].begin(), v[i].end());
        ll res = (ll)1e18; 
        for (int i = 0; i < m; ++i) 
            res = min(res, check(i));
        printf("%lld\n", res);
    }
    return 0;
}

 

Div1：

从大到小枚举$x$, 发现在大的$x的情况下会买掉的，在小的x下一定会买掉$

$每件物品最多操作一次，再用线段树维护前k小之和即可$

复杂度$O(nlogn)$

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

#define ll long long
#define N 100010
#define pii pair <int, int>
int n, m;
struct node
{
    int a, c;
    void scan() { scanf("%d%d", &a, &c); }
    bool operator < (const node &other) const { return a < other.a; }
}arr[N];
queue <pii> q[N];
vector <int> vec[N];

namespace SEG
{
    ll v[N << 2]; int cnt[N << 2];
    void pushup(int id) { v[id] = v[id << 1] + v[id << 1 | 1]; cnt[id] = cnt[id << 1] + cnt[id << 1 | 1]; }
    void build(int id, int l, int r)
    {
        v[id] = 0; cnt[id] = 0;
        if (l == r)
        {
            v[id] = arr[l].a;
            cnt[id] = 1;
            return;
        }
        int mid = (l + r) >> 1;
        build(id << 1, l, mid);
        build(id << 1 | 1, mid + 1, r);
        pushup(id);
    }
    void update(int id, int l, int r, int pos)
    {
        if (l == r)
        {
            v[id] = 0;
            cnt[id] = 0;
            return;
        }
        int mid = (l + r) >> 1;
        if (pos <= mid) update(id << 1, l, mid, pos);
        else update(id << 1 | 1, mid + 1, r, pos);
        pushup(id);
    }
    ll query(int id, int l, int r, int k)
    {
        if (k <= 0) return 0;
        if (k == cnt[id]) return v[id];
        int mid = (l + r) >> 1;
        ll res = 0;
        res += query(id << 1, l, mid, min(k, cnt[id << 1]));
        if (k - cnt[id << 1] > 0) res += query(id << 1 | 1, mid + 1, r, k - cnt[id << 1]);
        return res;
    }
}

ll tmp;
int cnt;
void work(int x)
{
    if (x - 1) for (auto it : vec[x]) vec[x - 1].push_back(it);
    for (auto it : vec[x]) 
    {
        pii top = q[it].front(); q[it].pop();
        ++cnt;
        tmp += top.first;
        SEG::update(1, 1, m, top.second);    
    }
}

int main()
{
    while (scanf("%d%d", &n, &m) != EOF)
    {
        for (int i = 1; i <= m; ++i) arr[i].scan();
        sort(arr + 1, arr + 1 + m);
        for (int i = 1; i <= m; ++i) q[arr[i].c].push(pii(arr[i].a, i)); 
        SEG::build(1, 1, m);
        for (int i = 1; i <= n; ++i) vec[q[i].size()].push_back(i);
        ll res = (ll)1e18; tmp = 0; cnt = 0;
        if (!vec[m].empty())
        {
            ++cnt;
            int it = *vec[m].begin();
            pii top = q[it].front(); q[it].pop();
            vec[m - 1].push_back(it); 
            tmp += top.first;
            SEG::update(1, 1, m, top.second); 
        }
        for (int i = m - 1; i >= 0; --i)
        {
            work(i);
            res = min(res, tmp + SEG::query(1, 1, m, i - cnt));
        }    
        printf("%lld\n", res);
    }    
    return 0;
}