Codeforces Round 1046 (Div. 2)题解

A. In the Dream

我们只要去算上半场得分和下半场与上半场差值得分,然后分别对这两个种情况的大得分对小得分去进行除法,如果结果大于2,那么就说明出现了一个队伍连拿三分的情况,然后输出NO,如果都没有就输出YES

#include<bits/stdc++.h>
using namespace std;
#define int long long
int t;
double a, b, c, d;
void solve()
{
    cin >> a >> b >> c >> d;
    double flag1 = 0;
    double flag2 = 0;
    if (max(a, b) /(min(a,b) +1)> 2)
    {
        cout << "NO\n";
        return;
    }
    flag1 = c-a;
    flag2 = d-b;
    if(max(flag1,flag2)/(min(flag1,flag2)+1)>2)
    {
        cout << "NO\n";
        return;
    }
    cout << "YES\n";
}
signed main()
{
    cin >> t;
    while(t--)
    {
        solve();
    }
    return 0;
}

B. Like the Bitset

我们只要让s[i]=1的位置尽可能的小就能让其区间尽可能的不是最大值,我们可以从1到n先给s[i]=1的赋值,然后再去赋值0的,什么时候会出现-1的情况呢?那肯定事有连续个s[i]=1的次数>=k在一起的情况

#include<bits/stdc++.h>
using namespace std;
#define int long long
int t;
int n, k;
string s;
int a[2000005];
void solve()
{
    cin >> n >> k;
    cin >> s;
    int len = 0;
    for (int i = 0; i < s.size();i++)
    {
        if(s[i]=='1')
        {
            len++;
        }
        else
        {
            len = 0;
        }
        if(len==k)
        {
            cout << "NO\n";
            return;
        }
    }
    int num = 1;
    for (int i = 0; i <s.size();i++)
    {
        if(s[i]=='1')
        {
            a[i] = num++;
        }
    }
    for (int i = 0; i < s.size(); i++)
    {
        if (s[i] == '0')
        {
            a[i] = num++;
        }
    }
    cout << "YES\n";
    for (int i = 0; i < s.size();i++)
    {
        cout << a[i] << " ";
    }
    cout << "\n";
}
signed main()
{
    cin >> t;
    while(t--)
    {
        solve();
    }
}

C. Against the Difference

我们对于这题,我们可以用一个pos数组来统计每个数出现了多少次,然后用一个o数组来确定i位置的数,对于a[i]是第几次出现过的,那我们对于状态转移方程就有了

dp[i]=dp[i-1]
如果我们的o[i]>=a[i]的话,那我我们可以考虑一下更新dp[i]的值

dp[i]=max(dp[i].dp[pos[a[i]][o[i]-a[i]-1]+a[i])

#include<bits/stdc++.h>
using namespace std;
#define int long long
int t;
int n, k;
string s;
int a[2000005];
void solve()
{
    cin >> n >> k;
    cin >> s;
    int len = 0;
    for (int i = 0; i < s.size();i++)
    {
        if(s[i]=='1')
        {
            len++;
        }
        else
        {
            len = 0;
        }
        if(len==k)
        {
            cout << "NO\n";
            return;
        }
    }
    int num = 1;
    for (int i = 0; i <s.size();i++)
    {
        if(s[i]=='1')
        {
            a[i] = num++;
        }
    }
    for (int i = 0; i < s.size(); i++)
    {
        if (s[i] == '0')
        {
            a[i] = num++;
        }
    }
    cout << "YES\n";
    for (int i = 0; i < s.size();i++)
    {
        cout << a[i] << " ";
    }
    cout << "\n";
}
signed main()
{
    cin >> t;
    while(t--)
    {
        solve();
    }
}

### 关于Codeforces Round 704 Div. 2 的信息 对于Codeforces Round 704 Div. 2的比赛,虽然未直接提及具体题目解析或参赛体验的内容,但是可以根据平台的一贯风格推测该轮比赛同样包含了多种算法挑战。通常这类赛事会涉及数据结构、动态规划、图论等方面的知识。 考虑到提供的参考资料并未覆盖到此特定编号的比赛详情[^1],建议访问Codeforces官方网站查询官方题解或是浏览社区论坛获取其他选手分享的经验总结。一般而言,在赛后不久就会有详细的解答发布出来供学习交流之用。 为了帮助理解同类型的竞赛内容,这里提供了一个基于过往相似赛事的例子——如何通过居中子数组特性来解决问题的方法: ```cpp // 假设有一个函数用于处理给定条件下的数组恢复问题 vector<int> restoreArray(vector<vector<int>>& adjacentPairs) { unordered_map<int, vector<int>> adj; for (auto& p : adjacentPairs){ adj[p[0]].push_back(p[1]); adj[p[1]].push_back(p[0]); } int start = 0; for(auto& [num, neighbors] : adj){ if(neighbors.size() == 1){ start = num; break; } } vector<int> res(adjacentPairs.size() + 1); unordered_set<int> seen; function<void(int,int)> dfs = [&](int node, int idx){ seen.insert(node); res[idx] = node; for(auto next : adj[node]){ if(!seen.count(next)){ dfs(next, idx + 1); } } }; dfs(start, 0); return res; } ``` 上述代码展示了利用深度优先搜索(DFS)重建原始序列的一种方式,这与某些情况下解决Codeforces比赛中遇到的问题思路相吻合[^4]。 #### 注意事项 由于缺乏针对Codeforces Round 704 Div. 2的具体材料支持,以上解释更多依赖于对同类活动的理解以及编程技巧的应用实例来进行说明。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值