Codeforces Round #287 (Div. 2)【贪心、几何、二叉树性质、数位DP、最短路】

原创 于 2019-12-23 23:41:40 发布 · 211 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Codeforces

本文深入解析了五道ACM竞赛题目，涵盖了贪心算法、数位DP、最短路径等核心算法，提供了完整的代码实现与思路分析。

题目链接

A. Amr and Music

  简单贪心，直接sort一下，先从小的开始选就可以了。

  然后直接存答案输出。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#define _ABS(x, y) ( x > y ? (x - y) : (y - x) )
#define lowbit(x) ( x&( -x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f3f3f3f3f
#define efs 1e-7
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
int N, K;
struct node
{
    int val, id;
    node(int a=0, int v=0):val(a), id(v) {}
    friend bool operator < (node e1, node e2) { return e1.val < e2.val; }
} a[105];
int main()
{
    scanf("%d%d", &N, &K);
    for(int i=1; i<=N; i++) scanf("%d", &a[i].val);
    for(int i=1; i<=N; i++) a[i].id = i;
    sort(a + 1, a + N + 1);
    int ans[105], tot = 0;
    for(int i=1; i<=N; i++)
    {
        if(a[i].val > K) break;
        K -= a[i].val;
        ans[++tot] = a[i].id;
    }
    printf("%d\n", tot);
    for(int i=1; i<=tot; i++) printf("%d%c", ans[i], i == tot ? '\n' : ' ');
    return 0;
}

 

B. Amr and Pins

  感觉考了个高中的圆，绕圆上一点旋转的问题，那么不就是最长的移动中心的距离就是直径长度，然后向上取整即可。不知道为什么正赛的时候那么多人FST。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#define _ABS(x, y) ( x > y ? (x - y) : (y - x) )
#define lowbit(x) ( x&( -x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f3f3f3f3f
#define efs 1e-7
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
double r, x_1, y_1, x_2, y_2;
int main()
{
    scanf("%lf%lf%lf%lf%lf", &r, &x_1, &y_1, &x_2, &y_2);
    double tmp = sqrt( (x_1 - x_2) * (x_1 - x_2) + (y_1 - y_2) * (y_1 - y_2) );
    double d = 2. * r;
    printf("%d\n", (int)((tmp + d - efs) / d));
    return 0;
}

 

C. Guess Your Way Out!

  是一个很好的对二叉树的认知，我们可以看成一个线段，被分成这么长[1, 2^{h}]，然后，我们可以想象成线段树，左右左右的走的话，我们可以去考虑上一步走的是哪一步，初始化我们定义上一步走的是右边。然后如果不同的话，我们就会加上它的另一个方向上的子节点的个数了。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#define _ABS(x, y) ( x > y ? (x - y) : (y - x) )
#define lowbit(x) ( x&( -x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f3f3f3f3f
#define efs 1e-7
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
ll H, N, inv2[55];
int main()
{
    inv2[0] = 1;
    for(int i=1; i<=50; i++) inv2[i] = inv2[i - 1] * 2LL;
    scanf("%lld%lld", &H, &N);
    ll depth = H, ans = 0, las_move = 1;
    ll L = 1LL, R = inv2[H], mid;
    while(L < R)
    {
        mid = (L + R) >> 1LL;
        if(N <= mid)
        {
            if(las_move)
            {
                ans += 0;
            }
            else
            {
                ans += inv2[depth] - 1LL;
            }
            R = mid;
            las_move = 0;
        }
        else
        {
            if(las_move)
            {
                ans += inv2[depth] - 1LL;
            }
            else
            {
                ans += 0;
            }
            L = mid + 1;
            las_move = 1;
        }
        depth--;
    }
    ans += H;
    printf("%lld\n", ans);
    return 0;
}

 

D. The Maths Lecture

  数位DP好题！

  这道题感觉比E难了好多，可能是我不擅长写数位DP的缘故吧。

  题目问的就是后缀是满足K的倍数的N长度的数有多少个，不能有前导零，并且后缀y不能为0，然后的话，我们这里要保证后缀不能是0的情况，我们需要开一个多维数组，记录后缀0和非后缀0的情况，因为是截然不同的。

  然后的话，判断的时候，如果已经确定是合法的，后面直接记录个数即可了，这样的做法是为了避免答案冲突。

样例：

2 7 1000000007
ans:21

My Code：

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#define _ABS(x, y) ( x > y ? (x - y) : (y - x) )
#define lowbit(x) ( x&( -x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define efs 1e-7
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
int N, K;
ll mod, dp[1007][105][2], inv[1007];   //后缀要求大于0
ll dfs(int pos, int K_mod, bool zero)
{
    if(pos == N)
    {
        if(!K_mod) return 1;
        else return 0;
    }
    if(dp[pos][K_mod][zero] ^ -1) return dp[pos][K_mod][zero];
    ll ans = 0;
    int nex_mod = K_mod;
    if(pos ^ (N - 1)) ans = dfs(pos + 1, nex_mod, zero) % mod;
    for(int i=1; i<=9; i++)
    {
        nex_mod = (i * inv[pos] + K_mod) % K;
        if(!K_mod && pos && !zero) nex_mod = 0; //现在已经是合法的了，再往后不管什么都是可行的了
        ans = (ans + dfs(pos + 1, nex_mod, false)) % mod;
    }
    return dp[pos][K_mod][zero] = ans;
}
inline void solve()
{
    memset(dp, -1, sizeof(dp));
    inv[0] = 1;
    for(int i=1; i<=N; i++) inv[i] = inv[i - 1] * 10 % K;
    ll ans = dfs(0, 0, true);
    printf("%lld\n", ans);
}
int main()
{
    scanf("%d%d%lld", &N, &K, &mod);
    solve();
    return 0;
}

 

E. Breaking Good

  最短路。

  一道最短路裸题了吧，但是最短路的条件变成了两个，首先第一关键字肯定是路径最短，第二关键字是在路径同时满足最短的时候，要求需要维修的路径最少不就是可以了嘛，直接跑堆优化的Dijkstra即可。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#define _ABS(x, y) ( x > y ? (x - y) : (y - x) )
#define lowbit(x) ( x&( -x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define efs 1e-7
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 1e5 + 7;
int N, M, head[maxN], cnt;
struct Eddge
{
    int nex, to, bad;
    Eddge(int a=-1, int b=0, int c=0):nex(a), to(b), bad(c) {}
}edge[maxN << 1];
inline void addEddge(int u, int v, int w)
{
    edge[cnt] = Eddge(head[u], v, w);
    head[u] = cnt++;
}
inline void _add(int u, int v, int w) { addEddge(u, v, w); addEddge(v, u, w); }
pair<int, int> dis[maxN];
bool operator < (pair<int, int> e1, pair<int, int> e2) { return e1.first == e2.first ? e1.second < e2.second : e1.first < e2.first; }
struct node
{
    int id; pair<int, int> val;
    node(int a=0, pair<int, int> b = MP(0, 0)):id(a), val(b) {}
    friend bool operator < (node e1, node e2) { return e1.val.first == e2.val.first ? e1.val.second > e2.val.second : e1.val.first > e2.val.first; }
};
priority_queue<node> Q;
int pre_P[maxN], pre_E[maxN];
bool vis_line[maxN << 1] = {false};
inline void Dijkstra()
{
    for(int i=1; i<=N; i++) dis[i] = MP(INF, INF);
    Q.push(node(1, MP(0, 0)));
    dis[1] = MP(0, 0);
    node now;
    while(!Q.empty())
    {
        now = Q.top(); Q.pop();
        int u = now.id;
        if(dis[u] < now.val) continue;
        for(int i=head[u], v; ~i; i=edge[i].nex)
        {
            v = edge[i].to;
            if(dis[v].first > dis[u].first + 1)
            {
                dis[v].first = dis[u].first + 1;
                dis[v].second = dis[u].second + edge[i].bad;
                Q.push(node(v, dis[v]));
                pre_P[v] = u;
                pre_E[v] = i;
            }
            else if(dis[v].first == dis[u].first + 1 && dis[v].second > dis[u].second + edge[i].bad)
            {
                dis[v].second = dis[u].second + edge[i].bad;
                Q.push(node(v, dis[v]));
                pre_P[v] = u;
                pre_E[v] = i;
            }
        }
    }
}
struct Out_ans
{
    int u, v, w;
    Out_ans(int a=0, int b=0, int c=0):u(a), v(b), w(c) {}
};
vector<Out_ans> ans;
inline void init()
{
    cnt = 0;
    for(int i=1; i<=N; i++) head[i] = -1;
}
int main()
{
    scanf("%d%d", &N, &M);
    init();
    for(int i=1, u, v, w; i<=M; i++)
    {
        scanf("%d%d%d", &u, &v, &w);
        _add(u, v, 1 ^ w);
    }
    Dijkstra();
    int now = N;
    while(now ^ 1)
    {
        if(edge[pre_E[now]].bad) ans.push_back(Out_ans(pre_P[now], now, 1));
        vis_line[pre_E[now]] = vis_line[pre_E[now] ^ 1] = true;
        now = pre_P[now];
    }
    for(int u=1; u<=N; u++)
    {
        for(int i=head[u], v; ~i; i=edge[i].nex)
        {
            if(vis_line[i] || edge[i].bad == 1) continue;
            vis_line[i ^ 1] = true;
            v = edge[i].to;
            ans.push_back(Out_ans(u, v, 0));
        }
    }
    int len = (int)ans.size();
    printf("%d\n", len);
    for(int i=0; i<len; i++) printf("%d %d %d\n", ans[i].u, ans[i].v, ans[i].w);
    return 0;
}

 

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wuliwuliii

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值