CodeCraft-21 and Codeforces Round 711 (Div. 2)A-F

最新推荐文章于 2024-07-19 19:11:19 发布
最新推荐文章于 2024-07-19 19:11:19 发布
阅读量90 收藏
点赞数
分类专栏： Codeforces 思维题 动态规划 文章标签： 算法 数据结构 动态规划
kkk
本文链接：https://blog.csdn.net/scanner___yw/article/details/133493512
版权

1.Problem - A - Codeforces

        （1）题意 

                求一个大于等于n的整数x，满足gcd(x,sum(dig(x)) > 1，dig表示x的各个数位。

        （2）思路

                考虑最差是满足gcd(x,sum(dig(x)) = 2,因此不会枚举很多，直接暴力枚举即可。

        （3）代码

#include <bits/stdc++.h>
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 2e5 + 10;
bool check(ll x)
{
    ll s = 0,rx = x;
    while(rx) {
        s += rx % 10;
        rx /= 10;
    }
    return __gcd(x,s) >= 2;
}
void solve()
{
    ll n;
    cin >> n;
    while(n) {
        if(check(n)) break;
        n ++;
    }
    cout << n << '\n';
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T = 1;
    cin >> T;
    while(T --) solve();
    return 0;
}

2.Problem - B - Codeforces

        （1）题意

                给你n个高为1，宽为w[i]的矩形，你有一个大矩型已经确定了宽为W，你需要确定最小的h满足能放入所有的高为1的矩形。

        （2）思路

                考虑h一定满足单调性，所以直接二分h的值即可。

        （3）代码

#include <bits/stdc++.h>
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 2e5 + 10;
int a[N],n,w;
bool check(int x)
{
    multiset<int> st;
    rep(i,1,x) st.insert(w);
    per(i,n,1) {
        auto it = st.lower_bound(a[i]);
        if(it == st.end()) return false;
        int res = *it - a[i];
        st.erase(it);
        st.insert(res);
    }
    return true;
}
void solve()
{
    cin >> n >> w;
    rep(i,1,n) cin >> a[i];
    sort(a + 1,a + 1 + n);
    int l = 1,r = n;
    while(l <= r) {
        int m = (l + r) >> 1;
        if(check(m)) r = m - 1;
        else l = m + 1;
    }
    cout << l << '\n';
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T = 1;
    cin >> T;
    while(T --) solve();
    return 0;
}

3.Problem - C - Codeforces

        （1）题意

                给你一条长为k的射线，有n面镜子，每次你穿过一面镜子有两种选择，一种是降低你目前的等级，然后新生成一条反方向为目前等级-1的射线，一种是直接穿过镜子，问最多会有多少条射线。

        （2）思路

                发现这是个计数题，因此直接考虑dp，dp[i][j]表示当前射线为i有j面镜子的方案数是多少。

                转移方程：

                        1.若前一条是通过降级来的，则应该是dp[i - 1][n - j]这个位置来的。

                        2.若前一条是通过直接穿的，则应该是dp[i][j - 1]这个位置来的。

        （3）代码

#include <bits/stdc++.h>
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 2e5 + 10;
using i64 = long long;

constexpr int P = 1e9 + 7;
// assume -P <= x < 2P
int Vnorm(int x) {
    if (x < 0) {
        x += P;
    }
    if (x >= P) {
        x -= P;
    }
    return x;
}
template<class T>
T power(T a, i64 b) {
    T res = 1;
    for (; b; b /= 2, a *= a) {
        if (b % 2) {
            res *= a;
        }
    }
    return res;
}
struct Mint {
    int x;
    Mint(int x = 0) : x(Vnorm(x)) {}
    Mint(i64 x) : x(Vnorm(x % P)) {}
    int val() const {
        return x;
    }
    Mint operator-() const {
        return Mint(Vnorm(P - x));
    }
    Mint inv() const {
        assert(x != 0);
        return power(*this, P - 2);
    }
    Mint &operator*=(const Mint &rhs) {
        x = i64(x) * rhs.x % P;
        return *this;
    }
    Mint &operator+=(const Mint &rhs) {
        x = Vnorm(x + rhs.x);
        return *this;
    }
    Mint &operator-=(const Mint &rhs) {
        x = Vnorm(x - rhs.x);
        return *this;
    }
    Mint &operator/=(const Mint &rhs) {
        return *this *= rhs.inv();
    }
    friend Mint operator*(const Mint &lhs, const Mint &rhs) {
        Mint res = lhs;
        res *= rhs;
        return res;
    }
    friend Mint operator+(const Mint &lhs, const Mint &rhs) {
        Mint res = lhs;
        res += rhs;
        return res;
    }
    friend Mint operator-(const Mint &lhs, const Mint &rhs) {
        Mint res = lhs;
        res -= rhs;
        return res;
    }
    friend Mint operator/(const Mint &lhs, const Mint &rhs) {
        Mint res = lhs;
        res /= rhs;
        return res;
    }
    friend std::istream &operator>>(std::istream &is, Mint &a) {
        i64 v;
        is >> v;
        a = Mint(v);
        return is;
    }
    friend std::ostream &operator<<(std::ostream &os, const Mint &a) {
        return os << a.val();
    }
};

void solve()
{
    int n,k;
    cin >> n >> k;
    vector<vector<Mint>> dp(k + 1,vector<Mint>(n + 1));
    rep(i,1,k) dp[i][0] = 1;
    rep(i,1,k) {
        rep(j,1,n) {
            dp[i][j] += dp[i - 1][n - j] + dp[i][j - 1];
        }
    }
    cout << dp[k][n] << '\n';
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T = 1;
    cin >> T;
    while(T --) solve();
    return 0;
}

4.Problem - D - Codeforces

        （1）题意

                你有n个活动事件，m个位置，初始在0这个位置，每一次活动给出Ti,Xi,Yi表示这个活动的类型是Ti，每一次步长为Xi'(Xi = Xi'/100000)，可以执行[0,Yi]次这个步长，若Ti为1或2，若Ti为1，则表示这一次会变成pos = (pos + Xi),若Ti为2，则表示这一次会变成pos = (pos * Xi), 问你最早到达[1,m]每一个位置是第几个活动事件。

        （2）思路

                直接暴力即可，记Ans[i]表示到第i个位置的最早时间，若这个位置被走过了则时间可以不执行了，若当前位置已经跳出m了，则也不执行了。

        （3）代码

#include <bits/stdc++.h>
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 2e5 + 10;
int Ans[N];
const int inf = 0x3f3f3f3f;
void solve()
{
    int n,m;
    cin >> n >> m;
    rep(i,1,m) Ans[i] = inf;
    rep(i,1,n) {
        ll t,x,y;
        cin >> t >> x >> y;
        per(j,m,0) {
            if(Ans[j] == inf) continue;
            ll p = j;
            rep(k,1,y) {
                if(t == 1) p = p + (99999 + x) / 100000;
                else p = (p * x + 99999) / 100000;
                if(p > m) break;
                if(Ans[p] < inf) break;
                Ans[p] = i;
            }
        }
    }
    rep(i,1,m) {
        if(Ans[i] == inf) cout << -1 << ' ';
        else cout << Ans[i] << ' ';
    }
}   
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T = 1;
    // cin >> T;
    while(T --) solve();
    return 0;
}

5.Problem - E - Codeforces

        （1）题意        （2）思路

                考虑这个图是一个竞赛图，我们可以直接用竞赛图解，对于一个竞赛图若按照点的出度进行排序，缩点后前面的点必定向后面所有点右边，若某一个位置前面的点的出度和为i * (i - 1) / 2,说明前面必定出现了SCC，如果前面j个点也出现了这个情况，说明要么前i个点存在两个SCC，要么后面这个不存在SCC，证明可得后面这个也一定是SCC。那么我们只需要挑一个最大的SCC的|Ka-Kb|即可。

        （3）代码

#include <bits/stdc++.h>
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 2e5 + 10;
PII e[N];
void solve()
{
    int n;
    cin >> n;
    rep(i,1,n) {
        cin >> e[i].fi;
        e[i].se = i;
    }
    stable_sort(e + 1,e + 1 + n);
    int v = 0,mx = -1,lst = 0;
    PII Ans = {0,0};
    rep(i,1,n) {
        v += e[i].fi;
        if(v == i * (i - 1) / 2) {
            if(lst != i - 1) {
                int rs = e[i].fi - e[lst + 1].fi;
                if(rs > mx) {
                    Ans = {e[lst + 1].se,e[i].se};
                    mx = rs;
                }
            }
            lst = i;
        }
    }
    cout << "! " << Ans.fi << ' ' << Ans.se << endl;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T = 1;
    // cin >> T;
    while(T --) solve();
    return 0;
}

6.Problem - F - Codeforces

        （1）题意

                Alice和Bob在一颗树上玩游戏，第i个节点有a[i]个石头，每轮可以选择一个距离根深度至少为k的点往上移动任意石头，问对每个节点作为根最后谁会赢。

        （2）思路

                对于k为1，无非就是一个树上阶梯尼姆博弈

                对于k为d，我们猜测会是一个dep/d的树上阶梯尼姆博弈

                因此我们考虑dp[i][j][k]表示在第i个点，距离i为j的，奇偶性为k的贡献是多少。

                1.对于j < k的奇偶性不会发生变化

                        dp[x][i][j] ^= dp[y][i - 1][j]

                2.对于j == k的会发生变化因此特殊转移就行。

                        dp[x][0][j] ^= dp[y][k - 1][j ^ 1]

                剩下的其他根换根dp一下就可以

       （3）代码

#include <bits/stdc++.h>
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 1e5 + 10;
vector<int> e[N];
int dp[N][21][2],Ans[N],a[N];
int n,k;
inline void do_dp(int x,int y)
{
    rep(i,1,k - 1) {
        rep(j,0,1) {
            dp[x][i][j] ^= dp[y][i - 1][j];
        }
    }
    dp[x][0][0] ^= dp[y][k - 1][1];
    dp[x][0][1] ^= dp[y][k - 1][0];
}
inline void dfs(int u,int f)
{
    dp[u][0][0] = a[u];
    for(auto v : e[u]) {
        if(v == f) continue;
        dfs(v,u);
        do_dp(u,v);
    }
}
inline void dfs2(int u,int f)
{
    if(f) {
        do_dp(f,u);
        do_dp(u,f);
    }
    rep(i,0,k - 1) Ans[u] ^= dp[u][i][1];
    for(auto v : e[u]) {
        if(v == f) continue;
        dfs2(v,u);
    }
    if(f) {
        do_dp(u,f);
        do_dp(f,u);
    }
}
void solve()
{
    cin >> n >> k;
    rep(i,2,n) {
        int u,v;
        cin >> u >> v;
        e[u].pb(v),e[v].pb(u);
    }
    rep(i,1,n) cin >> a[i];
    dfs(1,0);
    dfs2(1,0);
    rep(i,1,n) {
        if(Ans[i]) cout << 1 << ' ';
        else cout << 0 << ' ';
    }
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T = 1;
    // cin >> T;
    while(T --) solve();
    return 0;
}

                

A real Warrior
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Educational Codeforces Round 83 (Rated for Div. 2) D
01-20
C(n-2,i-1)*C(j-1,n-2)*(i-1) __ j: n-1 -> m 我们发现内层循环，每次只是j加一，我们就可以只用一次组合数剩下的用差量表示 对于外层循环同理 只有(i-1) * C(n-2,i-1) i会每次加一。我们也只算一次剩下的用差量...
CodeForces-Div.2A
04-28
Codeforces部门2，A # And a2oj Ladder 4 some problems Ladder URL:http://a2oj.com/Ladder.jsp?ID=4难度等级：2问题提示： 1- 4A. Watermelon: http://codeforces.com/problemset/problem/4/A 2- 71A. Way Too ...
CodeCraft-21 and Codeforces Round #711 (Div. 2)ABC题解
weixin_46001550的博客
03-30 256
A题，至少能找到个gcd=2gcd=2gcd=2的，只要222个都是偶数就行 #include<bits/stdc++.h> using namespace std; typedef long long ll; const int N=1e5+10; int t; ll n; int main() { scanf("%d",&t); while(t--) { scanf("%lld",&n); while(1) { ll x=n,res=0; whi
CodeCraft-22 and Codeforces Round #795 (Div. 2)
qq_65578508的博客
07-22 170
如果一个1从中间移动到最右边可以减少10，如果移动到最左边可以减少1。
CodeCraft-21 and Codeforces Round #711 (Div. 2) C. Planar Reflections
qq_45074215的博客
04-30 174
题意 给定一个衰变期为k的粒子，依次穿过n个墙（从左到右），每次穿过一个墙，都会在运动的反方向生成一个衰变期为k -1 的粒子，这个粒子仍保持原来的衰变期和方向穿下一个墙，生成的粒子沿反方向穿墙。直到粒子的衰变期为1时不在生成粒子。 给定一个n和k输出最后所有的粒子数。 n <= 1000 k <=1000 样例 思路 根据时间复杂度，大概为O(nk) 所有根据复杂度每次枚举衰变期k来确定第i个墙和第i + 1之间的墙之间的的个数。这个个数可以表示为衰变期为k+1朝该方向粒子个数，可以按照最开
2021-03-30 CodeCraft-21 and Codeforces Round #711 (Div. 2)
m0_51250458的博客
03-30 221
这场比赛，只A了一道，暴露了我很多不足的地方。 A. GCD Sum 题意：就是判断一个数和他所有位上的数加起来的值的gcd是否大于一，等于一就对当前数加1，直到两者的gcd大于一。 #include <bits/stdc++.h> using namespace std; typedef long long ll; typedef pair<int, int> PII; ll gcd(ll a, ll b) { if (b == 0) return a; return gc
CodeCraft-21 and Codeforces Round #711 (Div. 2) B. Box Fitting（枚举）
C_Dreamy的博客
03-30 306
const int N=2e6+5; int n,m; int i,j,k; int a[N]; int vis[N]; bool judge() { for(int i=20;i>=0;i--) if(vis[1<<i]) return 0; return 1; } int main() { rush(){ sdd(n,m); for(int i=1;i<=n;i++)...
CodeCraft-21 and Codeforces Round #711 (Div. 2) B. Box Fitting（优先队列）
hz0010的博客
04-15 135
传送门 题意： 给一堆高度为1的小块，长度为2的次幂，给一个长度为W（W肯定大于小块的最大长度）的框，要求把所有小块放进框内，求出最小高度，保证小块不旋转也不重叠； 思路： 用优先队列（默认是大根堆），刚开始push一个W进去，然后遍历每一个小木块的长度，如果小木块放不进去，就开辟新的一行； 代码： #include <iostream> #include <cstring> #include <cmath> #include <string> #includ
CodeCraft-21 and Codeforces Round #711 (Div. 2) D. Bananas in a Microwave(枚举+数学)
C_Dreamy的博客
03-30 673
TLE code： const int N=2e6+5; int n,m; int i,j,k; int a[N]; int vis[N]; vector<int> v; int idx(ll x) { int ans=x/100000; if(x%100000) ans++; return ans; } int main() { while(~sdd(n,m)){ int op...
CodeCraft-21 and Codeforces Round #711 (Div. 2)
neweryyy的博客
03-31 215
传送门 CodeCraft-21 and Codeforces Round #711 (Div. 2) A 333 的倍数各位数字求和依然是 333 的倍数，相邻 333 个数字中必有 111 个满足条件。从小到大枚举 333 个数字即可。 #include <bits/stdc++.h> using namespace std; typedef long long ll; const int maxn = 105; int T; ll N; ll gcd(ll a, ll b) { retu
CodeCraft-22 and Codeforces Round #795 (Div. 2) D. Max GEQ Sum
qq_40329819的博客
06-02 280
CodeCraft-22 and Codeforces Round #795 (Div. 2) D. Max GEQ Sum
CodeCraft-21 and Codeforces Round #711 (Div. 2) 题解
lalalzo的博客
03-31 136
先上链接CodeCraft-21 and Codeforces Round #711 (Div. 2) A： 从n开始往后找，不出几十个 一定能找到的，所以暴力就好了 void sovle(){ cin>>n; while(1) { ll k=n; ll sum=0; while(k) sum+=k%10,k/=10; if(gcd(n,sum)>1) { cout<&lt
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round #628 (Div. 2) A. EhAb AnD gCd
01-03
输入一个正整数x，找出这样的2个正整数a和b，使得gcd(a，b)+lcm(a，b)=x 解题思路 找最特殊的情况a=1,b=x-1即可 这样a,b两个数最大公因数为1，最小公倍数x-1，满足题意√ 附上代码 #include #define int long long #...
Codeforces Round #635 (Div. 2)D. Xenia and Colorful Gems
01-03
题解：6nlogn，先sort三个数组a,b,c, 六次枚举二分查找，再每次min找最小值，例如:先固定数组a，再在数组b,c中利用lower_bound找到第一个大于等于a[i]的数， #pragma GCC optimize(2) #include #define ll long long...
【18】输出字符菱形
2301_78786609的博客
07-19 287
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Held-Karp算法的C++代码
最新发布
m0_61862494的博客
07-19 108
Held-Karp算法是动态规划的一种应用，用于解决旅行商问题 (TSP)。该算法通过记录部分路径的最小成本来避免重复计算，从而有效地降低计算复杂度。Held-Karp算法使用一个状态压缩动态规划表。表示从起点出发，访问过所有由。表示的集合中的节点，并以节点。结束的最小路径长度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 235
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
常见的排序算法，复杂度
m0_61544805的博客
07-16 517
稳定 / 非稳定排序：两个相等的数 排序前后 相对位置不变。 插入排序（希尔排序）： 每一趟将一个待排序记录，按其关键字的大小插入到已排好序的一组记录的适当位置上，直到所有待排序记录全部插入为止。稳定，O(n)，O(1)。 把记录按下标增量（模）分组，对每组进行直接插入排序，每次排序后减小增量，当增量减至 1 时排序完毕。不稳定，不知道（有个实验结论），O(1)。 冒泡排序： 比较相邻的元素，如果第一个比第二个大就进行交换，对每一对相邻元素做同样的工作。稳定，O(n)，O(1)。 选择
codecraft-22 and codeforces round #795 (div. 2)
03-16
codecraft-22 和 codeforces round #795 (div. 2) 是两个编程竞赛的名称。其中，codecraft-22 是由 Codeforces 组织的一场在线编程竞赛，而 codeforces round #795 (div. 2) 则是 Codeforces 的一场常规编程竞赛，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值