EOJ Monthly 2018.2

A. 坑爹的售票机

题意

用\(1,5,10,25,50,100\)的纸币买\(n\)张单价为\(p\)的船票，且一次性最多买\(k\)张，求钱数恰好时最少需要多少张纸币。

Hard: \(n,k,p\leq 10^9\)

思路

Easy: dp

Hard: dp + 瞎搞

当钱数过大或者张数过多时，（由直觉）其中的大部分都是遵循一定的规律来取的，只有剩余的一小部分需要dp.

Code

Easy

#include <bits/stdc++.h>
#define F(i, a, b) for (int i = (a); i < (b); ++i)
#define F2(i, a, b) for (int i = (a); i <= (b); ++i)
#define dF(i, a, b) for (int i = (a); i > (b); --i)
#define dF2(i, a, b) for (int i = (a); i >= (b); --i)
#define maxn 10010
using namespace std;
typedef long long LL;
int a[6] = {1,5,10,20,50,100}, dp[maxn], dp2[maxn];
int main() {
    int n, k, p;
    scanf("%d%d%d", &n, &k, &p);
    int lim = k*p;
    F2(i, 1, lim) {
        int minn = INT_MAX;
        F(j, 0, 6) {
            if (i-a[j]<0) break;
            minn = min(minn, dp[i-a[j]]);
        }
        dp[i] = minn+1;
    }
    F2(i, 1, n) {
        int minn = INT_MAX;
        F2(j, 1, k) {
            if (i-j<0) break;
            minn = min(minn, dp2[i-j]+dp[j*p]);
        }
        dp2[i] = minn;
    }
    printf("%d\n", dp2[n]);
    return 0;
}

Hard

#include <bits/stdc++.h>
#define inf 0x3f3f3f3f3f3f3f3f
#define F(i, a, b) for (int i = (a); i < (b); ++i)
#define F2(i, a, b) for (int i = (a); i <= (b); ++i)
#define dF(i, a, b) for (int i = (a); i > (b); --i)
#define dF2(i, a, b) for (int i = (a); i >= (b); --i)
using namespace std;
typedef long long LL;
int a[6] = {1,5,10,20,50,100}, dp[1010];
LL dp2[1010], val[20];
int main() {
    LL n, p; int k;
    scanf("%lld%d%lld", &n, &k, &p);
    F(i, 1, 1000) {
        int minn = INT_MAX;
        F(j, 0, 6) {
            if (i-a[j]<0) break;
            minn = min(minn, dp[i-a[j]]);
        }
        dp[i] = minn+1;
    }
    F2(i, 1, k) {
        LL x = i * p;
        val[i] = x/1000*10 + dp[x%1000];
    }
    LL ans = inf;
    F2(i, 1, 1000) {
        LL minn = inf;
        F2(j, 1, k) {
            if (i-j<0) break;
            minn = min(minn, dp2[i-j]+val[j]);
        }
        dp2[i] = minn;
        ans = min(ans, n/i*dp2[i]+dp2[n%i]);
    }
    printf("%lld\n", ans);
    return 0;
}

B. 无聊的游戏

题意

给定一棵树，两人轮流从树中选取一个度数不为 0 的结点 (度数为 0 则不与任何边相连) 将其与其相连的边删去，谁最终无法删去结点，则谁败。问是否先手必胜？

思路

状压dp.

对删去的点进行状压，记录是必胜态还是必败态，记忆化搜索进行转移。

后继全部是必胜态的状态为必败态，后继中有一个是必败态的状态为必胜态。

Code

#include <bits/stdc++.h>
#define F(i, a, b) for (int i = (a); i < (b); ++i)
#define F2(i, a, b) for (int i = (a); i <= (b); ++i)
#define dF(i, a, b) for (int i = (a); i > (b); --i)
#define dF2(i, a, b) for (int i = (a); i >= (b); --i)
#define maxn 1100000
using namespace std;
typedef long long LL;
int n, dp[maxn], mp[22][22];
bool vis[maxn];
bool dfs(int state) {
    if (vis[state]) return dp[state];
    vis[state] = true;
    F(i, 0, n) {
        if (!(state&(1<<i))) {
            F(j, 0, n) {
                if (!(state&(1<<j)) && mp[i][j]) {
                    bool ret = dfs(state|(1<<i));
                    if (!ret) return dp[state] = 1;
                }
            }
        }
    }
    return 0;
}
int main() {
    scanf("%d", &n);
    F(i, 1, n) {
        int u, v;
        scanf("%d%d", &u, &v); --u, --v;
        mp[u][v] = mp[v][u] = true;
    }
    if (dfs(0)) puts("First");
    else puts("Second");
    return 0;
}

C. 贪吃的 xjj 和贪心的 oxx

题意

求 \(S=\{a_1,a_2,\ldots,a_n\}\) 这一多重集的一个非空子集 \(S'=\{a_{i_1}, a_{i_2}, \ldots, a_{i_k} \}\)，使得

\[\left(Sum(S') \le Sum(S-S') \right) \land \left(\forall t \in S-S', Sum(S') \ge Sum(S-S') - t\right)
\]

记多重集 \(Sum(A)\) 表示多重集 \(A\) 所有元素的和。特别地，\(Sum(\varnothing)=0\)。

题解

无论什么情况答案都为 Yes，方法为将原序列从大到小排序，贪心地放两堆，每次往少的一堆里放新的一盒，最终取少的一堆即可。

正确性显见：对于多的一堆，取走其中数量最少的一盒（即刚刚放入的一盒），则其总数必然少于少的一堆，否则这一盒不会被放入。

Code

#include <bits/stdc++.h>
#define F(i, a, b) for (int i = (a); i < (b); ++i)
#define F2(i, a, b) for (int i = (a); i <= (b); ++i)
#define dF(i, a, b) for (int i = (a); i > (b); --i)
#define dF2(i, a, b) for (int i = (a); i >= (b); --i)
#define maxn 1000010
using namespace std;
typedef long long LL;
int a[maxn], id[maxn];
bool cmp(int x, int y) { return a[x]>a[y]; }
int main() {
    int n;
    LL x=0, y=0;
    vector<int> v1,v2;
    scanf("%d", &n);
    F(i, 0, n) scanf("%d", &a[i]), id[i] = i;
    sort(id, id+n, cmp);
    F(i, 0, n) {
        if (x<=y) {
            v1.push_back(id[i]+1);
            x += a[id[i]];
        }
        else {
            v2.push_back(id[i]+1);
            y += a[id[i]];
        }
    }
    puts("Yes");
    if (x <= y) {
        printf("%d\n", v1.size());
        sort(v1.begin(), v1.end());
        for (auto x : v1) printf("%d ", x); puts("");
    }
    else {
        printf("%d\n", v2.size());
        sort(v2.begin(), v2.end());
        for (auto x : v2) printf("%d ", x); puts("");
    }
    return 0;
}

D. 黑心的出租车

题意

给定一个森林，从\(1\)号点出发，遍历森林中所有的点最后回到\(1\)号点。

大巴可以在有边相连的两点间往返，而出租车可以在任意两点间往返。

要求：乘出租车次数最少的情况下，乘大巴次数也最少，求两个次数。

思路

如果只有一棵树，显然，次数为\(0,2(n-1)\)

如果有多棵树，那么：

1. 出租车次数即联通块个数；
2. 每棵树内的遍历可以到叶子就结束（换乘出租车到另一棵树），而不用回到最初的点。也即可以省略一段回头路。要大把次数最少，则要省略的路径最长，即要找一条最长的路，一端作为根，一端作为叶子。显然，这一条最长的路即为 直径。

Code

#include <bits/stdc++.h>
#define F(i, a, b) for (int i = (a); i < (b); ++i)
#define F2(i, a, b) for (int i = (a); i <= (b); ++i)
#define dF(i, a, b) for (int i = (a); i > (b); --i)
#define dF2(i, a, b) for (int i = (a); i >= (b); --i)
#define maxn 100010
using namespace std;
typedef long long LL;
struct Edge { int to, ne; }edge[maxn<<1];
int ne[maxn], dep1[maxn], dep2[maxn], fa[maxn], tot, vis[maxn], sz[maxn];
vector<int> v[maxn];
void add(int u, int v) {
    edge[tot] = {v, ne[u]};
    ne[u] = tot++;
}
void dfs(int u, int fa, int d, int* dep) {
    dep[u] = d;
    for (int i = ne[u]; ~i; i = edge[i].ne) {
        int v = edge[i].to;
        if (v == fa) continue;
        dfs(v, u, d+1, dep);
    }
}
inline int find(int x) { return fa[x]==x ? x : fa[x]=find(fa[x]); }
inline void unionn(int u, int v) {
    u = find(u), v = find(v);
    if (sz[u] < sz[v]) swap(u, v);
    fa[v] = u, sz[u] += sz[v];
}
int main() {
    int n, k;
    scanf("%d%d", &n, &k);
    memset(ne, -1, sizeof ne);
    F2(i, 1, n) fa[i] = i, sz[i] = 1;
    F(i, 0, k) {
        int u, v;
        scanf("%d%d", &u, &v);
        add(u, v); add(v, u);
        unionn(u, v);
    }
    int cnt=0;
    F2(i, 1, n) {
        if (!vis[find(i)]) {
            vis[find(i)] = ++cnt;
        }
        v[vis[find(i)]].push_back(i);
    }
    if (cnt==1) printf("%d %d\n", 0, k<<1);
    else {
        int ans = 0;
        F2(i, 1, cnt) {
            int u = v[i][0];
            dfs(u, -1, 0, dep1);
            for (auto x : v[i]) if (dep1[x]>dep1[u]) u = x;
            dfs(u, -1, 0, dep2);
            for (auto x : v[i]) if (dep2[x]>dep2[u]) u = x;
            ans += (v[i].size()-1)*2-dep2[u];
        }
        printf("%d %d\n", cnt, ans);
    }
    return 0;
}

E. 出老千的 xjj

题目描述

玩了一天的 oxx 和 xjj 精力不减，晚上回到宾馆后决定玩一种卡牌游戏。

游戏规则很简单：一开始，每人手中有若干不同的牌。在每一回合中，两人轮流先手，先手可以打出 x 张任意相同的牌，随后两人轮流出牌，每次打出 x 张任意相同的牌，直至双方都不出牌，该回合结束（一方不出牌时另一方可以继续出牌直至不出牌）。下一回合中换为另一人先手，直至某一回合中一人打完手上所有牌。先打完所有牌的获胜。

xjj 出了把老千，使得自己拿到了 k 张相同的牌，她骄傲地向 oxx 炫耀：“我这牌稳赢了，让你先手。看看你那寒酸样，再给你额外几张万能牌，可以代替任何一张牌。”

机智的 oxx 立刻发现了自己胜利的希望，他想知道他至少拿到几张万能牌就可以赢得游戏。oxx 在第一回合中是先手。

题解

当牌总数小于等于 \(k\) 时，只需一张一张出即可，因此答案为 \(0\)。

当牌总数大于 \(k\) 时，需要每次出 \(x\) 张，且 \(x\) 不整除 \(k\)，即加上万能牌后所有牌数量的\(gcd\) 要不为 \(k\) 的约数。

对于每次枚举的 \(p\)，通过前缀和可以求出数量在 \((pi,p(i+1)]\) 之间堆数的个数 \(num\) 以及总数量和 \(sum\)，那么需要 \(num\cdot p(i+1)-sum\) 张万能牌，最后求和即可。总复杂度 \(O(nlogn)\)。前缀和数组注意开到 \(2\cdot 10^6\)。

还可以进行进一步优化：只需要枚举所有素数即可，对于 \(k\) 的素因子 \(p\)，则取 \(p^i\)，最小的 \(i\) 使得 \(p^i\) 不能整除 \(k\)。

Code

#include <bits/stdc++.h>
#define F(i, a, b) for (int i = (a); i < (b); ++i)
#define F2(i, a, b) for (int i = (a); i <= (b); ++i)
#define dF(i, a, b) for (int i = (a); i > (b); --i)
#define dF2(i, a, b) for (int i = (a); i >= (b); --i)
#define maxn 3000000
#define inf 0x3f3f3f3f3f3f3f3f
typedef long long LL;
int cnt[maxn+10], maxx, prime[maxn], tot;
LL sum[maxn+10];
bool check[maxn+10];
using namespace std;
void init() {
    F2(i, 2, maxx) {
        if (!check[i]) prime[tot++] = i;
        F(j, 0, tot) {
            if (i*prime[j]>maxx) break;
            check[i*prime[j]] = true;
            if (i%prime[j]==0) break;
        }
    }
}
LL update(LL p, LL k) {
    LL ret = p*p;
    while (!(k%ret)) ret *= p;
    return ret;
}
int main() {
    int n, k;
    scanf("%d%d", &n, &k);
    F(i, 0, n) {
        int x;
        scanf("%d", &x);
        ++cnt[x];
        sum[x] += x;
        maxx = max(maxx, x);
    }
    F2(i, 1, maxn) cnt[i] += cnt[i-1], sum[i] += sum[i-1];
    if (sum[maxn] <= k) { puts("0"); return 0; }
    init();
    LL ans = inf;
    F(i, 0, tot) {
        LL p = prime[i];
        if (!(k%p)) p = update(p, k);
        LL temp = 0;
        int lim = (maxx+p-1) / p;
        if (lim==1) temp = 1LL * n * p - sum[maxx];
        else {
            F(j, 0, lim) {
                temp += 1LL * (cnt[p*(j+1)]-cnt[p*j]) * p*(j+1) - (sum[p*(j+1)]-sum[p*j]);
            }
        }
        ans = min(ans, temp);
    }
    printf("%lld\n", ans);
    return 0;
}

F. 回家咯

思路

列方程解方程

Code

#include <bits/stdc++.h>
#define F(i, a, b) for (int i = (a); i < (b); ++i)
#define F2(i, a, b) for (int i = (a); i <= (b); ++i)
#define dF(i, a, b) for (int i = (a); i > (b); --i)
#define dF2(i, a, b) for (int i = (a); i >= (b); --i)
using namespace std;
typedef long long LL;
int main() {
    int x1,x2,x3;
    scanf("%d%d%d", &x1, &x2, &x3);
    double c3=1.0*(x3-x1)/2,
        c1 = x2-c3,
        c2 = x1-c1;
    if (c2<=0 || c1<=0 || c3<=0) puts("Wrong");
    else printf("%.2f\n", c1);
    return 0;
}