Acwing第 2 场周赛【完结】

最新推荐文章于 2024-09-24 22:07:02 发布

辉小歌

最新推荐文章于 2024-09-24 22:07:02 发布

阅读量178

点赞数 1

分类专栏： # Acwing比赛文章标签：算法 c++ c

本文链接：https://blog.csdn.net/qq_46527915/article/details/117636319

版权

Acwing比赛专栏收录该内容

75 篇文章 10 订阅

订阅专栏

本文详细介绍了三道算法题目，包括简单的三元一次方程暴力求解，利用贪心策略求解最大差值问题，以及在最短路径树背景下寻找边的删减策略。代码实现涵盖Dijkstra算法和深度优先搜索，适合进阶算法学习者参考。

摘要由CSDN通过智能技术生成

做了两道，看了一下第三道题目直接撤了，不过第三道题目好像之前在哪见过。
好像是个原题，不过还是不会。

A: 3626. 三元一次方程【难度: 简单 / 知识点: 暴力】

在这里插入图片描述
题目地址
这道题居然花费了我十分钟左右，题目数据范围很小直接三重循环暴力就行。
刚开始想复杂了，花费了不少时间，当看到2分钟就有人AC的时候，我知道了这绝对是一个签到。
果断转换思维，打暴力。

#include<bits/stdc++.h>
using namespace std;
int main(void)
{
    int t; cin>>t;
    while(t--)
    {
        int n; cin>>n;
        bool flag=false;
        for(int i=0;i<=350;i++)
        {
            for(int j=0;j<=200;j++)
            {
                for(int z=0;z<=200;z++)
                {
                    if(i*3+j*5+z*7==n)
                    {
                        cout<<i<<" "<<j<<" "<<z<<endl;
                        flag=1;
                    }
                    if(flag) break;
                }
                if(flag) break;
            }
            if(flag) break;
        }
        if(!flag) cout<<-1<<endl;
    }
    return 0;
}

B: 3627. 最大差值【难度: 简单 / 知识点: 贪心】

在这里插入图片描述
题目地址

#include<bits/stdc++.h>
using namespace std;
typedef long long int LL;
const int N=1e5*2+10;
LL a[N];
int main(void)
{
    int t; cin>>t;
    while(t--)
    {
        int n,k; cin>>n>>k;
        LL sum=0;
        for(int i=1;i<=n;i++) cin>>a[i];
        sort(a+1,a+n+1);
        for(int i=n-k;i<=n;i++) sum+=a[i];
        cout<<sum<<endl;
    }
    return 0;
}

C: 3628. 边的删减【难度: 中等 / 知识点: 最短路径树】

在这里插入图片描述
题目地址

在讲解题目之前，需要直到的前置知识：

最短路径的概念：一个指定的顶点出发，计算从该顶点出发到其他所有顶点的最短路径。
最小生成树(Minimum Spanning Tree)简称MST：有n个点我们选n-1条边可以将所有的点联通，且其权值之和最小。
最短路径树(Shortest Path Tree)简称SPT：是一种使用最短路径算法生成的数据结构树。
- 所谓最短路径树，就是对于给定的源点，求出它到所有结点的最短路径，并且通过前驱来标记每个结点是从哪个结点过来的,如果有多条长度相等的最短路径时，取其中一条，这样整个图就变成了一棵以源点为根结点的树，这棵树就叫最短路径树。
- 需要注意的是，最短路径树是原图的一棵生成树，并且要求原图一定是一个连通图。

在这里插入图片描述

本题考察的知识点就是最短路经树，大致思路跑一遍的Dijkstra()求出来，各个点到1的最短距离。
遍历一下图，找到一个最多保留k条边的最短路树,那么我们的最优状态是k+1个点。
如果 dist[b]=dist[a]+w说明这是一条最短路上的边。
y总代码：

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>

#define x first
#define y second

using namespace std;

typedef long long LL;
typedef pair<LL, int> PII;

const int N = 100010, M = 200010;

int n, m, k;
int h[N], e[M], w[M], id[M], ne[M], idx;
LL dist[N];
bool st[N];
vector<int> ans;

void add(int a, int b, int c, int d)  // 添加一条边a->b，边权为c
{
    e[idx] = b, w[idx] = c, id[idx] = d, ne[idx] = h[a], h[a] = idx ++ ;
}

void dijkstra()  // 求1号点到n号点的最短路距离
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 1});

    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();

        int ver = t.second, distance = t.first;

        if (st[ver]) continue;
        st[ver] = true;

        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[ver] + w[i])
            {
                dist[j] = dist[ver] + w[i];
                heap.push({dist[j], j});
            }
        }
    }
}

void dfs(int u)
{
    st[u] = true;
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (!st[j] && dist[j] == dist[u] + w[i])//如果这是一条最短路径上的边
        {
            if (ans.size() < k) ans.push_back(id[i]);//加进来
            dfs(j);
        }
    }
}

int main()
{
    scanf("%d%d%d", &n, &m, &k);
    memset(h, -1, sizeof h);
    for (int i = 1; i <= m; i ++ )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c, i), add(b, a, c, i);
    }

    dijkstra();

    memset(st, 0, sizeof st);
    dfs(1);

    printf("%d\n", ans.size());
    for (auto x: ans) printf("%d ", x);
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
typedef long long int LL;
typedef pair<LL, int> PII;
const int N = 1e5+10,M=1e5*2+10;
int h[N], e[M], w[M], ne[M],id[M],idx;
LL dist[N];
bool st[N];
int n,m,k;
vector<int> ans;
void add(int a, int b, int c,int d)  // 添加一条边a->b，边权为c
{
    id[idx]=d,e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

void dijkstra()  // 求1号点到n号点的最短路距离
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 1});

    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();

        int ver = t.second, distance = t.first;

        if (st[ver]) continue;
        st[ver] = true;

        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[ver] + w[i])
            {
                dist[j] = dist[ver] + w[i];
                heap.push({dist[j], j});
            }
        }
    }
}
void dfs(int u)
{
    st[u]=1;
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(!st[j]&&dist[j]==dist[u]+w[i])
        {
            if(ans.size()<k) ans.push_back(id[i]);
            dfs(j);
        }
    }
}
int main(void)
{
    cin>>n>>m>>k;
    memset(h, -1, sizeof h);
    for(int i=1;i<=m;i++)
    {
        int a,b,c; cin>>a>>b>>c;
        add(a, b, c, i),add(b,a,c,i);
    }
    dijkstra();
    memset(st, 0, sizeof st);
    dfs(1);
    cout<<ans.size()<<endl;
    for(int i=0;i<ans.size();i++) cout<<ans[i]<<" ";
}