Educational Codeforces Round 54 (Rated for Div. 2) Solution

A - Minimizing the String

solved

题意：给出一个字符串，可以移掉最多一个字符，在所有可能性中选取一个字典序最小的。

思路：显然，一定可以移掉一个字符，如果移掉的字符的后一个字符大于当前字符，那么字典序会变大。

那只需要从左往右，遇到第一个后面的字符大于当前字符的就可以移掉该字符。

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

#define N 200010
int n;
char s[N];

int main()
{
    while (scanf("%d%s", &n, s + 1) != EOF)
    {
        int pos = n;
        for (int i = 1; i < n; ++i) if (s[i + 1] < s[i])
        {
            pos = i;
            break;  
        }
        s[pos] = 0;
        printf("%s", s + 1);
        printf("%s
", s + pos + 1);
    }
    return 0;
}

B - Divisor Subtraction

solved

题意：给出一个数n，如果n = 0,那么程序就结束。否则减去这个数的最小质因子，再循环执行该算法，问程序会执行多少步。

思路：

我们假设数$n的最小质因子为x, 令 y = frac{n}{x}$

如果$y$是偶数，那么答案就很明显，直接不断减去2

如果$y是奇数，那么我们先减去一个x， 那么就会变成 n = (y - 1) cdot x$

$此时 (y - 1) 显然为偶数 就不断减去2就可以$

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

#define ll long long
ll x;

ll find(ll x)
{
    ll limit = sqrt(x + 1); 
    for (ll i = 2; i <= limit; ++i) if (x % i == 0) return i; 
    return x;
}

int main()
{
    while (scanf("%lld", &x) != EOF)
    {
        ll y = find(x); ll z = x / y;
        printf("%lld
", (z - 1) * y / 2 + 1);    
    }
    return 0;
}

C - Meme Problem

solved

题意：给出一个$d, 找a + b = d and a cdot b = d$

思路：将$a = d - b$ 代入第二个式子，解二元一次方程。

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

int t, d;

int main()
{
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &d);
        if (d * d < 4 * d) puts("N");
        else
        {
            double delta = sqrt(d * d - 4 * d);
            double b = (d - delta) / 2;
            double a = d - b;
            printf("Y %.10f %.10f
", a, b);
        }
    }
    return 0;
}

D - Edge Deletion

Upsolved

题意：给出一个无向图，定义$d_i为 1 - i 的最短路径$，定义一个点为好点为1 - 这个点的最短路径为 $d_i$，最多保留k条边，使得剩下的点中好点最多。

思路：Dijkstra构造最短路树，对最短路树DFS或者BFS皆可，按这个搜索顺序选取边，显然每选取一条边都会增加一个好点，所以最后好点的数量显然为$min(k + 1, n)$

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

#define ll long long
#define INFLL 0x3f3f3f3f3f3f3f3f
#define N 300010
int n, m, k;

struct Edge
{
    int u, v; ll w; 
    Edge() {}
    Edge(int u, int v, ll w) : u(u), v(v), w(w) {}  
}edge[N]; 

struct graph
{
    struct node
    {
        int to, nx, id; ll w;
        node () {}
        node (int to, int nx, int id, ll w) : to(to), nx(nx), id(id), w(w) {}
    }a[N << 1];
    int head[N], pos;
    void init() { memset(head, 0, sizeof head); pos = 0; } 
    void add(int u, int v, int id, ll w)
    {
        a[++pos] = node(v, head[u], id, w); head[u] = pos;
        a[++pos] = node(u, head[v], id, w); head[v] = pos;
    }
}G, g;  
#define erp(G, u) for (int it = G.head[u], v = G.a[it].to, w = G.a[it].w; it; it = G.a[it].nx, v = G.a[it].to, w = G.a[it].w)

struct Dijkstra
{
    struct node
    {
        int to; ll w;
        node () {}
        node (int to, ll w) : to(to), w(w) {}
        bool operator < (const node &r) const { return w > r.w; } 
    };
    struct DIST 
    {
        ll w; int id;
        DIST() {}
        DIST(ll w, int id) : w(w), id(id) {}
    }dist[N]; bool used[N]; 
    void solve() 
    {
        for (int i = 1; i <= n; ++i)
        {
            dist[i] = DIST(INFLL, -1); 
            used[i] = false; 
        }
        dist[1] = DIST(0, -1); 
        priority_queue <node> q; q.emplace(1, 0);
        while (!q.empty())
        {
            int u = q.top().to; q.pop();
            if (used[u]) continue;
            used[u] = 1; 
            int id = dist[u].id; if (id != -1) g.add(edge[id].u, edge[id].v, id, edge[id].w); 
            erp(G, u) if (!used[v] && dist[v].w > dist[u].w + w) 
            {
                dist[v].w = dist[u].w + w; 
                dist[v].id = G.a[it].id;
                q.emplace(v, dist[v].w);
            }
        }
    }
}dij;

vector <int> res;
void DFS(int u, int fa)
{
    erp(g, u) if (v != fa && res.size() < k)
    {
        res.push_back(g.a[it].id); 
        DFS(v, u);
    }
}

int main()
{
    while (scanf("%d%d%d", &n, &m, &k) != EOF)
    {
        G.init(); g.init(); res.clear();
        for (int i = 1, u, v, w; i <= m; ++i)
        {
            scanf("%d%d%d", &u, &v, &w);
            edge[i] = Edge(u, v, w);
            G.add(u, v, i, w);
        } dij.solve(); DFS(1, 1); 
        int len = res.size(); 
        printf("%d
", len);
        for (int i = 0; i < len; ++i) printf("%d%c", res[i], " 
"[i == len - 1]);
    }
    return 0;
}

E - Vasya and a Tree

solved

题意：给出一棵树，有m次操作，每次将以x为根的子树下，和x的距离不超过d的所有点的权值都加上v,最后输出每个点的权值。

思路：首先考虑$d$特别大的情况下，也就是子树下所有点都要加上，那么更新的时候直接在那个点上更新，

最后只需要DFS一遍，每个点都加上父亲的权值即可。

再考虑加入限制的情况：

其实对于一个点，我们DFS下去的时候，到回溯上来这段时间，遍历的都是它的子树，那么我们可以设立一个标记

对于每个点，给他加上更新的权值的时候，我们在对应的子树的deep界限那里加上，那么每次遍历下去的时候，首先要减去这个当前深度对应的lazy值，然后再更新答案，回溯上来的时候取消标记即可。

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

#define ll long long
#define N 300010
#define pii pair <int, int>
int n, m;
vector <int> G[N]; 
vector <pii> vec[N];
ll ans[N], gap[N];

int deep[N], fa[N];
void DFS(int u, ll res)
{
    res -= gap[deep[u]];
    for (auto it : vec[u]) 
    {
        int dep = min(deep[u] + it.first + 1, n + 1);
        gap[dep] += it.second;  
        res += it.second;
    }
    ans[u] = res;
    for (auto v : G[u]) if (v != fa[u])
    {
        fa[v] = u;
        deep[v] = deep[u] + 1;
        DFS(v, res); 
    }
    for (auto it : vec[u])
    {
        int dep = min(deep[u] + it.first + 1, n + 1);
        gap[dep] -= it.second;
        res -= it.second;
    }
    res += gap[deep[u]];
}
    
void init()
{
    for (int i = 1; i <= n; ++i)
    {
        G[i].clear();
        vec[i].clear();
    }
    memset(gap, 0, sizeof gap);
    deep[1] = 0; 
}

int main()
{
    while (scanf("%d", &n) != EOF)
    {
        init(); 
        for (int i = 1, u, v; i < n; ++i)
        {
            scanf("%d%d", &u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        scanf("%d", &m);
        for (int i = 1, x, d, v; i <= m; ++i)
        {
            scanf("%d%d%d", &x, &d, &v);
            vec[x].emplace_back(min(d, n), v); 
        }
        DFS(1, 0);
        for (int i = 1; i <= n; ++i) printf("%lld%c", ans[i], " 
"[i == n]);
    }
    return 0; 
}

F. Summer Practice Report

 Upsolved.

题意：

$第i天有x_i个糖果，y_i个果冻，要求将他们放在一排，且相同的东西连续最多放k个，要放n天，求是否有放置方案满足$

思路：

$dp[i][1/0] 表示第i天最后一部分放糖果还是果冻的最小数量，然后枚举四种状态DP转移即可。$

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

#define ll long long
#define INF 0x3f3f3f3f
#define N 300010
int n, k, x[N], y[N], dp[N][2]; 

int calc(int pa, int pb, int a, int b)
{
    int ans = INF;
    if (pa <= k)
    {
        int tot = pa + a;
        int cnt = (tot + k - 1) / k - 1;
        if (b == cnt) ans = min(ans, tot - cnt * k);    
        else if (b > cnt && b <= (ll)a * k) ans = min(ans, 1);
    }
    if (pb <= k)
    {
        int cnt = (a + k - 1) / k - 1;
        if (b == cnt) ans = min(ans, a - cnt * k);
        else if (b > cnt && b <= (ll)a * k - pb) ans = min(ans, 1);
    }
    return ans;
}    

bool solve()
{
    memset(dp, 0x3f, sizeof dp); dp[0][0] = dp[0][1] = 0;
    for (int i = 1; i <= n; ++i)
    {
        dp[i][0] = calc(dp[i - 1][0], dp[i - 1][1], x[i], y[i]);
        dp[i][1] = calc(dp[i - 1][1], dp[i - 1][0], y[i], x[i]);
        if (dp[i][0] == INF && dp[i][1] == INF) return false;
    }
    return true;
}

int main()
{
    while (scanf("%d%d", &n, &k) != EOF)
    {
        for (int i = 1; i <= n; ++i) scanf("%d", x + i);
        for (int i = 1; i <= n; ++i) scanf("%d", y + i);
        puts(solve() ? "YES" : "NO");
    }
    return 0;
}

G. Array Game

Unsolved.