Codeforces Round #374 (Div. 2) A,B,C,D

最新推荐文章于 2025-08-01 11:12:48 发布

原创最新推荐文章于 2025-08-01 11:12:48 发布 · 435 阅读

0 ·

CC 4.0 BY-SA版权

ACM/ICPC_Codeforences 专栏收录该内容

204 篇文章

订阅专栏

本文介绍了一道关于有向图的最短路径问题，采用DAG上的动态规划求解，并分享了一个关于数组操作的贪心算法题目及其实现方案。

【A】水题，统计一下连续的‘B’有多少个连续部分，输出即可。

【B】水题，排序后模拟一下即可。

【C. Journey】

【题意】给定了一个有向图，问从1从1到n在满足权值之和不超过T的条件下，最多经过多少个点。

【解题方法】赛场上直接莽了个最长路，综测挂掉了，简直不要太蠢。其实这就是一个DAG上的DP,我们用DP[i][j]表示经过i点目的地为j的最少时间，那么对于v点来说，转移很简单就是dp[i][v] = min(dp[i-1][u] + E[v][u].w)。然后在转移的时候记录下路径就行了。

【时间复杂度】O(n*m)

【代码君】

//
//Created by just_sort 2016/10/1 9:00
//Copyright (c) 2016 just_sort.All Rights Reserved
//

#include <set>
#include <map>
#include <queue>
#include <stack>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 5001;
int dp[maxn][maxn],pre[maxn][maxn];
stack<int>ans;
struct node{
    int u,v,w;
}E[maxn];

int main()
{
    int n,m,T;
    scanf("%d%d%d",&n,&m,&T);
    for(int i = 0; i < m; i++){
        scanf("%d%d%d",&E[i].u,&E[i].v,&E[i].w);
    }
    memset(dp,0x3f,sizeof(dp));
    memset(pre,-1,sizeof(pre));
    dp[1][1] = 0;
    int pos;
    for(int i = 2; i <= n; i++){
        for(int j = 0; j < m; j++){
            int u = E[j].u;
            int v = E[j].v;
            int w = E[j].w;
            if(dp[i-1][u] + w < dp[i][v]){
                dp[i][v] = dp[i-1][u] + w;
                pre[i][v] = u;
            }
        }
        if(dp[i][n] <= T){
            pos = i;
        }
    }
    cout<<pos<<endl;
    int u = n;
    while(u != -1){
        ans.push(u);
        u = pre[pos--][u];
    }
    while(!ans.empty())
    {
        printf("%d ",ans.top());
        ans.pop();
    }
}

【D. Maxim and Array】

【题意】n个数做k次+/-x,使得他们的乘积最小。

【解题方法】贪心。显然，如果负数的个数为奇数，我们只需要使得所有的符号不改变的情况下，绝对值尽可能的大，这里绝对值从小到大排序。如果负数的个数不是偶数，我们先使一个绝对值最小的数变号之后，再做上面的操作就好了

【时间复杂度】O(K*log(n))

【代码君】

//
//Created by just_sort 2016/10/1 14:00
//Copyright (c) 2016 just_sort.All Rights Reserved
//

#include <set>
#include <map>
#include <queue>
#include <stack>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 200001;
int n,K,X;
long long a[maxn];
struct node{
    long long x;
    int sg;
    int id;
    bool operator<(const node &rhs) const{
        if(abs(x) != abs(rhs.x)) return abs(x) < abs(rhs.x);
        return id < rhs.id;
    }
};
set<node>s;

int main()
{
    cin>>n>>K>>X;
    int oddcnt = 0;
    for(int i = 1; i <= n; i++){
        int x;
        scanf("%d",&x);
        int sg = (x >= 0 ? 1 : -1);
        if(x < 0) ++oddcnt;
        s.insert({1LL*x,sg,i});
    }
    if(oddcnt%2 == 0){
        while(K){
            --K;
            long long x = s.begin()->x;
            int sg = s.begin()->sg;
            int id = s.begin()->id;
            s.erase(s.begin());
            if((x - X*sg) * sg <= 0){
                s.insert({x - X*sg,-sg,id});
                break;
            }
            else{
                s.insert({x - X*sg,sg,id});
            }
        }
    }
    while(K){
        --K;
        long long x = s.begin()->x;
        int sg = s.begin()->sg;
        int id = s.begin()->id;
        s.erase(s.begin());
        s.insert({x + X*sg,sg,id});
    }
    for(auto it : s) a[it.id] = it.x;
    for(int i = 1; i <= n; i++) printf("%lld ",a[i]);
}